From c2c49ebc66f5225f7af0f42ba1342b7801e37750 Mon Sep 17 00:00:00 2001
From: levlam <levlam@telegram.org>
Date: Tue, 16 Nov 2021 12:14:19 +0300
Subject: [PATCH 01/28] Ignore Document parse errors.

---
 td/telegram/Document.hpp | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/td/telegram/Document.hpp b/td/telegram/Document.hpp
index 4b85600f3..c97c279f8 100644
--- a/td/telegram/Document.hpp
+++ b/td/telegram/Document.hpp
@@ -94,7 +94,9 @@ void parse(Document &document, ParserT &parser) {
       break;
     case Document::Type::Unknown:
     default:
-      UNREACHABLE();
+      LOG(ERROR) << "Have invalid Document type " << static_cast<int32>(document.type);
+      document = Document();
+      return;
   }
   if (!document.file_id.is_valid()) {
     LOG(ERROR) << "Parse invalid document.file_id";

From c64cc8ad26bb13193aac4d505a0c1a697317d18b Mon Sep 17 00:00:00 2001
From: levlam <levlam@telegram.org>
Date: Tue, 16 Nov 2021 13:02:07 +0300
Subject: [PATCH 02/28] Move account-related methods to Account.cpp.

---
 CMakeLists.txt                  |   2 +
 td/telegram/Account.cpp         | 255 ++++++++++++++++++++++++++++++++
 td/telegram/Account.h           |  31 ++++
 td/telegram/ContactsManager.cpp | 226 ----------------------------
 td/telegram/ContactsManager.h   |  12 --
 td/telegram/Td.cpp              |  13 +-
 6 files changed, 295 insertions(+), 244 deletions(-)
 create mode 100644 td/telegram/Account.cpp
 create mode 100644 td/telegram/Account.h

diff --git a/CMakeLists.txt b/CMakeLists.txt
index f463608c1..7690676eb 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -276,6 +276,7 @@ set(TDLIB_SOURCE
   td/mtproto/Transport.cpp
   td/mtproto/utils.cpp
 
+  td/telegram/Account.cpp
   td/telegram/AnimationsManager.cpp
   td/telegram/AudiosManager.cpp
   td/telegram/AuthManager.cpp
@@ -453,6 +454,7 @@ set(TDLIB_SOURCE
   td/mtproto/utils.h
 
   td/telegram/AccessRights.h
+  td/telegram/Account.h
   td/telegram/AffectedHistory.h
   td/telegram/AnimationsManager.h
   td/telegram/AudiosManager.h
diff --git a/td/telegram/Account.cpp b/td/telegram/Account.cpp
new file mode 100644
index 000000000..51695fb14
--- /dev/null
+++ b/td/telegram/Account.cpp
@@ -0,0 +1,255 @@
+//
+// Copyright Aliaksei Levin (levlam@telegram.org), Arseny Smirnov (arseny30@gmail.com) 2014-2021
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+#include "td/telegram/Account.h"
+
+#include "td/telegram/DeviceTokenManager.h"
+#include "td/telegram/Global.h"
+#include "td/telegram/net/NetQueryCreator.h"
+#include "td/telegram/Td.h"
+#include "td/telegram/telegram_api.h"
+
+#include "td/actor/actor.h"
+
+#include "td/utils/algorithm.h"
+#include "td/utils/base64.h"
+#include "td/utils/buffer.h"
+#include "td/utils/logging.h"
+#include "td/utils/misc.h"
+#include "td/utils/Slice.h"
+#include "td/utils/Status.h"
+
+#include <algorithm>
+
+namespace td {
+
+static td_api::object_ptr<td_api::session> convert_authorization_object(
+    tl_object_ptr<telegram_api::authorization> &&authorization) {
+  CHECK(authorization != nullptr);
+  return td_api::make_object<td_api::session>(
+      authorization->hash_, authorization->current_, authorization->password_pending_, authorization->api_id_,
+      authorization->app_name_, authorization->app_version_, authorization->official_app_, authorization->device_model_,
+      authorization->platform_, authorization->system_version_, authorization->date_created_,
+      authorization->date_active_, authorization->ip_, authorization->country_, authorization->region_);
+}
+
+class SetAccountTtlQuery final : public Td::ResultHandler {
+  Promise<Unit> promise_;
+
+ public:
+  explicit SetAccountTtlQuery(Promise<Unit> &&promise) : promise_(std::move(promise)) {
+  }
+
+  void send(int32 account_ttl) {
+    send_query(G()->net_query_creator().create(
+        telegram_api::account_setAccountTTL(make_tl_object<telegram_api::accountDaysTTL>(account_ttl))));
+  }
+
+  void on_result(BufferSlice packet) final {
+    auto result_ptr = fetch_result<telegram_api::account_setAccountTTL>(packet);
+    if (result_ptr.is_error()) {
+      return on_error(result_ptr.move_as_error());
+    }
+
+    bool result = result_ptr.move_as_ok();
+    if (!result) {
+      return on_error(Status::Error(500, "Internal Server Error: failed to set account TTL"));
+    }
+
+    promise_.set_value(Unit());
+  }
+
+  void on_error(Status status) final {
+    promise_.set_error(std::move(status));
+  }
+};
+
+class GetAccountTtlQuery final : public Td::ResultHandler {
+  Promise<int32> promise_;
+
+ public:
+  explicit GetAccountTtlQuery(Promise<int32> &&promise) : promise_(std::move(promise)) {
+  }
+
+  void send() {
+    send_query(G()->net_query_creator().create(telegram_api::account_getAccountTTL()));
+  }
+
+  void on_result(BufferSlice packet) final {
+    auto result_ptr = fetch_result<telegram_api::account_getAccountTTL>(packet);
+    if (result_ptr.is_error()) {
+      return on_error(result_ptr.move_as_error());
+    }
+
+    auto ptr = result_ptr.move_as_ok();
+    LOG(INFO) << "Receive result for GetAccountTtlQuery: " << to_string(ptr);
+
+    promise_.set_value(std::move(ptr->days_));
+  }
+
+  void on_error(Status status) final {
+    promise_.set_error(std::move(status));
+  }
+};
+
+class AcceptLoginTokenQuery final : public Td::ResultHandler {
+  Promise<td_api::object_ptr<td_api::session>> promise_;
+
+ public:
+  explicit AcceptLoginTokenQuery(Promise<td_api::object_ptr<td_api::session>> &&promise)
+      : promise_(std::move(promise)) {
+  }
+
+  void send(const string &login_token) {
+    send_query(G()->net_query_creator().create(telegram_api::auth_acceptLoginToken(BufferSlice(login_token))));
+  }
+
+  void on_result(BufferSlice packet) final {
+    auto result_ptr = fetch_result<telegram_api::auth_acceptLoginToken>(packet);
+    if (result_ptr.is_error()) {
+      return on_error(result_ptr.move_as_error());
+    }
+
+    LOG(DEBUG) << "Receive result for AcceptLoginTokenQuery: " << to_string(result_ptr.ok());
+    promise_.set_value(convert_authorization_object(result_ptr.move_as_ok()));
+  }
+
+  void on_error(Status status) final {
+    promise_.set_error(std::move(status));
+  }
+};
+
+class GetAuthorizationsQuery final : public Td::ResultHandler {
+  Promise<td_api::object_ptr<td_api::sessions>> promise_;
+
+ public:
+  explicit GetAuthorizationsQuery(Promise<td_api::object_ptr<td_api::sessions>> &&promise)
+      : promise_(std::move(promise)) {
+  }
+
+  void send() {
+    send_query(G()->net_query_creator().create(telegram_api::account_getAuthorizations()));
+  }
+
+  void on_result(BufferSlice packet) final {
+    auto result_ptr = fetch_result<telegram_api::account_getAuthorizations>(packet);
+    if (result_ptr.is_error()) {
+      return on_error(result_ptr.move_as_error());
+    }
+
+    auto ptr = result_ptr.move_as_ok();
+    LOG(INFO) << "Receive result for GetAuthorizationsQuery: " << to_string(ptr);
+
+    auto results =
+        make_tl_object<td_api::sessions>(transform(std::move(ptr->authorizations_), convert_authorization_object));
+    std::sort(results->sessions_.begin(), results->sessions_.end(),
+              [](const td_api::object_ptr<td_api::session> &lhs, const td_api::object_ptr<td_api::session> &rhs) {
+                if (lhs->is_current_ != rhs->is_current_) {
+                  return lhs->is_current_;
+                }
+                if (lhs->is_password_pending_ != rhs->is_password_pending_) {
+                  return lhs->is_password_pending_;
+                }
+                return lhs->last_active_date_ > rhs->last_active_date_;
+              });
+
+    promise_.set_value(std::move(results));
+  }
+
+  void on_error(Status status) final {
+    promise_.set_error(std::move(status));
+  }
+};
+
+class ResetAuthorizationQuery final : public Td::ResultHandler {
+  Promise<Unit> promise_;
+
+ public:
+  explicit ResetAuthorizationQuery(Promise<Unit> &&promise) : promise_(std::move(promise)) {
+  }
+
+  void send(int64 authorization_id) {
+    send_query(G()->net_query_creator().create(telegram_api::account_resetAuthorization(authorization_id)));
+  }
+
+  void on_result(BufferSlice packet) final {
+    auto result_ptr = fetch_result<telegram_api::account_resetAuthorization>(packet);
+    if (result_ptr.is_error()) {
+      return on_error(result_ptr.move_as_error());
+    }
+
+    bool result = result_ptr.move_as_ok();
+    LOG_IF(WARNING, !result) << "Failed to terminate session";
+    promise_.set_value(Unit());
+  }
+
+  void on_error(Status status) final {
+    promise_.set_error(std::move(status));
+  }
+};
+
+class ResetAuthorizationsQuery final : public Td::ResultHandler {
+  Promise<Unit> promise_;
+
+ public:
+  explicit ResetAuthorizationsQuery(Promise<Unit> &&promise) : promise_(std::move(promise)) {
+  }
+
+  void send() {
+    send_query(G()->net_query_creator().create(telegram_api::auth_resetAuthorizations()));
+  }
+
+  void on_result(BufferSlice packet) final {
+    auto result_ptr = fetch_result<telegram_api::auth_resetAuthorizations>(packet);
+    if (result_ptr.is_error()) {
+      return on_error(result_ptr.move_as_error());
+    }
+
+    bool result = result_ptr.move_as_ok();
+    LOG_IF(WARNING, !result) << "Failed to terminate all sessions";
+    send_closure(td_->device_token_manager_, &DeviceTokenManager::reregister_device);
+    promise_.set_value(Unit());
+  }
+
+  void on_error(Status status) final {
+    promise_.set_error(std::move(status));
+  }
+};
+
+void set_account_ttl(Td *td, int32 account_ttl, Promise<Unit> &&promise) {
+  td->create_handler<SetAccountTtlQuery>(std::move(promise))->send(account_ttl);
+}
+
+void get_account_ttl(Td *td, Promise<int32> &&promise) {
+  td->create_handler<GetAccountTtlQuery>(std::move(promise))->send();
+}
+
+void confirm_qr_code_authentication(Td *td, const string &link,
+                                    Promise<td_api::object_ptr<td_api::session>> &&promise) {
+  Slice prefix("tg://login?token=");
+  if (!begins_with(to_lower(link), prefix)) {
+    return promise.set_error(Status::Error(400, "AUTH_TOKEN_INVALID"));
+  }
+  auto r_token = base64url_decode(Slice(link).substr(prefix.size()));
+  if (r_token.is_error()) {
+    return promise.set_error(Status::Error(400, "AUTH_TOKEN_INVALID"));
+  }
+  td->create_handler<AcceptLoginTokenQuery>(std::move(promise))->send(r_token.ok());
+}
+
+void get_active_sessions(Td *td, Promise<td_api::object_ptr<td_api::sessions>> &&promise) {
+  td->create_handler<GetAuthorizationsQuery>(std::move(promise))->send();
+}
+
+void terminate_session(Td *td, int64 session_id, Promise<Unit> &&promise) {
+  td->create_handler<ResetAuthorizationQuery>(std::move(promise))->send(session_id);
+}
+
+void terminate_all_other_sessions(Td *td, Promise<Unit> &&promise) {
+  td->create_handler<ResetAuthorizationsQuery>(std::move(promise))->send();
+}
+
+}  // namespace td
diff --git a/td/telegram/Account.h b/td/telegram/Account.h
new file mode 100644
index 000000000..288a3ee2c
--- /dev/null
+++ b/td/telegram/Account.h
@@ -0,0 +1,31 @@
+//
+// Copyright Aliaksei Levin (levlam@telegram.org), Arseny Smirnov (arseny30@gmail.com) 2014-2021
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+#pragma once
+
+#include "td/telegram/td_api.h"
+
+#include "td/actor/PromiseFuture.h"
+
+#include "td/utils/common.h"
+
+namespace td {
+
+class Td;
+
+void set_account_ttl(Td *td, int32 account_ttl, Promise<Unit> &&promise);
+
+void get_account_ttl(Td *td, Promise<int32> &&promise);
+
+void confirm_qr_code_authentication(Td *td, const string &link, Promise<td_api::object_ptr<td_api::session>> &&promise);
+
+void get_active_sessions(Td *td, Promise<td_api::object_ptr<td_api::sessions>> &&promise);
+
+void terminate_session(Td *td, int64 session_id, Promise<Unit> &&promise);
+
+void terminate_all_other_sessions(Td *td, Promise<Unit> &&promise);
+
+}  // namespace td
diff --git a/td/telegram/ContactsManager.cpp b/td/telegram/ContactsManager.cpp
index ea2966ab4..31c9594bf 100644
--- a/td/telegram/ContactsManager.cpp
+++ b/td/telegram/ContactsManager.cpp
@@ -54,7 +54,6 @@
 #include "td/actor/SleepActor.h"
 
 #include "td/utils/algorithm.h"
-#include "td/utils/base64.h"
 #include "td/utils/buffer.h"
 #include "td/utils/format.h"
 #include "td/utils/logging.h"
@@ -106,188 +105,6 @@ class DismissSuggestionQuery final : public Td::ResultHandler {
   }
 };
 
-class SetAccountTtlQuery final : public Td::ResultHandler {
-  Promise<Unit> promise_;
-
- public:
-  explicit SetAccountTtlQuery(Promise<Unit> &&promise) : promise_(std::move(promise)) {
-  }
-
-  void send(int32 account_ttl) {
-    send_query(G()->net_query_creator().create(
-        telegram_api::account_setAccountTTL(make_tl_object<telegram_api::accountDaysTTL>(account_ttl))));
-  }
-
-  void on_result(BufferSlice packet) final {
-    auto result_ptr = fetch_result<telegram_api::account_setAccountTTL>(packet);
-    if (result_ptr.is_error()) {
-      return on_error(result_ptr.move_as_error());
-    }
-
-    bool result = result_ptr.move_as_ok();
-    if (!result) {
-      return on_error(Status::Error(500, "Internal Server Error: failed to set account TTL"));
-    }
-
-    promise_.set_value(Unit());
-  }
-
-  void on_error(Status status) final {
-    promise_.set_error(std::move(status));
-  }
-};
-
-class GetAccountTtlQuery final : public Td::ResultHandler {
-  Promise<int32> promise_;
-
- public:
-  explicit GetAccountTtlQuery(Promise<int32> &&promise) : promise_(std::move(promise)) {
-  }
-
-  void send() {
-    send_query(G()->net_query_creator().create(telegram_api::account_getAccountTTL()));
-  }
-
-  void on_result(BufferSlice packet) final {
-    auto result_ptr = fetch_result<telegram_api::account_getAccountTTL>(packet);
-    if (result_ptr.is_error()) {
-      return on_error(result_ptr.move_as_error());
-    }
-
-    auto ptr = result_ptr.move_as_ok();
-    LOG(INFO) << "Receive result for GetAccountTtlQuery: " << to_string(ptr);
-
-    promise_.set_value(std::move(ptr->days_));
-  }
-
-  void on_error(Status status) final {
-    promise_.set_error(std::move(status));
-  }
-};
-
-class AcceptLoginTokenQuery final : public Td::ResultHandler {
-  Promise<td_api::object_ptr<td_api::session>> promise_;
-
- public:
-  explicit AcceptLoginTokenQuery(Promise<td_api::object_ptr<td_api::session>> &&promise)
-      : promise_(std::move(promise)) {
-  }
-
-  void send(const string &login_token) {
-    send_query(G()->net_query_creator().create(telegram_api::auth_acceptLoginToken(BufferSlice(login_token))));
-  }
-
-  void on_result(BufferSlice packet) final {
-    auto result_ptr = fetch_result<telegram_api::auth_acceptLoginToken>(packet);
-    if (result_ptr.is_error()) {
-      return on_error(result_ptr.move_as_error());
-    }
-
-    LOG(DEBUG) << "Receive result for AcceptLoginTokenQuery: " << to_string(result_ptr.ok());
-    promise_.set_value(ContactsManager::convert_authorization_object(result_ptr.move_as_ok()));
-  }
-
-  void on_error(Status status) final {
-    promise_.set_error(std::move(status));
-  }
-};
-
-class GetAuthorizationsQuery final : public Td::ResultHandler {
-  Promise<tl_object_ptr<td_api::sessions>> promise_;
-
- public:
-  explicit GetAuthorizationsQuery(Promise<tl_object_ptr<td_api::sessions>> &&promise) : promise_(std::move(promise)) {
-  }
-
-  void send() {
-    send_query(G()->net_query_creator().create(telegram_api::account_getAuthorizations()));
-  }
-
-  void on_result(BufferSlice packet) final {
-    auto result_ptr = fetch_result<telegram_api::account_getAuthorizations>(packet);
-    if (result_ptr.is_error()) {
-      return on_error(result_ptr.move_as_error());
-    }
-
-    auto ptr = result_ptr.move_as_ok();
-    LOG(INFO) << "Receive result for GetAuthorizationsQuery: " << to_string(ptr);
-
-    auto results = make_tl_object<td_api::sessions>(
-        transform(std::move(ptr->authorizations_), ContactsManager::convert_authorization_object));
-    std::sort(results->sessions_.begin(), results->sessions_.end(),
-              [](const td_api::object_ptr<td_api::session> &lhs, const td_api::object_ptr<td_api::session> &rhs) {
-                if (lhs->is_current_ != rhs->is_current_) {
-                  return lhs->is_current_;
-                }
-                if (lhs->is_password_pending_ != rhs->is_password_pending_) {
-                  return lhs->is_password_pending_;
-                }
-                return lhs->last_active_date_ > rhs->last_active_date_;
-              });
-
-    promise_.set_value(std::move(results));
-  }
-
-  void on_error(Status status) final {
-    promise_.set_error(std::move(status));
-  }
-};
-
-class ResetAuthorizationQuery final : public Td::ResultHandler {
-  Promise<Unit> promise_;
-
- public:
-  explicit ResetAuthorizationQuery(Promise<Unit> &&promise) : promise_(std::move(promise)) {
-  }
-
-  void send(int64 authorization_id) {
-    send_query(G()->net_query_creator().create(telegram_api::account_resetAuthorization(authorization_id)));
-  }
-
-  void on_result(BufferSlice packet) final {
-    auto result_ptr = fetch_result<telegram_api::account_resetAuthorization>(packet);
-    if (result_ptr.is_error()) {
-      return on_error(result_ptr.move_as_error());
-    }
-
-    bool result = result_ptr.move_as_ok();
-    LOG_IF(WARNING, !result) << "Failed to terminate session";
-    promise_.set_value(Unit());
-  }
-
-  void on_error(Status status) final {
-    promise_.set_error(std::move(status));
-  }
-};
-
-class ResetAuthorizationsQuery final : public Td::ResultHandler {
-  Promise<Unit> promise_;
-
- public:
-  explicit ResetAuthorizationsQuery(Promise<Unit> &&promise) : promise_(std::move(promise)) {
-  }
-
-  void send() {
-    send_query(G()->net_query_creator().create(telegram_api::auth_resetAuthorizations()));
-  }
-
-  void on_result(BufferSlice packet) final {
-    auto result_ptr = fetch_result<telegram_api::auth_resetAuthorizations>(packet);
-    if (result_ptr.is_error()) {
-      return on_error(result_ptr.move_as_error());
-    }
-
-    bool result = result_ptr.move_as_ok();
-    LOG_IF(WARNING, !result) << "Failed to terminate all sessions";
-    send_closure(td_->device_token_manager_, &DeviceTokenManager::reregister_device);
-    promise_.set_value(Unit());
-  }
-
-  void on_error(Status status) final {
-    promise_.set_error(std::move(status));
-  }
-};
-
 class GetWebAuthorizationsQuery final : public Td::ResultHandler {
   Promise<tl_object_ptr<td_api::connectedWebsites>> promise_;
 
@@ -5223,49 +5040,6 @@ td_api::object_ptr<td_api::CheckChatUsernameResult> ContactsManager::get_check_c
   }
 }
 
-void ContactsManager::set_account_ttl(int32 account_ttl, Promise<Unit> &&promise) const {
-  td_->create_handler<SetAccountTtlQuery>(std::move(promise))->send(account_ttl);
-}
-
-void ContactsManager::get_account_ttl(Promise<int32> &&promise) const {
-  td_->create_handler<GetAccountTtlQuery>(std::move(promise))->send();
-}
-
-td_api::object_ptr<td_api::session> ContactsManager::convert_authorization_object(
-    tl_object_ptr<telegram_api::authorization> &&authorization) {
-  CHECK(authorization != nullptr);
-  return td_api::make_object<td_api::session>(
-      authorization->hash_, authorization->current_, authorization->password_pending_, authorization->api_id_,
-      authorization->app_name_, authorization->app_version_, authorization->official_app_, authorization->device_model_,
-      authorization->platform_, authorization->system_version_, authorization->date_created_,
-      authorization->date_active_, authorization->ip_, authorization->country_, authorization->region_);
-}
-
-void ContactsManager::confirm_qr_code_authentication(const string &link,
-                                                     Promise<td_api::object_ptr<td_api::session>> &&promise) {
-  Slice prefix("tg://login?token=");
-  if (!begins_with(to_lower(link), prefix)) {
-    return promise.set_error(Status::Error(400, "AUTH_TOKEN_INVALID"));
-  }
-  auto r_token = base64url_decode(Slice(link).substr(prefix.size()));
-  if (r_token.is_error()) {
-    return promise.set_error(Status::Error(400, "AUTH_TOKEN_INVALID"));
-  }
-  td_->create_handler<AcceptLoginTokenQuery>(std::move(promise))->send(r_token.ok());
-}
-
-void ContactsManager::get_active_sessions(Promise<tl_object_ptr<td_api::sessions>> &&promise) const {
-  td_->create_handler<GetAuthorizationsQuery>(std::move(promise))->send();
-}
-
-void ContactsManager::terminate_session(int64 session_id, Promise<Unit> &&promise) const {
-  td_->create_handler<ResetAuthorizationQuery>(std::move(promise))->send(session_id);
-}
-
-void ContactsManager::terminate_all_other_sessions(Promise<Unit> &&promise) const {
-  td_->create_handler<ResetAuthorizationsQuery>(std::move(promise))->send();
-}
-
 void ContactsManager::get_connected_websites(Promise<tl_object_ptr<td_api::connectedWebsites>> &&promise) const {
   td_->create_handler<GetWebAuthorizationsQuery>(std::move(promise))->send();
 }
diff --git a/td/telegram/ContactsManager.h b/td/telegram/ContactsManager.h
index 5abd303dd..b9edd83a8 100644
--- a/td/telegram/ContactsManager.h
+++ b/td/telegram/ContactsManager.h
@@ -273,18 +273,6 @@ class ContactsManager final : public Actor {
   static td_api::object_ptr<td_api::CheckChatUsernameResult> get_check_chat_username_result_object(
       CheckDialogUsernameResult result);
 
-  void set_account_ttl(int32 account_ttl, Promise<Unit> &&promise) const;
-  void get_account_ttl(Promise<int32> &&promise) const;
-
-  static td_api::object_ptr<td_api::session> convert_authorization_object(
-      tl_object_ptr<telegram_api::authorization> &&authorization);
-
-  void confirm_qr_code_authentication(const string &link, Promise<td_api::object_ptr<td_api::session>> &&promise);
-
-  void get_active_sessions(Promise<tl_object_ptr<td_api::sessions>> &&promise) const;
-  void terminate_session(int64 session_id, Promise<Unit> &&promise) const;
-  void terminate_all_other_sessions(Promise<Unit> &&promise) const;
-
   void get_connected_websites(Promise<tl_object_ptr<td_api::connectedWebsites>> &&promise) const;
   void disconnect_website(int64 website_id, Promise<Unit> &&promise) const;
   void disconnect_all_websites(Promise<Unit> &&promise) const;
diff --git a/td/telegram/Td.cpp b/td/telegram/Td.cpp
index 8d315b595..2a924a21c 100644
--- a/td/telegram/Td.cpp
+++ b/td/telegram/Td.cpp
@@ -6,6 +6,7 @@
 //
 #include "td/telegram/Td.h"
 
+#include "td/telegram/Account.h"
 #include "td/telegram/AnimationsManager.h"
 #include "td/telegram/AudiosManager.h"
 #include "td/telegram/AuthManager.h"
@@ -4538,7 +4539,7 @@ void Td::on_request(uint64 id, td_api::checkAuthenticationBotToken &request) {
 void Td::on_request(uint64 id, td_api::confirmQrCodeAuthentication &request) {
   CLEAN_INPUT_STRING(request.link_);
   CREATE_REQUEST_PROMISE();
-  contacts_manager_->confirm_qr_code_authentication(request.link_, std::move(promise));
+  confirm_qr_code_authentication(this, request.link_, std::move(promise));
 }
 
 void Td::on_request(uint64 id, const td_api::getCurrentState &request) {
@@ -4733,7 +4734,7 @@ void Td::on_request(uint64 id, const td_api::getAccountTtl &request) {
       promise.set_value(td_api::make_object<td_api::accountTtl>(result.ok()));
     }
   });
-  contacts_manager_->get_account_ttl(std::move(query_promise));
+  get_account_ttl(this, std::move(query_promise));
 }
 
 void Td::on_request(uint64 id, const td_api::setAccountTtl &request) {
@@ -4742,7 +4743,7 @@ void Td::on_request(uint64 id, const td_api::setAccountTtl &request) {
     return send_error_raw(id, 400, "New account TTL must be non-empty");
   }
   CREATE_OK_REQUEST_PROMISE();
-  contacts_manager_->set_account_ttl(request.ttl_->days_, std::move(promise));
+  set_account_ttl(this, request.ttl_->days_, std::move(promise));
 }
 
 void Td::on_request(uint64 id, td_api::deleteAccount &request) {
@@ -4772,19 +4773,19 @@ void Td::on_request(uint64 id, td_api::resendChangePhoneNumberCode &request) {
 void Td::on_request(uint64 id, const td_api::getActiveSessions &request) {
   CHECK_IS_USER();
   CREATE_REQUEST_PROMISE();
-  contacts_manager_->get_active_sessions(std::move(promise));
+  get_active_sessions(this, std::move(promise));
 }
 
 void Td::on_request(uint64 id, const td_api::terminateSession &request) {
   CHECK_IS_USER();
   CREATE_OK_REQUEST_PROMISE();
-  contacts_manager_->terminate_session(request.session_id_, std::move(promise));
+  terminate_session(this, request.session_id_, std::move(promise));
 }
 
 void Td::on_request(uint64 id, const td_api::terminateAllOtherSessions &request) {
   CHECK_IS_USER();
   CREATE_OK_REQUEST_PROMISE();
-  contacts_manager_->terminate_all_other_sessions(std::move(promise));
+  terminate_all_other_sessions(this, std::move(promise));
 }
 
 void Td::on_request(uint64 id, const td_api::getConnectedWebsites &request) {

From 36d4de747f6b9e4fa1eb53d310c8e61c9c8e2097 Mon Sep 17 00:00:00 2001
From: levlam <levlam@telegram.org>
Date: Tue, 16 Nov 2021 13:13:06 +0300
Subject: [PATCH 03/28] Move website authorization functions to Account.cpp.

---
 td/telegram/Account.cpp         | 118 +++++++++++++++++++++++++++++++-
 td/telegram/Account.h           |   6 ++
 td/telegram/ContactsManager.cpp | 114 ------------------------------
 td/telegram/ContactsManager.h   |   4 --
 td/telegram/Td.cpp              |   6 +-
 5 files changed, 126 insertions(+), 122 deletions(-)

diff --git a/td/telegram/Account.cpp b/td/telegram/Account.cpp
index 51695fb14..ed83b2a64 100644
--- a/td/telegram/Account.cpp
+++ b/td/telegram/Account.cpp
@@ -6,11 +6,13 @@
 //
 #include "td/telegram/Account.h"
 
+#include "td/telegram/ContactsManager.h"
 #include "td/telegram/DeviceTokenManager.h"
 #include "td/telegram/Global.h"
 #include "td/telegram/net/NetQueryCreator.h"
 #include "td/telegram/Td.h"
 #include "td/telegram/telegram_api.h"
+#include "td/telegram/UserId.h"
 
 #include "td/actor/actor.h"
 
@@ -144,7 +146,7 @@ class GetAuthorizationsQuery final : public Td::ResultHandler {
     LOG(INFO) << "Receive result for GetAuthorizationsQuery: " << to_string(ptr);
 
     auto results =
-        make_tl_object<td_api::sessions>(transform(std::move(ptr->authorizations_), convert_authorization_object));
+        td_api::make_object<td_api::sessions>(transform(std::move(ptr->authorizations_), convert_authorization_object));
     std::sort(results->sessions_.begin(), results->sessions_.end(),
               [](const td_api::object_ptr<td_api::session> &lhs, const td_api::object_ptr<td_api::session> &rhs) {
                 if (lhs->is_current_ != rhs->is_current_) {
@@ -219,6 +221,108 @@ class ResetAuthorizationsQuery final : public Td::ResultHandler {
   }
 };
 
+class GetWebAuthorizationsQuery final : public Td::ResultHandler {
+  Promise<td_api::object_ptr<td_api::connectedWebsites>> promise_;
+
+ public:
+  explicit GetWebAuthorizationsQuery(Promise<td_api::object_ptr<td_api::connectedWebsites>> &&promise)
+      : promise_(std::move(promise)) {
+  }
+
+  void send() {
+    send_query(G()->net_query_creator().create(telegram_api::account_getWebAuthorizations()));
+  }
+
+  void on_result(BufferSlice packet) final {
+    auto result_ptr = fetch_result<telegram_api::account_getWebAuthorizations>(packet);
+    if (result_ptr.is_error()) {
+      return on_error(result_ptr.move_as_error());
+    }
+
+    auto ptr = result_ptr.move_as_ok();
+    LOG(INFO) << "Receive result for GetWebAuthorizationsQuery: " << to_string(ptr);
+
+    td_->contacts_manager_->on_get_users(std::move(ptr->users_), "GetWebAuthorizationsQuery");
+
+    auto results = td_api::make_object<td_api::connectedWebsites>();
+    results->websites_.reserve(ptr->authorizations_.size());
+    for (auto &authorization : ptr->authorizations_) {
+      CHECK(authorization != nullptr);
+      UserId bot_user_id(authorization->bot_id_);
+      if (!bot_user_id.is_valid()) {
+        LOG(ERROR) << "Receive invalid bot " << bot_user_id;
+        bot_user_id = UserId();
+      }
+
+      results->websites_.push_back(td_api::make_object<td_api::connectedWebsite>(
+          authorization->hash_, authorization->domain_,
+          td_->contacts_manager_->get_user_id_object(bot_user_id, "GetWebAuthorizationsQuery"), authorization->browser_,
+          authorization->platform_, authorization->date_created_, authorization->date_active_, authorization->ip_,
+          authorization->region_));
+    }
+
+    promise_.set_value(std::move(results));
+  }
+
+  void on_error(Status status) final {
+    promise_.set_error(std::move(status));
+  }
+};
+
+class ResetWebAuthorizationQuery final : public Td::ResultHandler {
+  Promise<Unit> promise_;
+
+ public:
+  explicit ResetWebAuthorizationQuery(Promise<Unit> &&promise) : promise_(std::move(promise)) {
+  }
+
+  void send(int64 hash) {
+    send_query(G()->net_query_creator().create(telegram_api::account_resetWebAuthorization(hash)));
+  }
+
+  void on_result(BufferSlice packet) final {
+    auto result_ptr = fetch_result<telegram_api::account_resetWebAuthorization>(packet);
+    if (result_ptr.is_error()) {
+      return on_error(result_ptr.move_as_error());
+    }
+
+    bool result = result_ptr.move_as_ok();
+    LOG_IF(WARNING, !result) << "Failed to disconnect website";
+    promise_.set_value(Unit());
+  }
+
+  void on_error(Status status) final {
+    promise_.set_error(std::move(status));
+  }
+};
+
+class ResetWebAuthorizationsQuery final : public Td::ResultHandler {
+  Promise<Unit> promise_;
+
+ public:
+  explicit ResetWebAuthorizationsQuery(Promise<Unit> &&promise) : promise_(std::move(promise)) {
+  }
+
+  void send() {
+    send_query(G()->net_query_creator().create(telegram_api::account_resetWebAuthorizations()));
+  }
+
+  void on_result(BufferSlice packet) final {
+    auto result_ptr = fetch_result<telegram_api::account_resetWebAuthorizations>(packet);
+    if (result_ptr.is_error()) {
+      return on_error(result_ptr.move_as_error());
+    }
+
+    bool result = result_ptr.move_as_ok();
+    LOG_IF(WARNING, !result) << "Failed to disconnect all websites";
+    promise_.set_value(Unit());
+  }
+
+  void on_error(Status status) final {
+    promise_.set_error(std::move(status));
+  }
+};
+
 void set_account_ttl(Td *td, int32 account_ttl, Promise<Unit> &&promise) {
   td->create_handler<SetAccountTtlQuery>(std::move(promise))->send(account_ttl);
 }
@@ -252,4 +356,16 @@ void terminate_all_other_sessions(Td *td, Promise<Unit> &&promise) {
   td->create_handler<ResetAuthorizationsQuery>(std::move(promise))->send();
 }
 
+void get_connected_websites(Td *td, Promise<td_api::object_ptr<td_api::connectedWebsites>> &&promise) {
+  td->create_handler<GetWebAuthorizationsQuery>(std::move(promise))->send();
+}
+
+void disconnect_website(Td *td, int64 website_id, Promise<Unit> &&promise) {
+  td->create_handler<ResetWebAuthorizationQuery>(std::move(promise))->send(website_id);
+}
+
+void disconnect_all_websites(Td *td, Promise<Unit> &&promise) {
+  td->create_handler<ResetWebAuthorizationsQuery>(std::move(promise))->send();
+}
+
 }  // namespace td
diff --git a/td/telegram/Account.h b/td/telegram/Account.h
index 288a3ee2c..6ac45d644 100644
--- a/td/telegram/Account.h
+++ b/td/telegram/Account.h
@@ -28,4 +28,10 @@ void terminate_session(Td *td, int64 session_id, Promise<Unit> &&promise);
 
 void terminate_all_other_sessions(Td *td, Promise<Unit> &&promise);
 
+void get_connected_websites(Td *td, Promise<td_api::object_ptr<td_api::connectedWebsites>> &&promise);
+
+void disconnect_website(Td *td, int64 website_id, Promise<Unit> &&promise);
+
+void disconnect_all_websites(Td *td, Promise<Unit> &&promise);
+
 }  // namespace td
diff --git a/td/telegram/ContactsManager.cpp b/td/telegram/ContactsManager.cpp
index 31c9594bf..feba1b1ed 100644
--- a/td/telegram/ContactsManager.cpp
+++ b/td/telegram/ContactsManager.cpp
@@ -105,108 +105,6 @@ class DismissSuggestionQuery final : public Td::ResultHandler {
   }
 };
 
-class GetWebAuthorizationsQuery final : public Td::ResultHandler {
-  Promise<tl_object_ptr<td_api::connectedWebsites>> promise_;
-
- public:
-  explicit GetWebAuthorizationsQuery(Promise<tl_object_ptr<td_api::connectedWebsites>> &&promise)
-      : promise_(std::move(promise)) {
-  }
-
-  void send() {
-    send_query(G()->net_query_creator().create(telegram_api::account_getWebAuthorizations()));
-  }
-
-  void on_result(BufferSlice packet) final {
-    auto result_ptr = fetch_result<telegram_api::account_getWebAuthorizations>(packet);
-    if (result_ptr.is_error()) {
-      return on_error(result_ptr.move_as_error());
-    }
-
-    auto ptr = result_ptr.move_as_ok();
-    LOG(INFO) << "Receive result for GetWebAuthorizationsQuery: " << to_string(ptr);
-
-    td_->contacts_manager_->on_get_users(std::move(ptr->users_), "GetWebAuthorizationsQuery");
-
-    auto results = make_tl_object<td_api::connectedWebsites>();
-    results->websites_.reserve(ptr->authorizations_.size());
-    for (auto &authorization : ptr->authorizations_) {
-      CHECK(authorization != nullptr);
-      UserId bot_user_id(authorization->bot_id_);
-      if (!bot_user_id.is_valid()) {
-        LOG(ERROR) << "Receive invalid bot " << bot_user_id;
-        bot_user_id = UserId();
-      }
-
-      results->websites_.push_back(make_tl_object<td_api::connectedWebsite>(
-          authorization->hash_, authorization->domain_,
-          td_->contacts_manager_->get_user_id_object(bot_user_id, "GetWebAuthorizationsQuery"), authorization->browser_,
-          authorization->platform_, authorization->date_created_, authorization->date_active_, authorization->ip_,
-          authorization->region_));
-    }
-
-    promise_.set_value(std::move(results));
-  }
-
-  void on_error(Status status) final {
-    promise_.set_error(std::move(status));
-  }
-};
-
-class ResetWebAuthorizationQuery final : public Td::ResultHandler {
-  Promise<Unit> promise_;
-
- public:
-  explicit ResetWebAuthorizationQuery(Promise<Unit> &&promise) : promise_(std::move(promise)) {
-  }
-
-  void send(int64 hash) {
-    send_query(G()->net_query_creator().create(telegram_api::account_resetWebAuthorization(hash)));
-  }
-
-  void on_result(BufferSlice packet) final {
-    auto result_ptr = fetch_result<telegram_api::account_resetWebAuthorization>(packet);
-    if (result_ptr.is_error()) {
-      return on_error(result_ptr.move_as_error());
-    }
-
-    bool result = result_ptr.move_as_ok();
-    LOG_IF(WARNING, !result) << "Failed to disconnect website";
-    promise_.set_value(Unit());
-  }
-
-  void on_error(Status status) final {
-    promise_.set_error(std::move(status));
-  }
-};
-
-class ResetWebAuthorizationsQuery final : public Td::ResultHandler {
-  Promise<Unit> promise_;
-
- public:
-  explicit ResetWebAuthorizationsQuery(Promise<Unit> &&promise) : promise_(std::move(promise)) {
-  }
-
-  void send() {
-    send_query(G()->net_query_creator().create(telegram_api::account_resetWebAuthorizations()));
-  }
-
-  void on_result(BufferSlice packet) final {
-    auto result_ptr = fetch_result<telegram_api::account_resetWebAuthorizations>(packet);
-    if (result_ptr.is_error()) {
-      return on_error(result_ptr.move_as_error());
-    }
-
-    bool result = result_ptr.move_as_ok();
-    LOG_IF(WARNING, !result) << "Failed to disconnect all websites";
-    promise_.set_value(Unit());
-  }
-
-  void on_error(Status status) final {
-    promise_.set_error(std::move(status));
-  }
-};
-
 class GetContactsQuery final : public Td::ResultHandler {
  public:
   void send(int64 hash) {
@@ -5040,18 +4938,6 @@ td_api::object_ptr<td_api::CheckChatUsernameResult> ContactsManager::get_check_c
   }
 }
 
-void ContactsManager::get_connected_websites(Promise<tl_object_ptr<td_api::connectedWebsites>> &&promise) const {
-  td_->create_handler<GetWebAuthorizationsQuery>(std::move(promise))->send();
-}
-
-void ContactsManager::disconnect_website(int64 website_id, Promise<Unit> &&promise) const {
-  td_->create_handler<ResetWebAuthorizationQuery>(std::move(promise))->send(website_id);
-}
-
-void ContactsManager::disconnect_all_websites(Promise<Unit> &&promise) const {
-  td_->create_handler<ResetWebAuthorizationsQuery>(std::move(promise))->send();
-}
-
 bool ContactsManager::is_valid_username(const string &username) {
   if (username.size() < 5 || username.size() > 32) {
     return false;
diff --git a/td/telegram/ContactsManager.h b/td/telegram/ContactsManager.h
index b9edd83a8..b7336ea02 100644
--- a/td/telegram/ContactsManager.h
+++ b/td/telegram/ContactsManager.h
@@ -273,10 +273,6 @@ class ContactsManager final : public Actor {
   static td_api::object_ptr<td_api::CheckChatUsernameResult> get_check_chat_username_result_object(
       CheckDialogUsernameResult result);
 
-  void get_connected_websites(Promise<tl_object_ptr<td_api::connectedWebsites>> &&promise) const;
-  void disconnect_website(int64 website_id, Promise<Unit> &&promise) const;
-  void disconnect_all_websites(Promise<Unit> &&promise) const;
-
   void add_contact(Contact contact, bool share_phone_number, Promise<Unit> &&promise);
 
   std::pair<vector<UserId>, vector<int32>> import_contacts(const vector<Contact> &contacts, int64 &random_id,
diff --git a/td/telegram/Td.cpp b/td/telegram/Td.cpp
index 2a924a21c..0256df71c 100644
--- a/td/telegram/Td.cpp
+++ b/td/telegram/Td.cpp
@@ -4791,19 +4791,19 @@ void Td::on_request(uint64 id, const td_api::terminateAllOtherSessions &request)
 void Td::on_request(uint64 id, const td_api::getConnectedWebsites &request) {
   CHECK_IS_USER();
   CREATE_REQUEST_PROMISE();
-  contacts_manager_->get_connected_websites(std::move(promise));
+  get_connected_websites(this, std::move(promise));
 }
 
 void Td::on_request(uint64 id, const td_api::disconnectWebsite &request) {
   CHECK_IS_USER();
   CREATE_OK_REQUEST_PROMISE();
-  contacts_manager_->disconnect_website(request.website_id_, std::move(promise));
+  disconnect_website(this, request.website_id_, std::move(promise));
 }
 
 void Td::on_request(uint64 id, const td_api::disconnectAllWebsites &request) {
   CHECK_IS_USER();
   CREATE_OK_REQUEST_PROMISE();
-  contacts_manager_->disconnect_all_websites(std::move(promise));
+  disconnect_all_websites(this, std::move(promise));
 }
 
 void Td::on_request(uint64 id, const td_api::getMe &request) {

From 04736f363be5385a9729dcea9d26186f236dca71 Mon Sep 17 00:00:00 2001
From: 23rd <23rd@vivaldi.net>
Date: Wed, 17 Nov 2021 08:26:44 +0300
Subject: [PATCH 04/28] Fixed processing of speaking action in channels to form
 recent speakers.

---
 td/telegram/MessagesManager.cpp | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/td/telegram/MessagesManager.cpp b/td/telegram/MessagesManager.cpp
index 9261d1067..ae1af1bfa 100644
--- a/td/telegram/MessagesManager.cpp
+++ b/td/telegram/MessagesManager.cpp
@@ -6970,7 +6970,7 @@ void MessagesManager::on_update_delete_scheduled_messages(DialogId dialog_id,
 void MessagesManager::on_user_dialog_action(DialogId dialog_id, MessageId top_thread_message_id,
                                             DialogId typing_dialog_id, DialogAction action, int32 date,
                                             MessageContentType message_content_type) {
-  if (td_->auth_manager_->is_bot() || !typing_dialog_id.is_valid() || is_broadcast_channel(dialog_id)) {
+  if (td_->auth_manager_->is_bot() || !typing_dialog_id.is_valid()) {
     return;
   }
   if (top_thread_message_id != MessageId() && !top_thread_message_id.is_valid()) {
@@ -6992,6 +6992,10 @@ void MessagesManager::on_user_dialog_action(DialogId dialog_id, MessageId top_th
     return;
   }
 
+  if (is_broadcast_channel(dialog_id)) {
+    return;
+  }
+
   if (typing_dialog_id.get_type() != DialogType::User) {
     LOG(ERROR) << "Ignore " << action << " of " << typing_dialog_id << " in " << dialog_id;
     return;

From e7dfed10a52ae892c984798ebf065f6161a04b5a Mon Sep 17 00:00:00 2001
From: levlam <levlam@telegram.org>
Date: Wed, 17 Nov 2021 09:07:23 +0300
Subject: [PATCH 05/28] Increase performance warning time to a reasonable
 value.

---
 tddb/td/db/SqliteDb.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tddb/td/db/SqliteDb.cpp b/tddb/td/db/SqliteDb.cpp
index 910374b26..6675879f4 100644
--- a/tddb/td/db/SqliteDb.cpp
+++ b/tddb/td/db/SqliteDb.cpp
@@ -244,7 +244,7 @@ optional<int32> SqliteDb::get_cipher_version() const {
 
 Result<SqliteDb> SqliteDb::change_key(CSlice path, bool allow_creation, const DbKey &new_db_key,
                                       const DbKey &old_db_key) {
-  PerfWarningTimer perf("change key", 0.001);
+  PerfWarningTimer perf("change key", 0.05);
 
   // fast path
   {

From 4e802d67ca56336eae2e7859dd786f8298e92f50 Mon Sep 17 00:00:00 2001
From: levlam <levlam@telegram.org>
Date: Wed, 17 Nov 2021 09:09:01 +0300
Subject: [PATCH 06/28] Move out user_version logging from WARNING.

---
 td/telegram/TdDb.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/td/telegram/TdDb.cpp b/td/telegram/TdDb.cpp
index 56c09e075..b37fbfaf9 100644
--- a/td/telegram/TdDb.cpp
+++ b/td/telegram/TdDb.cpp
@@ -315,7 +315,7 @@ Status TdDb::init_sqlite(int32 scheduler_id, const TdParameters &parameters, con
 
   // Get 'PRAGMA user_version'
   TRY_RESULT(user_version, db.user_version());
-  LOG(WARNING) << "Got PRAGMA user_version = " << user_version;
+  LOG(INFO) << "Got PRAGMA user_version = " << user_version;
 
   // init DialogDb
   bool dialog_db_was_created = false;

From fb39e5d74667db915a75a5e58065c59af8e7d8d6 Mon Sep 17 00:00:00 2001
From: levlam <levlam@telegram.org>
Date: Wed, 17 Nov 2021 15:15:40 +0300
Subject: [PATCH 07/28] SImplify StackAllocator::Ptr implementation.

---
 tdutils/td/utils/StackAllocator.h | 58 ++++++++++++++++---------------
 1 file changed, 30 insertions(+), 28 deletions(-)

diff --git a/tdutils/td/utils/StackAllocator.h b/tdutils/td/utils/StackAllocator.h
index e9f5d3b00..849d90421 100644
--- a/tdutils/td/utils/StackAllocator.h
+++ b/tdutils/td/utils/StackAllocator.h
@@ -7,76 +7,78 @@
 #pragma once
 
 #include "td/utils/common.h"
-#include "td/utils/MovableValue.h"
 #include "td/utils/Slice.h"
 
 #include <array>
 #include <cstdlib>
-#include <memory>
 
 namespace td {
 
 class StackAllocator {
-  class Deleter {
-   public:
-    void operator()(char *ptr) {
-      free_ptr(ptr);
-    }
-  };
-
   // TODO: alloc memory with mmap and unload unused pages
   // memory still can be corrupted, but it is better than explicit free function
-  // TODO: use pointer that can't be even copied
-  using PtrImpl = std::unique_ptr<char, Deleter>;
   class Ptr {
    public:
-    Ptr(char *ptr, size_t size) : ptr_(ptr), size_(size) {
+    Ptr(char *ptr, size_t size) : slice_(ptr, size) {
+    }
+    Ptr(const Ptr &other) = delete;
+    Ptr &operator=(const Ptr &other) = delete;
+    Ptr(Ptr &&other) noexcept : slice_(other.slice_) {
+      other.slice_ = MutableSlice();
+    }
+    Ptr &operator=(Ptr &&other) = delete;
+    ~Ptr() {
+      if (!slice_.empty()) {
+        free_ptr(slice_.data(), slice_.size());
+      }
     }
 
     MutableSlice as_slice() const {
-      return MutableSlice(ptr_.get(), size_.get());
+      return slice_;
     }
 
    private:
-    PtrImpl ptr_;
-    MovableValue<size_t> size_;
+    MutableSlice slice_;
   };
 
-  static void free_ptr(char *ptr) {
-    impl().free_ptr(ptr);
-  }
-
   struct Impl {
     static const size_t MEM_SIZE = 1024 * 1024;
     std::array<char, MEM_SIZE> mem;
 
     size_t pos{0};
-    char *alloc(size_t size) {
+    Ptr alloc(size_t size) {
       if (size == 0) {
-        size = 1;
+        size = 8;
+      } else {
+        if (size > MEM_SIZE) {
+          std::abort();  // too much memory requested
+        }
+        size = (size + 7) & -8;
       }
       char *res = mem.data() + pos;
-      size = (size + 7) & -8;
       pos += size;
       if (pos > MEM_SIZE) {
         std::abort();  // memory is over
       }
-      return res;
+      return Ptr(res, size);
     }
-    void free_ptr(char *ptr) {
-      size_t new_pos = ptr - mem.data();
-      if (new_pos >= pos) {
+    void free_ptr(char *ptr, size_t size) {
+      if (size > pos || ptr != mem.data() + (pos - size)) {
         std::abort();  // shouldn't happen
       }
-      pos = new_pos;
+      pos -= size;
     }
   };
 
   static Impl &impl();
 
+  static void free_ptr(char *ptr, size_t size) {
+    impl().free_ptr(ptr, size);
+  }
+
  public:
   static Ptr alloc(size_t size) {
-    return Ptr(impl().alloc(size), size);
+    return impl().alloc(size);
   }
 };
 

From bf9c78e982f921e646ccd16570a50ad37af5b7f4 Mon Sep 17 00:00:00 2001
From: levlam <levlam@telegram.org>
Date: Thu, 18 Nov 2021 14:37:31 +0300
Subject: [PATCH 08/28] Fix is_emoji.

---
 tdutils/td/utils/emoji.cpp | 1249 ++++++++++++++++--------------------
 tdutils/test/misc.cpp      |    2 +
 2 files changed, 541 insertions(+), 710 deletions(-)

diff --git a/tdutils/td/utils/emoji.cpp b/tdutils/td/utils/emoji.cpp
index 6243c8996..022dee8e6 100644
--- a/tdutils/td/utils/emoji.cpp
+++ b/tdutils/td/utils/emoji.cpp
@@ -75,291 +75,206 @@ bool is_emoji(Slice str) {
       "🪢", "🪣", "🪤", "🪥", "🪦", "🪧", "🪨", "🪩", "🪪", "🪫", "🪬", "🪰", "🪱", "🪲",
       "🪳", "🪴", "🪵", "🪶", "🪷", "🪸", "🪹", "🪺", "🫀", "🫁", "🫂", "🫃", "🫄", "🫅",
       "🫐", "🫑", "🫒", "🫓", "🫔", "🫕", "🫖", "🫗", "🫘", "🫙", "🫠", "🫡", "🫢", "🫣",
-      "🫤", "🫥", "🫦", "🫧", "🫰", "🫱", "🫲", "🫳", "🫴", "🫵", "🫶", "©", "®", "‼", "⁉", "™",
-      "ℹ", "↔", "↕", "↖", "↗", "↘", "↙", "↩", "↪", "⌨", "⏏", "⏭", "⏮", "⏯", "⏱", "⏲", "⏸", "⏹", "⏺", "Ⓜ", "▪",
-      "▫", "▶", "◀", "◻", "◼", "☀", "☁", "☂", "☃", "☄", "☎", "☑", "☘", "☝", "☠", "☢", "☣", "☦", "☪", "☮", "☯", "☸", "☹",
-      "☺", "♀", "♂", "♟", "♠", "♣", "♥", "♦", "♨", "♻", "♾", "⚒", "⚔", "⚕", "⚖", "⚗", "⚙", "⚛", "⚜", "⚠", "⚧", "⚰", "⚱",
-      "⛈", "⛏", "⛑", "⛓", "⛩", "⛰", "⛱", "⛴", "⛷", "⛸", "⛹", "✂", "✈", "✉", "✌", "✍", "✏", "✒", "✔", "✖", "✝", "✡", "✳",
-      "✴", "❄", "❇", "❣", "❤", "➡", "⤴", "⤵", "⬅", "⬆", "⬇", "〰", "〽", "㊗", "㊙", "🅰", "🅱", "🅾", "🅿", "🈂", "🈷",
-      "🌡", "🌤", "🌥", "🌦", "🌧", "🌨", "🌩", "🌪", "🌫", "🌬", "🌶", "🍽", "🎖", "🎗",
-      "🎙", "🎚", "🎛", "🎞", "🎟", "🏋", "🏌", "🏍", "🏎", "🏔", "🏕", "🏖", "🏗", "🏘",
-      "🏙", "🏚", "🏛", "🏜", "🏝", "🏞", "🏟", "🏳", "🏵", "🏷", "🐿", "👁", "📽", "🕉",
-      "🕊", "🕯", "🕰", "🕳", "🕴", "🕵", "🕶", "🕷", "🕸", "🕹", "🖇", "🖊", "🖋", "🖌",
-      "🖍", "🖐", "🖥", "🖨", "🖱", "🖲", "🖼", "🗂", "🗃", "🗄", "🗑", "🗒", "🗓", "🗜",
-      "🗝", "🗞", "🗡", "🗣", "🗨", "🗯", "🗳", "🗺", "🛋", "🛍", "🛎", "🛏", "🛠", "🛡",
-      "🛢", "🛣", "🛤", "🛥", "🛩", "🛰", "🛳", "#⃣", "#️⃣", "*⃣", "*️⃣", "0⃣", "0️⃣", "1⃣",
-      "1️⃣", "2⃣", "2️⃣", "3⃣", "3️⃣", "4⃣", "4️⃣", "5⃣", "5️⃣", "6⃣", "6️⃣", "7⃣", "7️⃣", "8⃣",
-      "8️⃣", "9⃣", "9️⃣", "🇦🇨", "🇦🇨", "🇦🇩", "🇦🇩", "🇦🇪", "🇦🇪", "🇦🇫", "🇦🇫", "🇦🇬", "🇦🇬", "🇦🇮", "🇦🇮", "🇦🇱", "🇦🇱",
-      "🇦🇲", "🇦🇲", "🇦🇴", "🇦🇴", "🇦🇶", "🇦🇶", "🇦🇷", "🇦🇷", "🇦🇸", "🇦🇸", "🇦🇹", "🇦🇹", "🇦🇺", "🇦🇺", "🇦🇼", "🇦🇼", "🇦🇽", "🇦🇽", "🇦🇿",
-      "🇦🇿", "🇧🇦", "🇧🇦", "🇧🇧", "🇧🇧", "🇧🇩", "🇧🇩", "🇧🇪", "🇧🇪", "🇧🇫", "🇧🇫", "🇧🇬", "🇧🇬", "🇧🇭", "🇧🇭", "🇧🇮", "🇧🇮", "🇧🇯", "🇧🇯",
-      "🇧🇱", "🇧🇱", "🇧🇲", "🇧🇲", "🇧🇳", "🇧🇳", "🇧🇴", "🇧🇴", "🇧🇶", "🇧🇶", "🇧🇷", "🇧🇷", "🇧🇸", "🇧🇸", "🇧🇹", "🇧🇹", "🇧🇻", "🇧🇻", "🇧🇼",
-      "🇧🇼", "🇧🇾", "🇧🇾", "🇧🇿", "🇧🇿", "🇨🇦", "🇨🇦", "🇨🇨", "🇨🇨", "🇨🇩", "🇨🇩", "🇨🇫", "🇨🇫", "🇨🇬", "🇨🇬", "🇨🇭", "🇨🇭", "🇨🇮", "🇨🇮",
-      "🇨🇰", "🇨🇰", "🇨🇱", "🇨🇱", "🇨🇲", "🇨🇲", "🇨🇳", "🇨🇳", "🇨🇴", "🇨🇴", "🇨🇵", "🇨🇵", "🇨🇷", "🇨🇷", "🇨🇺", "🇨🇺", "🇨🇻", "🇨🇻", "🇨🇼",
-      "🇨🇼", "🇨🇽", "🇨🇽", "🇨🇾", "🇨🇾", "🇨🇿", "🇨🇿", "🇩🇪", "🇩🇪", "🇩🇬", "🇩🇬", "🇩🇯", "🇩🇯", "🇩🇰", "🇩🇰", "🇩🇲", "🇩🇲", "🇩🇴", "🇩🇴",
-      "🇩🇿", "🇩🇿", "🇪🇦", "🇪🇦", "🇪🇨", "🇪🇨", "🇪🇪", "🇪🇪", "🇪🇬", "🇪🇬", "🇪🇭", "🇪🇭", "🇪🇷", "🇪🇷", "🇪🇸", "🇪🇸", "🇪🇹", "🇪🇹", "🇪🇺",
-      "🇪🇺", "🇫🇮", "🇫🇮", "🇫🇯", "🇫🇯", "🇫🇰", "🇫🇰", "🇫🇲", "🇫🇲", "🇫🇴", "🇫🇴", "🇫🇷", "🇫🇷", "🇬🇦", "🇬🇦", "🇬🇧", "🇬🇧", "🇬🇩", "🇬🇩",
-      "🇬🇪", "🇬🇪", "🇬🇫", "🇬🇫", "🇬🇬", "🇬🇬", "🇬🇭", "🇬🇭", "🇬🇮", "🇬🇮", "🇬🇱", "🇬🇱", "🇬🇲", "🇬🇲", "🇬🇳", "🇬🇳", "🇬🇵", "🇬🇵", "🇬🇶",
-      "🇬🇶", "🇬🇷", "🇬🇷", "🇬🇸", "🇬🇸", "🇬🇹", "🇬🇹", "🇬🇺", "🇬🇺", "🇬🇼", "🇬🇼", "🇬🇾", "🇬🇾", "🇭🇰", "🇭🇰", "🇭🇲", "🇭🇲", "🇭🇳", "🇭🇳",
-      "🇭🇷", "🇭🇷", "🇭🇹", "🇭🇹", "🇭🇺", "🇭🇺", "🇮🇨", "🇮🇨", "🇮🇩", "🇮🇩", "🇮🇪", "🇮🇪", "🇮🇱", "🇮🇱", "🇮🇲", "🇮🇲", "🇮🇳", "🇮🇳", "🇮🇴",
-      "🇮🇴", "🇮🇶", "🇮🇶", "🇮🇷", "🇮🇷", "🇮🇸", "🇮🇸", "🇮🇹", "🇮🇹", "🇯🇪", "🇯🇪", "🇯🇲", "🇯🇲", "🇯🇴", "🇯🇴", "🇯🇵", "🇯🇵", "🇰🇪", "🇰🇪",
-      "🇰🇬", "🇰🇬", "🇰🇭", "🇰🇭", "🇰🇮", "🇰🇮", "🇰🇲", "🇰🇲", "🇰🇳", "🇰🇳", "🇰🇵", "🇰🇵", "🇰🇷", "🇰🇷", "🇰🇼", "🇰🇼", "🇰🇾", "🇰🇾", "🇰🇿",
-      "🇰🇿", "🇱🇦", "🇱🇦", "🇱🇧", "🇱🇧", "🇱🇨", "🇱🇨", "🇱🇮", "🇱🇮", "🇱🇰", "🇱🇰", "🇱🇷", "🇱🇷", "🇱🇸", "🇱🇸", "🇱🇹", "🇱🇹", "🇱🇺", "🇱🇺",
-      "🇱🇻", "🇱🇻", "🇱🇾", "🇱🇾", "🇲🇦", "🇲🇦", "🇲🇨", "🇲🇨", "🇲🇩", "🇲🇩", "🇲🇪", "🇲🇪", "🇲🇫", "🇲🇫", "🇲🇬", "🇲🇬", "🇲🇭", "🇲🇭", "🇲🇰",
-      "🇲🇰", "🇲🇱", "🇲🇱", "🇲🇲", "🇲🇲", "🇲🇳", "🇲🇳", "🇲🇴", "🇲🇴", "🇲🇵", "🇲🇵", "🇲🇶", "🇲🇶", "🇲🇷", "🇲🇷", "🇲🇸", "🇲🇸", "🇲🇹", "🇲🇹",
-      "🇲🇺", "🇲🇺", "🇲🇻", "🇲🇻", "🇲🇼", "🇲🇼", "🇲🇽", "🇲🇽", "🇲🇾", "🇲🇾", "🇲🇿", "🇲🇿", "🇳🇦", "🇳🇦", "🇳🇨", "🇳🇨", "🇳🇪", "🇳🇪", "🇳🇫",
-      "🇳🇫", "🇳🇬", "🇳🇬", "🇳🇮", "🇳🇮", "🇳🇱", "🇳🇱", "🇳🇴", "🇳🇴", "🇳🇵", "🇳🇵", "🇳🇷", "🇳🇷", "🇳🇺", "🇳🇺", "🇳🇿", "🇳🇿", "🇴🇲", "🇴🇲",
-      "🇵🇦", "🇵🇦", "🇵🇪", "🇵🇪", "🇵🇫", "🇵🇫", "🇵🇬", "🇵🇬", "🇵🇭", "🇵🇭", "🇵🇰", "🇵🇰", "🇵🇱", "🇵🇱", "🇵🇲", "🇵🇲", "🇵🇳", "🇵🇳", "🇵🇷",
-      "🇵🇷", "🇵🇸", "🇵🇸", "🇵🇹", "🇵🇹", "🇵🇼", "🇵🇼", "🇵🇾", "🇵🇾", "🇶🇦", "🇶🇦", "🇷🇪", "🇷🇪", "🇷🇴", "🇷🇴", "🇷🇸", "🇷🇸", "🇷🇺", "🇷🇺",
-      "🇷🇼", "🇷🇼", "🇸🇦", "🇸🇦", "🇸🇧", "🇸🇧", "🇸🇨", "🇸🇨", "🇸🇩", "🇸🇩", "🇸🇪", "🇸🇪", "🇸🇬", "🇸🇬", "🇸🇭", "🇸🇭", "🇸🇮", "🇸🇮", "🇸🇯",
-      "🇸🇯", "🇸🇰", "🇸🇰", "🇸🇱", "🇸🇱", "🇸🇲", "🇸🇲", "🇸🇳", "🇸🇳", "🇸🇴", "🇸🇴", "🇸🇷", "🇸🇷", "🇸🇸", "🇸🇸", "🇸🇹", "🇸🇹", "🇸🇻", "🇸🇻",
-      "🇸🇽", "🇸🇽", "🇸🇾", "🇸🇾", "🇸🇿", "🇸🇿", "🇹🇦", "🇹🇦", "🇹🇨", "🇹🇨", "🇹🇩", "🇹🇩", "🇹🇫", "🇹🇫", "🇹🇬", "🇹🇬", "🇹🇭", "🇹🇭", "🇹🇯",
-      "🇹🇯", "🇹🇰", "🇹🇰", "🇹🇱", "🇹🇱", "🇹🇲", "🇹🇲", "🇹🇳", "🇹🇳", "🇹🇴", "🇹🇴", "🇹🇷", "🇹🇷", "🇹🇹", "🇹🇹", "🇹🇻", "🇹🇻", "🇹🇼", "🇹🇼",
-      "🇹🇿", "🇹🇿", "🇺🇦", "🇺🇦", "🇺🇬", "🇺🇬", "🇺🇲", "🇺🇲", "🇺🇳", "🇺🇳", "🇺🇸", "🇺🇸", "🇺🇾", "🇺🇾", "🇺🇿", "🇺🇿", "🇻🇦", "🇻🇦", "🇻🇨",
-      "🇻🇨", "🇻🇪", "🇻🇪", "🇻🇬", "🇻🇬", "🇻🇮", "🇻🇮", "🇻🇳", "🇻🇳", "🇻🇺", "🇻🇺", "🇼🇫", "🇼🇫", "🇼🇸", "🇼🇸", "🇽🇰", "🇽🇰", "🇾🇪", "🇾🇪",
-      "🇾🇹", "🇾🇹", "🇿🇦", "🇿🇦", "🇿🇲", "🇿🇲", "🇿🇼", "🇿🇼", "🏴󠁧󠁢󠁥󠁮󠁧󠁿", "🏴󠁧󠁢󠁥󠁮󠁧󠁿",
-      "🏴󠁧󠁢󠁳󠁣󠁴󠁿", "🏴󠁧󠁢󠁳󠁣󠁴󠁿", "🏴󠁧󠁢󠁷󠁬󠁳󠁿",
-      "🏴󠁧󠁢󠁷󠁬󠁳󠁿", "☝🏻", "☝🏻", "☝🏼", "☝🏼", "☝🏽", "☝🏽", "☝🏾",
-      "☝🏾", "☝🏿", "☝🏿", "⛹🏻", "⛹🏻", "⛹🏼", "⛹🏼", "⛹🏽", "⛹🏽", "⛹🏾",
-      "⛹🏾", "⛹🏿", "⛹🏿", "✊🏻", "✊🏻", "✊🏼", "✊🏼", "✊🏽", "✊🏽", "✊🏾",
-      "✊🏾", "✊🏿", "✊🏿", "✋🏻", "✋🏻", "✋🏼", "✋🏼", "✋🏽", "✋🏽", "✋🏾",
-      "✋🏾", "✋🏿", "✋🏿", "✌🏻", "✌🏻", "✌🏼", "✌🏼", "✌🏽", "✌🏽", "✌🏾",
-      "✌🏾", "✌🏿", "✌🏿", "✍🏻", "✍🏻", "✍🏼", "✍🏼", "✍🏽", "✍🏽", "✍🏾",
-      "✍🏾", "✍🏿", "✍🏿", "🎅🏻", "🎅🏻", "🎅🏼", "🎅🏼", "🎅🏽", "🎅🏽",
-      "🎅🏾", "🎅🏾", "🎅🏿", "🎅🏿", "🏂🏻", "🏂🏻", "🏂🏼", "🏂🏼", "🏂🏽",
-      "🏂🏽", "🏂🏾", "🏂🏾", "🏂🏿", "🏂🏿", "🏃🏻", "🏃🏻", "🏃🏼", "🏃🏼",
-      "🏃🏽", "🏃🏽", "🏃🏾", "🏃🏾", "🏃🏿", "🏃🏿", "🏄🏻", "🏄🏻", "🏄🏼",
-      "🏄🏼", "🏄🏽", "🏄🏽", "🏄🏾", "🏄🏾", "🏄🏿", "🏄🏿", "🏇🏻", "🏇🏻",
-      "🏇🏼", "🏇🏼", "🏇🏽", "🏇🏽", "🏇🏾", "🏇🏾", "🏇🏿", "🏇🏿", "🏊🏻",
-      "🏊🏻", "🏊🏼", "🏊🏼", "🏊🏽", "🏊🏽", "🏊🏾", "🏊🏾", "🏊🏿", "🏊🏿",
-      "🏋🏻", "🏋🏻", "🏋🏼", "🏋🏼", "🏋🏽", "🏋🏽", "🏋🏾", "🏋🏾", "🏋🏿",
-      "🏋🏿", "🏌🏻", "🏌🏻", "🏌🏼", "🏌🏼", "🏌🏽", "🏌🏽", "🏌🏾", "🏌🏾",
-      "🏌🏿", "🏌🏿", "👂🏻", "👂🏻", "👂🏼", "👂🏼", "👂🏽", "👂🏽", "👂🏾",
-      "👂🏾", "👂🏿", "👂🏿", "👃🏻", "👃🏻", "👃🏼", "👃🏼", "👃🏽", "👃🏽",
-      "👃🏾", "👃🏾", "👃🏿", "👃🏿", "👆🏻", "👆🏻", "👆🏼", "👆🏼", "👆🏽",
-      "👆🏽", "👆🏾", "👆🏾", "👆🏿", "👆🏿", "👇🏻", "👇🏻", "👇🏼", "👇🏼",
-      "👇🏽", "👇🏽", "👇🏾", "👇🏾", "👇🏿", "👇🏿", "👈🏻", "👈🏻", "👈🏼",
-      "👈🏼", "👈🏽", "👈🏽", "👈🏾", "👈🏾", "👈🏿", "👈🏿", "👉🏻", "👉🏻",
-      "👉🏼", "👉🏼", "👉🏽", "👉🏽", "👉🏾", "👉🏾", "👉🏿", "👉🏿", "👊🏻",
-      "👊🏻", "👊🏼", "👊🏼", "👊🏽", "👊🏽", "👊🏾", "👊🏾", "👊🏿", "👊🏿",
-      "👋🏻", "👋🏻", "👋🏼", "👋🏼", "👋🏽", "👋🏽", "👋🏾", "👋🏾", "👋🏿",
-      "👋🏿", "👌🏻", "👌🏻", "👌🏼", "👌🏼", "👌🏽", "👌🏽", "👌🏾", "👌🏾",
-      "👌🏿", "👌🏿", "👍🏻", "👍🏻", "👍🏼", "👍🏼", "👍🏽", "👍🏽", "👍🏾",
-      "👍🏾", "👍🏿", "👍🏿", "👎🏻", "👎🏻", "👎🏼", "👎🏼", "👎🏽", "👎🏽",
-      "👎🏾", "👎🏾", "👎🏿", "👎🏿", "👏🏻", "👏🏻", "👏🏼", "👏🏼", "👏🏽",
-      "👏🏽", "👏🏾", "👏🏾", "👏🏿", "👏🏿", "👐🏻", "👐🏻", "👐🏼", "👐🏼",
-      "👐🏽", "👐🏽", "👐🏾", "👐🏾", "👐🏿", "👐🏿", "👦🏻", "👦🏻", "👦🏼",
-      "👦🏼", "👦🏽", "👦🏽", "👦🏾", "👦🏾", "👦🏿", "👦🏿", "👧🏻", "👧🏻",
-      "👧🏼", "👧🏼", "👧🏽", "👧🏽", "👧🏾", "👧🏾", "👧🏿", "👧🏿", "👨🏻",
-      "👨🏻", "👨🏼", "👨🏼", "👨🏽", "👨🏽", "👨🏾", "👨🏾", "👨🏿", "👨🏿",
-      "👩🏻", "👩🏻", "👩🏼", "👩🏼", "👩🏽", "👩🏽", "👩🏾", "👩🏾", "👩🏿",
-      "👩🏿", "👫🏻", "👫🏻", "👫🏼", "👫🏼", "👫🏽", "👫🏽", "👫🏾", "👫🏾",
-      "👫🏿", "👫🏿", "👬🏻", "👬🏻", "👬🏼", "👬🏼", "👬🏽", "👬🏽", "👬🏾",
-      "👬🏾", "👬🏿", "👬🏿", "👭🏻", "👭🏻", "👭🏼", "👭🏼", "👭🏽", "👭🏽",
-      "👭🏾", "👭🏾", "👭🏿", "👭🏿", "👮🏻", "👮🏻", "👮🏼", "👮🏼", "👮🏽",
-      "👮🏽", "👮🏾", "👮🏾", "👮🏿", "👮🏿", "👰🏻", "👰🏻", "👰🏼", "👰🏼",
-      "👰🏽", "👰🏽", "👰🏾", "👰🏾", "👰🏿", "👰🏿", "👱🏻", "👱🏻", "👱🏼",
-      "👱🏼", "👱🏽", "👱🏽", "👱🏾", "👱🏾", "👱🏿", "👱🏿", "👲🏻", "👲🏻",
-      "👲🏼", "👲🏼", "👲🏽", "👲🏽", "👲🏾", "👲🏾", "👲🏿", "👲🏿", "👳🏻",
-      "👳🏻", "👳🏼", "👳🏼", "👳🏽", "👳🏽", "👳🏾", "👳🏾", "👳🏿", "👳🏿",
-      "👴🏻", "👴🏻", "👴🏼", "👴🏼", "👴🏽", "👴🏽", "👴🏾", "👴🏾", "👴🏿",
-      "👴🏿", "👵🏻", "👵🏻", "👵🏼", "👵🏼", "👵🏽", "👵🏽", "👵🏾", "👵🏾",
-      "👵🏿", "👵🏿", "👶🏻", "👶🏻", "👶🏼", "👶🏼", "👶🏽", "👶🏽", "👶🏾",
-      "👶🏾", "👶🏿", "👶🏿", "👷🏻", "👷🏻", "👷🏼", "👷🏼", "👷🏽", "👷🏽",
-      "👷🏾", "👷🏾", "👷🏿", "👷🏿", "👸🏻", "👸🏻", "👸🏼", "👸🏼", "👸🏽",
-      "👸🏽", "👸🏾", "👸🏾", "👸🏿", "👸🏿", "👼🏻", "👼🏻", "👼🏼", "👼🏼",
-      "👼🏽", "👼🏽", "👼🏾", "👼🏾", "👼🏿", "👼🏿", "💁🏻", "💁🏻", "💁🏼",
-      "💁🏼", "💁🏽", "💁🏽", "💁🏾", "💁🏾", "💁🏿", "💁🏿", "💂🏻", "💂🏻",
-      "💂🏼", "💂🏼", "💂🏽", "💂🏽", "💂🏾", "💂🏾", "💂🏿", "💂🏿", "💃🏻",
-      "💃🏻", "💃🏼", "💃🏼", "💃🏽", "💃🏽", "💃🏾", "💃🏾", "💃🏿", "💃🏿",
-      "💅🏻", "💅🏻", "💅🏼", "💅🏼", "💅🏽", "💅🏽", "💅🏾", "💅🏾", "💅🏿",
-      "💅🏿", "💆🏻", "💆🏻", "💆🏼", "💆🏼", "💆🏽", "💆🏽", "💆🏾", "💆🏾",
-      "💆🏿", "💆🏿", "💇🏻", "💇🏻", "💇🏼", "💇🏼", "💇🏽", "💇🏽", "💇🏾",
-      "💇🏾", "💇🏿", "💇🏿", "💏🏻", "💏🏻", "💏🏼", "💏🏼", "💏🏽", "💏🏽",
-      "💏🏾", "💏🏾", "💏🏿", "💏🏿", "💑🏻", "💑🏻", "💑🏼", "💑🏼", "💑🏽",
-      "💑🏽", "💑🏾", "💑🏾", "💑🏿", "💑🏿", "💪🏻", "💪🏻", "💪🏼", "💪🏼",
-      "💪🏽", "💪🏽", "💪🏾", "💪🏾", "💪🏿", "💪🏿", "🕴🏻", "🕴🏻", "🕴🏼",
-      "🕴🏼", "🕴🏽", "🕴🏽", "🕴🏾", "🕴🏾", "🕴🏿", "🕴🏿", "🕵🏻", "🕵🏻",
-      "🕵🏼", "🕵🏼", "🕵🏽", "🕵🏽", "🕵🏾", "🕵🏾", "🕵🏿", "🕵🏿", "🕺🏻",
-      "🕺🏻", "🕺🏼", "🕺🏼", "🕺🏽", "🕺🏽", "🕺🏾", "🕺🏾", "🕺🏿", "🕺🏿",
-      "🖐🏻", "🖐🏻", "🖐🏼", "🖐🏼", "🖐🏽", "🖐🏽", "🖐🏾", "🖐🏾", "🖐🏿",
-      "🖐🏿", "🖕🏻", "🖕🏻", "🖕🏼", "🖕🏼", "🖕🏽", "🖕🏽", "🖕🏾", "🖕🏾",
-      "🖕🏿", "🖕🏿", "🖖🏻", "🖖🏻", "🖖🏼", "🖖🏼", "🖖🏽", "🖖🏽", "🖖🏾",
-      "🖖🏾", "🖖🏿", "🖖🏿", "🙅🏻", "🙅🏻", "🙅🏼", "🙅🏼", "🙅🏽", "🙅🏽",
-      "🙅🏾", "🙅🏾", "🙅🏿", "🙅🏿", "🙆🏻", "🙆🏻", "🙆🏼", "🙆🏼", "🙆🏽",
-      "🙆🏽", "🙆🏾", "🙆🏾", "🙆🏿", "🙆🏿", "🙇🏻", "🙇🏻", "🙇🏼", "🙇🏼",
-      "🙇🏽", "🙇🏽", "🙇🏾", "🙇🏾", "🙇🏿", "🙇🏿", "🙋🏻", "🙋🏻", "🙋🏼",
-      "🙋🏼", "🙋🏽", "🙋🏽", "🙋🏾", "🙋🏾", "🙋🏿", "🙋🏿", "🙌🏻", "🙌🏻",
-      "🙌🏼", "🙌🏼", "🙌🏽", "🙌🏽", "🙌🏾", "🙌🏾", "🙌🏿", "🙌🏿", "🙍🏻",
-      "🙍🏻", "🙍🏼", "🙍🏼", "🙍🏽", "🙍🏽", "🙍🏾", "🙍🏾", "🙍🏿", "🙍🏿",
-      "🙎🏻", "🙎🏻", "🙎🏼", "🙎🏼", "🙎🏽", "🙎🏽", "🙎🏾", "🙎🏾", "🙎🏿",
-      "🙎🏿", "🙏🏻", "🙏🏻", "🙏🏼", "🙏🏼", "🙏🏽", "🙏🏽", "🙏🏾", "🙏🏾",
-      "🙏🏿", "🙏🏿", "🚣🏻", "🚣🏻", "🚣🏼", "🚣🏼", "🚣🏽", "🚣🏽", "🚣🏾",
-      "🚣🏾", "🚣🏿", "🚣🏿", "🚴🏻", "🚴🏻", "🚴🏼", "🚴🏼", "🚴🏽", "🚴🏽",
-      "🚴🏾", "🚴🏾", "🚴🏿", "🚴🏿", "🚵🏻", "🚵🏻", "🚵🏼", "🚵🏼", "🚵🏽",
-      "🚵🏽", "🚵🏾", "🚵🏾", "🚵🏿", "🚵🏿", "🚶🏻", "🚶🏻", "🚶🏼", "🚶🏼",
-      "🚶🏽", "🚶🏽", "🚶🏾", "🚶🏾", "🚶🏿", "🚶🏿", "🛀🏻", "🛀🏻", "🛀🏼",
-      "🛀🏼", "🛀🏽", "🛀🏽", "🛀🏾", "🛀🏾", "🛀🏿", "🛀🏿", "🛌🏻", "🛌🏻",
-      "🛌🏼", "🛌🏼", "🛌🏽", "🛌🏽", "🛌🏾", "🛌🏾", "🛌🏿", "🛌🏿", "🤌🏻",
-      "🤌🏻", "🤌🏼", "🤌🏼", "🤌🏽", "🤌🏽", "🤌🏾", "🤌🏾", "🤌🏿", "🤌🏿",
-      "🤏🏻", "🤏🏻", "🤏🏼", "🤏🏼", "🤏🏽", "🤏🏽", "🤏🏾", "🤏🏾", "🤏🏿",
-      "🤏🏿", "🤘🏻", "🤘🏻", "🤘🏼", "🤘🏼", "🤘🏽", "🤘🏽", "🤘🏾", "🤘🏾",
-      "🤘🏿", "🤘🏿", "🤙🏻", "🤙🏻", "🤙🏼", "🤙🏼", "🤙🏽", "🤙🏽", "🤙🏾",
-      "🤙🏾", "🤙🏿", "🤙🏿", "🤚🏻", "🤚🏻", "🤚🏼", "🤚🏼", "🤚🏽", "🤚🏽",
-      "🤚🏾", "🤚🏾", "🤚🏿", "🤚🏿", "🤛🏻", "🤛🏻", "🤛🏼", "🤛🏼", "🤛🏽",
-      "🤛🏽", "🤛🏾", "🤛🏾", "🤛🏿", "🤛🏿", "🤜🏻", "🤜🏻", "🤜🏼", "🤜🏼",
-      "🤜🏽", "🤜🏽", "🤜🏾", "🤜🏾", "🤜🏿", "🤜🏿", "🤝🏻", "🤝🏻", "🤝🏼",
-      "🤝🏼", "🤝🏽", "🤝🏽", "🤝🏾", "🤝🏾", "🤝🏿", "🤝🏿", "🤞🏻", "🤞🏻",
-      "🤞🏼", "🤞🏼", "🤞🏽", "🤞🏽", "🤞🏾", "🤞🏾", "🤞🏿", "🤞🏿", "🤟🏻",
-      "🤟🏻", "🤟🏼", "🤟🏼", "🤟🏽", "🤟🏽", "🤟🏾", "🤟🏾", "🤟🏿", "🤟🏿",
-      "🤦🏻", "🤦🏻", "🤦🏼", "🤦🏼", "🤦🏽", "🤦🏽", "🤦🏾", "🤦🏾", "🤦🏿",
-      "🤦🏿", "🤰🏻", "🤰🏻", "🤰🏼", "🤰🏼", "🤰🏽", "🤰🏽", "🤰🏾", "🤰🏾",
-      "🤰🏿", "🤰🏿", "🤱🏻", "🤱🏻", "🤱🏼", "🤱🏼", "🤱🏽", "🤱🏽", "🤱🏾",
-      "🤱🏾", "🤱🏿", "🤱🏿", "🤲🏻", "🤲🏻", "🤲🏼", "🤲🏼", "🤲🏽", "🤲🏽",
-      "🤲🏾", "🤲🏾", "🤲🏿", "🤲🏿", "🤳🏻", "🤳🏻", "🤳🏼", "🤳🏼", "🤳🏽",
-      "🤳🏽", "🤳🏾", "🤳🏾", "🤳🏿", "🤳🏿", "🤴🏻", "🤴🏻", "🤴🏼", "🤴🏼",
-      "🤴🏽", "🤴🏽", "🤴🏾", "🤴🏾", "🤴🏿", "🤴🏿", "🤵🏻", "🤵🏻", "🤵🏼",
-      "🤵🏼", "🤵🏽", "🤵🏽", "🤵🏾", "🤵🏾", "🤵🏿", "🤵🏿", "🤶🏻", "🤶🏻",
-      "🤶🏼", "🤶🏼", "🤶🏽", "🤶🏽", "🤶🏾", "🤶🏾", "🤶🏿", "🤶🏿", "🤷🏻",
-      "🤷🏻", "🤷🏼", "🤷🏼", "🤷🏽", "🤷🏽", "🤷🏾", "🤷🏾", "🤷🏿", "🤷🏿",
-      "🤸🏻", "🤸🏻", "🤸🏼", "🤸🏼", "🤸🏽", "🤸🏽", "🤸🏾", "🤸🏾", "🤸🏿",
-      "🤸🏿", "🤹🏻", "🤹🏻", "🤹🏼", "🤹🏼", "🤹🏽", "🤹🏽", "🤹🏾", "🤹🏾",
-      "🤹🏿", "🤹🏿", "🤽🏻", "🤽🏻", "🤽🏼", "🤽🏼", "🤽🏽", "🤽🏽", "🤽🏾",
-      "🤽🏾", "🤽🏿", "🤽🏿", "🤾🏻", "🤾🏻", "🤾🏼", "🤾🏼", "🤾🏽", "🤾🏽",
-      "🤾🏾", "🤾🏾", "🤾🏿", "🤾🏿", "🥷🏻", "🥷🏻", "🥷🏼", "🥷🏼", "🥷🏽",
-      "🥷🏽", "🥷🏾", "🥷🏾", "🥷🏿", "🥷🏿", "🦵🏻", "🦵🏻", "🦵🏼", "🦵🏼",
-      "🦵🏽", "🦵🏽", "🦵🏾", "🦵🏾", "🦵🏿", "🦵🏿", "🦶🏻", "🦶🏻", "🦶🏼",
-      "🦶🏼", "🦶🏽", "🦶🏽", "🦶🏾", "🦶🏾", "🦶🏿", "🦶🏿", "🦸🏻", "🦸🏻",
-      "🦸🏼", "🦸🏼", "🦸🏽", "🦸🏽", "🦸🏾", "🦸🏾", "🦸🏿", "🦸🏿", "🦹🏻",
-      "🦹🏻", "🦹🏼", "🦹🏼", "🦹🏽", "🦹🏽", "🦹🏾", "🦹🏾", "🦹🏿", "🦹🏿",
-      "🦻🏻", "🦻🏻", "🦻🏼", "🦻🏼", "🦻🏽", "🦻🏽", "🦻🏾", "🦻🏾", "🦻🏿",
-      "🦻🏿", "🧍🏻", "🧍🏻", "🧍🏼", "🧍🏼", "🧍🏽", "🧍🏽", "🧍🏾", "🧍🏾",
-      "🧍🏿", "🧍🏿", "🧎🏻", "🧎🏻", "🧎🏼", "🧎🏼", "🧎🏽", "🧎🏽", "🧎🏾",
-      "🧎🏾", "🧎🏿", "🧎🏿", "🧏🏻", "🧏🏻", "🧏🏼", "🧏🏼", "🧏🏽", "🧏🏽",
-      "🧏🏾", "🧏🏾", "🧏🏿", "🧏🏿", "🧑🏻", "🧑🏻", "🧑🏼", "🧑🏼", "🧑🏽",
-      "🧑🏽", "🧑🏾", "🧑🏾", "🧑🏿", "🧑🏿", "🧒🏻", "🧒🏻", "🧒🏼", "🧒🏼",
-      "🧒🏽", "🧒🏽", "🧒🏾", "🧒🏾", "🧒🏿", "🧒🏿", "🧓🏻", "🧓🏻", "🧓🏼",
-      "🧓🏼", "🧓🏽", "🧓🏽", "🧓🏾", "🧓🏾", "🧓🏿", "🧓🏿", "🧔🏻", "🧔🏻",
-      "🧔🏼", "🧔🏼", "🧔🏽", "🧔🏽", "🧔🏾", "🧔🏾", "🧔🏿", "🧔🏿", "🧕🏻",
-      "🧕🏻", "🧕🏼", "🧕🏼", "🧕🏽", "🧕🏽", "🧕🏾", "🧕🏾", "🧕🏿", "🧕🏿",
-      "🧖🏻", "🧖🏻", "🧖🏼", "🧖🏼", "🧖🏽", "🧖🏽", "🧖🏾", "🧖🏾", "🧖🏿",
-      "🧖🏿", "🧗🏻", "🧗🏻", "🧗🏼", "🧗🏼", "🧗🏽", "🧗🏽", "🧗🏾", "🧗🏾",
-      "🧗🏿", "🧗🏿", "🧘🏻", "🧘🏻", "🧘🏼", "🧘🏼", "🧘🏽", "🧘🏽", "🧘🏾",
-      "🧘🏾", "🧘🏿", "🧘🏿", "🧙🏻", "🧙🏻", "🧙🏼", "🧙🏼", "🧙🏽", "🧙🏽",
-      "🧙🏾", "🧙🏾", "🧙🏿", "🧙🏿", "🧚🏻", "🧚🏻", "🧚🏼", "🧚🏼", "🧚🏽",
-      "🧚🏽", "🧚🏾", "🧚🏾", "🧚🏿", "🧚🏿", "🧛🏻", "🧛🏻", "🧛🏼", "🧛🏼",
-      "🧛🏽", "🧛🏽", "🧛🏾", "🧛🏾", "🧛🏿", "🧛🏿", "🧜🏻", "🧜🏻", "🧜🏼",
-      "🧜🏼", "🧜🏽", "🧜🏽", "🧜🏾", "🧜🏾", "🧜🏿", "🧜🏿", "🧝🏻", "🧝🏻",
-      "🧝🏼", "🧝🏼", "🧝🏽", "🧝🏽", "🧝🏾", "🧝🏾", "🧝🏿", "🧝🏿", "🫃🏻",
-      "🫃🏻", "🫃🏼", "🫃🏼", "🫃🏽", "🫃🏽", "🫃🏾", "🫃🏾", "🫃🏿", "🫃🏿",
-      "🫄🏻", "🫄🏻", "🫄🏼", "🫄🏼", "🫄🏽", "🫄🏽", "🫄🏾", "🫄🏾", "🫄🏿",
-      "🫄🏿", "🫅🏻", "🫅🏻", "🫅🏼", "🫅🏼", "🫅🏽", "🫅🏽", "🫅🏾", "🫅🏾",
-      "🫅🏿", "🫅🏿", "🫰🏻", "🫰🏻", "🫰🏼", "🫰🏼", "🫰🏽", "🫰🏽", "🫰🏾",
-      "🫰🏾", "🫰🏿", "🫰🏿", "🫱🏻", "🫱🏻", "🫱🏼", "🫱🏼", "🫱🏽", "🫱🏽",
-      "🫱🏾", "🫱🏾", "🫱🏿", "🫱🏿", "🫲🏻", "🫲🏻", "🫲🏼", "🫲🏼", "🫲🏽",
-      "🫲🏽", "🫲🏾", "🫲🏾", "🫲🏿", "🫲🏿", "🫳🏻", "🫳🏻", "🫳🏼", "🫳🏼",
-      "🫳🏽", "🫳🏽", "🫳🏾", "🫳🏾", "🫳🏿", "🫳🏿", "🫴🏻", "🫴🏻", "🫴🏼",
-      "🫴🏼", "🫴🏽", "🫴🏽", "🫴🏾", "🫴🏾", "🫴🏿", "🫴🏿", "🫵🏻", "🫵🏻",
-      "🫵🏼", "🫵🏼", "🫵🏽", "🫵🏽", "🫵🏾", "🫵🏾", "🫵🏿", "🫵🏿", "🫶🏻",
-      "🫶🏻", "🫶🏼", "🫶🏼", "🫶🏽", "🫶🏽", "🫶🏾", "🫶🏾", "🫶🏿", "🫶🏿",
-      "👨‍❤‍👨", "👨‍❤️‍👨", "👨‍❤‍💋‍👨", "👨‍❤️‍💋‍👨",
-      "👨‍👦", "👨‍👦", "👨‍👦‍👦", "👨‍👦‍👦", "👨‍👧", "👨‍👧",
-      "👨‍👧‍👦", "👨‍👧‍👦", "👨‍👧‍👧", "👨‍👧‍👧", "👨‍👨‍👦",
-      "👨‍👨‍👦", "👨‍👨‍👦‍👦", "👨‍👨‍👦‍👦", "👨‍👨‍👧",
-      "👨‍👨‍👧", "👨‍👨‍👧‍👦", "👨‍👨‍👧‍👦", "👨‍👨‍👧‍👧",
-      "👨‍👨‍👧‍👧", "👨‍👩‍👦", "👨‍👩‍👦", "👨‍👩‍👦‍👦",
-      "👨‍👩‍👦‍👦", "👨‍👩‍👧", "👨‍👩‍👧", "👨‍👩‍👧‍👦",
-      "👨‍👩‍👧‍👦", "👨‍👩‍👧‍👧", "👨‍👩‍👧‍👧",
-      "👨🏻‍❤‍👨🏻", "👨🏻‍❤️‍👨🏻", "👨🏻‍❤‍👨🏼",
-      "👨🏻‍❤️‍👨🏼", "👨🏻‍❤‍👨🏽", "👨🏻‍❤️‍👨🏽",
-      "👨🏻‍❤‍👨🏾", "👨🏻‍❤️‍👨🏾", "👨🏻‍❤‍👨🏿",
-      "👨🏻‍❤️‍👨🏿", "👨🏻‍❤‍💋‍👨🏻", "👨🏻‍❤️‍💋‍👨🏻",
-      "👨🏻‍❤‍💋‍👨🏼", "👨🏻‍❤️‍💋‍👨🏼", "👨🏻‍❤‍💋‍👨🏽",
-      "👨🏻‍❤️‍💋‍👨🏽", "👨🏻‍❤‍💋‍👨🏾", "👨🏻‍❤️‍💋‍👨🏾",
-      "👨🏻‍❤‍💋‍👨🏿", "👨🏻‍❤️‍💋‍👨🏿", "👨🏻‍🤝‍👨🏼",
-      "👨🏻‍🤝‍👨🏼", "👨🏻‍🤝‍👨🏽", "👨🏻‍🤝‍👨🏽",
-      "👨🏻‍🤝‍👨🏾", "👨🏻‍🤝‍👨🏾", "👨🏻‍🤝‍👨🏿",
-      "👨🏻‍🤝‍👨🏿", "👨🏼‍❤‍👨🏻", "👨🏼‍❤️‍👨🏻",
-      "👨🏼‍❤‍👨🏼", "👨🏼‍❤️‍👨🏼", "👨🏼‍❤‍👨🏽",
-      "👨🏼‍❤️‍👨🏽", "👨🏼‍❤‍👨🏾", "👨🏼‍❤️‍👨🏾",
-      "👨🏼‍❤‍👨🏿", "👨🏼‍❤️‍👨🏿", "👨🏼‍❤‍💋‍👨🏻",
-      "👨🏼‍❤️‍💋‍👨🏻", "👨🏼‍❤‍💋‍👨🏼", "👨🏼‍❤️‍💋‍👨🏼",
-      "👨🏼‍❤‍💋‍👨🏽", "👨🏼‍❤️‍💋‍👨🏽", "👨🏼‍❤‍💋‍👨🏾",
-      "👨🏼‍❤️‍💋‍👨🏾", "👨🏼‍❤‍💋‍👨🏿", "👨🏼‍❤️‍💋‍👨🏿",
-      "👨🏼‍🤝‍👨🏻", "👨🏼‍🤝‍👨🏻", "👨🏼‍🤝‍👨🏽",
-      "👨🏼‍🤝‍👨🏽", "👨🏼‍🤝‍👨🏾", "👨🏼‍🤝‍👨🏾",
-      "👨🏼‍🤝‍👨🏿", "👨🏼‍🤝‍👨🏿", "👨🏽‍❤‍👨🏻",
+      "🫤", "🫥", "🫦", "🫧", "🫰", "🫱", "🫲", "🫳", "🫴", "🫵", "🫶", "©", "©️", "®",
+      "®️", "‼", "‼️", "⁉", "⁉️", "™", "™️", "ℹ", "ℹ️", "↔", "↔️", "↕", "↕️", "↖", "↖️",
+      "↗", "↗️", "↘", "↘️", "↙", "↙️", "↩", "↩️", "↪", "↪️", "⌨", "⌨️", "⏏", "⏏️", "⏭",
+      "⏭️", "⏮", "⏮️", "⏯", "⏯️", "⏱", "⏱️", "⏲", "⏲️", "⏸", "⏸️", "⏹", "⏹️", "⏺",
+      "⏺️", "Ⓜ", "Ⓜ️", "▪", "▪️", "▫", "▫️", "▶", "▶️", "◀", "◀️", "◻", "◻️", "◼", "◼️",
+      "☀", "☀️", "☁", "☁️", "☂", "☂️", "☃", "☃️", "☄", "☄️", "☎", "☎️", "☑", "☑️", "☘",
+      "☘️", "☝", "☝️", "☠", "☠️", "☢", "☢️", "☣", "☣️", "☦", "☦️", "☪", "☪️", "☮", "☮️",
+      "☯", "☯️", "☸", "☸️", "☹", "☹️", "☺", "☺️", "♀", "♀️", "♂", "♂️", "♟", "♟️", "♠",
+      "♠️", "♣", "♣️", "♥", "♥️", "♦", "♦️", "♨", "♨️", "♻", "♻️", "♾", "♾️", "⚒", "⚒️",
+      "⚔", "⚔️", "⚕", "⚕️", "⚖", "⚖️", "⚗", "⚗️", "⚙", "⚙️", "⚛", "⚛️", "⚜", "⚜️", "⚠",
+      "⚠️", "⚧", "⚧️", "⚰", "⚰️", "⚱", "⚱️", "⛈", "⛈️", "⛏", "⛏️", "⛑", "⛑️", "⛓", "⛓️",
+      "⛩", "⛩️", "⛰", "⛰️", "⛱", "⛱️", "⛴", "⛴️", "⛷", "⛷️", "⛸", "⛸️", "⛹", "⛹️", "✂",
+      "✂️", "✈", "✈️", "✉", "✉️", "✌", "✌️", "✍", "✍️", "✏", "✏️", "✒", "✒️", "✔", "✔️",
+      "✖", "✖️", "✝", "✝️", "✡", "✡️", "✳", "✳️", "✴", "✴️", "❄", "❄️", "❇", "❇️", "❣",
+      "❣️", "❤", "❤️", "➡", "➡️", "⤴", "⤴️", "⤵", "⤵️", "⬅", "⬅️", "⬆", "⬆️", "⬇", "⬇️",
+      "〰", "〰️", "〽", "〽️", "㊗", "㊗️", "㊙", "㊙️", "🅰", "🅰️", "🅱", "🅱️", "🅾", "🅾️",
+      "🅿", "🅿️", "🈂", "🈂️", "🈷", "🈷️", "🌡", "🌡️", "🌤", "🌤️", "🌥", "🌥️", "🌦",
+      "🌦️", "🌧", "🌧️", "🌨", "🌨️", "🌩", "🌩️", "🌪", "🌪️", "🌫", "🌫️", "🌬",
+      "🌬️", "🌶", "🌶️", "🍽", "🍽️", "🎖", "🎖️", "🎗", "🎗️", "🎙", "🎙️", "🎚",
+      "🎚️", "🎛", "🎛️", "🎞", "🎞️", "🎟", "🎟️", "🏋", "🏋️", "🏌", "🏌️", "🏍",
+      "🏍️", "🏎", "🏎️", "🏔", "🏔️", "🏕", "🏕️", "🏖", "🏖️", "🏗", "🏗️", "🏘",
+      "🏘️", "🏙", "🏙️", "🏚", "🏚️", "🏛", "🏛️", "🏜", "🏜️", "🏝", "🏝️", "🏞",
+      "🏞️", "🏟", "🏟️", "🏳", "🏳️", "🏵", "🏵️", "🏷", "🏷️", "🐿", "🐿️", "👁",
+      "👁️", "📽", "📽️", "🕉", "🕉️", "🕊", "🕊️", "🕯", "🕯️", "🕰", "🕰️", "🕳",
+      "🕳️", "🕴", "🕴️", "🕵", "🕵️", "🕶", "🕶️", "🕷", "🕷️", "🕸", "🕸️", "🕹",
+      "🕹️", "🖇", "🖇️", "🖊", "🖊️", "🖋", "🖋️", "🖌", "🖌️", "🖍", "🖍️", "🖐",
+      "🖐️", "🖥", "🖥️", "🖨", "🖨️", "🖱", "🖱️", "🖲", "🖲️", "🖼", "🖼️", "🗂",
+      "🗂️", "🗃", "🗃️", "🗄", "🗄️", "🗑", "🗑️", "🗒", "🗒️", "🗓", "🗓️", "🗜",
+      "🗜️", "🗝", "🗝️", "🗞", "🗞️", "🗡", "🗡️", "🗣", "🗣️", "🗨", "🗨️", "🗯",
+      "🗯️", "🗳", "🗳️", "🗺", "🗺️", "🛋", "🛋️", "🛍", "🛍️", "🛎", "🛎️", "🛏",
+      "🛏️", "🛠", "🛠️", "🛡", "🛡️", "🛢", "🛢️", "🛣", "🛣️", "🛤", "🛤️", "🛥",
+      "🛥️", "🛩", "🛩️", "🛰", "🛰️", "🛳", "🛳️", "#⃣", "#️⃣", "*⃣", "*️⃣", "0⃣",
+      "0️⃣", "1⃣", "1️⃣", "2⃣", "2️⃣", "3⃣", "3️⃣", "4⃣", "4️⃣", "5⃣", "5️⃣", "6⃣", "6️⃣", "7⃣",
+      "7️⃣", "8⃣", "8️⃣", "9⃣", "9️⃣", "🇦🇨", "🇦🇩", "🇦🇪", "🇦🇫", "🇦🇬", "🇦🇮", "🇦🇱", "🇦🇲", "🇦🇴", "🇦🇶", "🇦🇷", "🇦🇸",
+      "🇦🇹", "🇦🇺", "🇦🇼", "🇦🇽", "🇦🇿", "🇧🇦", "🇧🇧", "🇧🇩", "🇧🇪", "🇧🇫", "🇧🇬", "🇧🇭", "🇧🇮", "🇧🇯", "🇧🇱", "🇧🇲", "🇧🇳", "🇧🇴", "🇧🇶",
+      "🇧🇷", "🇧🇸", "🇧🇹", "🇧🇻", "🇧🇼", "🇧🇾", "🇧🇿", "🇨🇦", "🇨🇨", "🇨🇩", "🇨🇫", "🇨🇬", "🇨🇭", "🇨🇮", "🇨🇰", "🇨🇱", "🇨🇲", "🇨🇳", "🇨🇴",
+      "🇨🇵", "🇨🇷", "🇨🇺", "🇨🇻", "🇨🇼", "🇨🇽", "🇨🇾", "🇨🇿", "🇩🇪", "🇩🇬", "🇩🇯", "🇩🇰", "🇩🇲", "🇩🇴", "🇩🇿", "🇪🇦", "🇪🇨", "🇪🇪", "🇪🇬",
+      "🇪🇭", "🇪🇷", "🇪🇸", "🇪🇹", "🇪🇺", "🇫🇮", "🇫🇯", "🇫🇰", "🇫🇲", "🇫🇴", "🇫🇷", "🇬🇦", "🇬🇧", "🇬🇩", "🇬🇪", "🇬🇫", "🇬🇬", "🇬🇭", "🇬🇮",
+      "🇬🇱", "🇬🇲", "🇬🇳", "🇬🇵", "🇬🇶", "🇬🇷", "🇬🇸", "🇬🇹", "🇬🇺", "🇬🇼", "🇬🇾", "🇭🇰", "🇭🇲", "🇭🇳", "🇭🇷", "🇭🇹", "🇭🇺", "🇮🇨", "🇮🇩",
+      "🇮🇪", "🇮🇱", "🇮🇲", "🇮🇳", "🇮🇴", "🇮🇶", "🇮🇷", "🇮🇸", "🇮🇹", "🇯🇪", "🇯🇲", "🇯🇴", "🇯🇵", "🇰🇪", "🇰🇬", "🇰🇭", "🇰🇮", "🇰🇲", "🇰🇳",
+      "🇰🇵", "🇰🇷", "🇰🇼", "🇰🇾", "🇰🇿", "🇱🇦", "🇱🇧", "🇱🇨", "🇱🇮", "🇱🇰", "🇱🇷", "🇱🇸", "🇱🇹", "🇱🇺", "🇱🇻", "🇱🇾", "🇲🇦", "🇲🇨", "🇲🇩",
+      "🇲🇪", "🇲🇫", "🇲🇬", "🇲🇭", "🇲🇰", "🇲🇱", "🇲🇲", "🇲🇳", "🇲🇴", "🇲🇵", "🇲🇶", "🇲🇷", "🇲🇸", "🇲🇹", "🇲🇺", "🇲🇻", "🇲🇼", "🇲🇽", "🇲🇾",
+      "🇲🇿", "🇳🇦", "🇳🇨", "🇳🇪", "🇳🇫", "🇳🇬", "🇳🇮", "🇳🇱", "🇳🇴", "🇳🇵", "🇳🇷", "🇳🇺", "🇳🇿", "🇴🇲", "🇵🇦", "🇵🇪", "🇵🇫", "🇵🇬", "🇵🇭",
+      "🇵🇰", "🇵🇱", "🇵🇲", "🇵🇳", "🇵🇷", "🇵🇸", "🇵🇹", "🇵🇼", "🇵🇾", "🇶🇦", "🇷🇪", "🇷🇴", "🇷🇸", "🇷🇺", "🇷🇼", "🇸🇦", "🇸🇧", "🇸🇨", "🇸🇩",
+      "🇸🇪", "🇸🇬", "🇸🇭", "🇸🇮", "🇸🇯", "🇸🇰", "🇸🇱", "🇸🇲", "🇸🇳", "🇸🇴", "🇸🇷", "🇸🇸", "🇸🇹", "🇸🇻", "🇸🇽", "🇸🇾", "🇸🇿", "🇹🇦", "🇹🇨",
+      "🇹🇩", "🇹🇫", "🇹🇬", "🇹🇭", "🇹🇯", "🇹🇰", "🇹🇱", "🇹🇲", "🇹🇳", "🇹🇴", "🇹🇷", "🇹🇹", "🇹🇻", "🇹🇼", "🇹🇿", "🇺🇦", "🇺🇬", "🇺🇲", "🇺🇳",
+      "🇺🇸", "🇺🇾", "🇺🇿", "🇻🇦", "🇻🇨", "🇻🇪", "🇻🇬", "🇻🇮", "🇻🇳", "🇻🇺", "🇼🇫", "🇼🇸", "🇽🇰", "🇾🇪", "🇾🇹", "🇿🇦", "🇿🇲", "🇿🇼",
+      "🏴󠁧󠁢󠁥󠁮󠁧󠁿", "🏴󠁧󠁢󠁳󠁣󠁴󠁿", "🏴󠁧󠁢󠁷󠁬󠁳󠁿", "☝🏻",
+      "☝🏼", "☝🏽", "☝🏾", "☝🏿", "⛹🏻", "⛹🏼", "⛹🏽", "⛹🏾", "⛹🏿", "✊🏻",
+      "✊🏼", "✊🏽", "✊🏾", "✊🏿", "✋🏻", "✋🏼", "✋🏽", "✋🏾", "✋🏿", "✌🏻",
+      "✌🏼", "✌🏽", "✌🏾", "✌🏿", "✍🏻", "✍🏼", "✍🏽", "✍🏾", "✍🏿", "🎅🏻",
+      "🎅🏼", "🎅🏽", "🎅🏾", "🎅🏿", "🏂🏻", "🏂🏼", "🏂🏽", "🏂🏾", "🏂🏿",
+      "🏃🏻", "🏃🏼", "🏃🏽", "🏃🏾", "🏃🏿", "🏄🏻", "🏄🏼", "🏄🏽", "🏄🏾",
+      "🏄🏿", "🏇🏻", "🏇🏼", "🏇🏽", "🏇🏾", "🏇🏿", "🏊🏻", "🏊🏼", "🏊🏽",
+      "🏊🏾", "🏊🏿", "🏋🏻", "🏋🏼", "🏋🏽", "🏋🏾", "🏋🏿", "🏌🏻", "🏌🏼",
+      "🏌🏽", "🏌🏾", "🏌🏿", "👂🏻", "👂🏼", "👂🏽", "👂🏾", "👂🏿", "👃🏻",
+      "👃🏼", "👃🏽", "👃🏾", "👃🏿", "👆🏻", "👆🏼", "👆🏽", "👆🏾", "👆🏿",
+      "👇🏻", "👇🏼", "👇🏽", "👇🏾", "👇🏿", "👈🏻", "👈🏼", "👈🏽", "👈🏾",
+      "👈🏿", "👉🏻", "👉🏼", "👉🏽", "👉🏾", "👉🏿", "👊🏻", "👊🏼", "👊🏽",
+      "👊🏾", "👊🏿", "👋🏻", "👋🏼", "👋🏽", "👋🏾", "👋🏿", "👌🏻", "👌🏼",
+      "👌🏽", "👌🏾", "👌🏿", "👍🏻", "👍🏼", "👍🏽", "👍🏾", "👍🏿", "👎🏻",
+      "👎🏼", "👎🏽", "👎🏾", "👎🏿", "👏🏻", "👏🏼", "👏🏽", "👏🏾", "👏🏿",
+      "👐🏻", "👐🏼", "👐🏽", "👐🏾", "👐🏿", "👦🏻", "👦🏼", "👦🏽", "👦🏾",
+      "👦🏿", "👧🏻", "👧🏼", "👧🏽", "👧🏾", "👧🏿", "👨🏻", "👨🏼", "👨🏽",
+      "👨🏾", "👨🏿", "👩🏻", "👩🏼", "👩🏽", "👩🏾", "👩🏿", "👫🏻", "👫🏼",
+      "👫🏽", "👫🏾", "👫🏿", "👬🏻", "👬🏼", "👬🏽", "👬🏾", "👬🏿", "👭🏻",
+      "👭🏼", "👭🏽", "👭🏾", "👭🏿", "👮🏻", "👮🏼", "👮🏽", "👮🏾", "👮🏿",
+      "👰🏻", "👰🏼", "👰🏽", "👰🏾", "👰🏿", "👱🏻", "👱🏼", "👱🏽", "👱🏾",
+      "👱🏿", "👲🏻", "👲🏼", "👲🏽", "👲🏾", "👲🏿", "👳🏻", "👳🏼", "👳🏽",
+      "👳🏾", "👳🏿", "👴🏻", "👴🏼", "👴🏽", "👴🏾", "👴🏿", "👵🏻", "👵🏼",
+      "👵🏽", "👵🏾", "👵🏿", "👶🏻", "👶🏼", "👶🏽", "👶🏾", "👶🏿", "👷🏻",
+      "👷🏼", "👷🏽", "👷🏾", "👷🏿", "👸🏻", "👸🏼", "👸🏽", "👸🏾", "👸🏿",
+      "👼🏻", "👼🏼", "👼🏽", "👼🏾", "👼🏿", "💁🏻", "💁🏼", "💁🏽", "💁🏾",
+      "💁🏿", "💂🏻", "💂🏼", "💂🏽", "💂🏾", "💂🏿", "💃🏻", "💃🏼", "💃🏽",
+      "💃🏾", "💃🏿", "💅🏻", "💅🏼", "💅🏽", "💅🏾", "💅🏿", "💆🏻", "💆🏼",
+      "💆🏽", "💆🏾", "💆🏿", "💇🏻", "💇🏼", "💇🏽", "💇🏾", "💇🏿", "💏🏻",
+      "💏🏼", "💏🏽", "💏🏾", "💏🏿", "💑🏻", "💑🏼", "💑🏽", "💑🏾", "💑🏿",
+      "💪🏻", "💪🏼", "💪🏽", "💪🏾", "💪🏿", "🕴🏻", "🕴🏼", "🕴🏽", "🕴🏾",
+      "🕴🏿", "🕵🏻", "🕵🏼", "🕵🏽", "🕵🏾", "🕵🏿", "🕺🏻", "🕺🏼", "🕺🏽",
+      "🕺🏾", "🕺🏿", "🖐🏻", "🖐🏼", "🖐🏽", "🖐🏾", "🖐🏿", "🖕🏻", "🖕🏼",
+      "🖕🏽", "🖕🏾", "🖕🏿", "🖖🏻", "🖖🏼", "🖖🏽", "🖖🏾", "🖖🏿", "🙅🏻",
+      "🙅🏼", "🙅🏽", "🙅🏾", "🙅🏿", "🙆🏻", "🙆🏼", "🙆🏽", "🙆🏾", "🙆🏿",
+      "🙇🏻", "🙇🏼", "🙇🏽", "🙇🏾", "🙇🏿", "🙋🏻", "🙋🏼", "🙋🏽", "🙋🏾",
+      "🙋🏿", "🙌🏻", "🙌🏼", "🙌🏽", "🙌🏾", "🙌🏿", "🙍🏻", "🙍🏼", "🙍🏽",
+      "🙍🏾", "🙍🏿", "🙎🏻", "🙎🏼", "🙎🏽", "🙎🏾", "🙎🏿", "🙏🏻", "🙏🏼",
+      "🙏🏽", "🙏🏾", "🙏🏿", "🚣🏻", "🚣🏼", "🚣🏽", "🚣🏾", "🚣🏿", "🚴🏻",
+      "🚴🏼", "🚴🏽", "🚴🏾", "🚴🏿", "🚵🏻", "🚵🏼", "🚵🏽", "🚵🏾", "🚵🏿",
+      "🚶🏻", "🚶🏼", "🚶🏽", "🚶🏾", "🚶🏿", "🛀🏻", "🛀🏼", "🛀🏽", "🛀🏾",
+      "🛀🏿", "🛌🏻", "🛌🏼", "🛌🏽", "🛌🏾", "🛌🏿", "🤌🏻", "🤌🏼", "🤌🏽",
+      "🤌🏾", "🤌🏿", "🤏🏻", "🤏🏼", "🤏🏽", "🤏🏾", "🤏🏿", "🤘🏻", "🤘🏼",
+      "🤘🏽", "🤘🏾", "🤘🏿", "🤙🏻", "🤙🏼", "🤙🏽", "🤙🏾", "🤙🏿", "🤚🏻",
+      "🤚🏼", "🤚🏽", "🤚🏾", "🤚🏿", "🤛🏻", "🤛🏼", "🤛🏽", "🤛🏾", "🤛🏿",
+      "🤜🏻", "🤜🏼", "🤜🏽", "🤜🏾", "🤜🏿", "🤝🏻", "🤝🏼", "🤝🏽", "🤝🏾",
+      "🤝🏿", "🤞🏻", "🤞🏼", "🤞🏽", "🤞🏾", "🤞🏿", "🤟🏻", "🤟🏼", "🤟🏽",
+      "🤟🏾", "🤟🏿", "🤦🏻", "🤦🏼", "🤦🏽", "🤦🏾", "🤦🏿", "🤰🏻", "🤰🏼",
+      "🤰🏽", "🤰🏾", "🤰🏿", "🤱🏻", "🤱🏼", "🤱🏽", "🤱🏾", "🤱🏿", "🤲🏻",
+      "🤲🏼", "🤲🏽", "🤲🏾", "🤲🏿", "🤳🏻", "🤳🏼", "🤳🏽", "🤳🏾", "🤳🏿",
+      "🤴🏻", "🤴🏼", "🤴🏽", "🤴🏾", "🤴🏿", "🤵🏻", "🤵🏼", "🤵🏽", "🤵🏾",
+      "🤵🏿", "🤶🏻", "🤶🏼", "🤶🏽", "🤶🏾", "🤶🏿", "🤷🏻", "🤷🏼", "🤷🏽",
+      "🤷🏾", "🤷🏿", "🤸🏻", "🤸🏼", "🤸🏽", "🤸🏾", "🤸🏿", "🤹🏻", "🤹🏼",
+      "🤹🏽", "🤹🏾", "🤹🏿", "🤽🏻", "🤽🏼", "🤽🏽", "🤽🏾", "🤽🏿", "🤾🏻",
+      "🤾🏼", "🤾🏽", "🤾🏾", "🤾🏿", "🥷🏻", "🥷🏼", "🥷🏽", "🥷🏾", "🥷🏿",
+      "🦵🏻", "🦵🏼", "🦵🏽", "🦵🏾", "🦵🏿", "🦶🏻", "🦶🏼", "🦶🏽", "🦶🏾",
+      "🦶🏿", "🦸🏻", "🦸🏼", "🦸🏽", "🦸🏾", "🦸🏿", "🦹🏻", "🦹🏼", "🦹🏽",
+      "🦹🏾", "🦹🏿", "🦻🏻", "🦻🏼", "🦻🏽", "🦻🏾", "🦻🏿", "🧍🏻", "🧍🏼",
+      "🧍🏽", "🧍🏾", "🧍🏿", "🧎🏻", "🧎🏼", "🧎🏽", "🧎🏾", "🧎🏿", "🧏🏻",
+      "🧏🏼", "🧏🏽", "🧏🏾", "🧏🏿", "🧑🏻", "🧑🏼", "🧑🏽", "🧑🏾", "🧑🏿",
+      "🧒🏻", "🧒🏼", "🧒🏽", "🧒🏾", "🧒🏿", "🧓🏻", "🧓🏼", "🧓🏽", "🧓🏾",
+      "🧓🏿", "🧔🏻", "🧔🏼", "🧔🏽", "🧔🏾", "🧔🏿", "🧕🏻", "🧕🏼", "🧕🏽",
+      "🧕🏾", "🧕🏿", "🧖🏻", "🧖🏼", "🧖🏽", "🧖🏾", "🧖🏿", "🧗🏻", "🧗🏼",
+      "🧗🏽", "🧗🏾", "🧗🏿", "🧘🏻", "🧘🏼", "🧘🏽", "🧘🏾", "🧘🏿", "🧙🏻",
+      "🧙🏼", "🧙🏽", "🧙🏾", "🧙🏿", "🧚🏻", "🧚🏼", "🧚🏽", "🧚🏾", "🧚🏿",
+      "🧛🏻", "🧛🏼", "🧛🏽", "🧛🏾", "🧛🏿", "🧜🏻", "🧜🏼", "🧜🏽", "🧜🏾",
+      "🧜🏿", "🧝🏻", "🧝🏼", "🧝🏽", "🧝🏾", "🧝🏿", "🫃🏻", "🫃🏼", "🫃🏽",
+      "🫃🏾", "🫃🏿", "🫄🏻", "🫄🏼", "🫄🏽", "🫄🏾", "🫄🏿", "🫅🏻", "🫅🏼",
+      "🫅🏽", "🫅🏾", "🫅🏿", "🫰🏻", "🫰🏼", "🫰🏽", "🫰🏾", "🫰🏿", "🫱🏻",
+      "🫱🏼", "🫱🏽", "🫱🏾", "🫱🏿", "🫲🏻", "🫲🏼", "🫲🏽", "🫲🏾", "🫲🏿",
+      "🫳🏻", "🫳🏼", "🫳🏽", "🫳🏾", "🫳🏿", "🫴🏻", "🫴🏼", "🫴🏽", "🫴🏾",
+      "🫴🏿", "🫵🏻", "🫵🏼", "🫵🏽", "🫵🏾", "🫵🏿", "🫶🏻", "🫶🏼", "🫶🏽",
+      "🫶🏾", "🫶🏿", "👨‍❤‍👨", "👨‍❤️‍👨", "👨‍❤‍💋‍👨",
+      "👨‍❤️‍💋‍👨", "👨‍👦", "👨‍👦‍👦", "👨‍👧", "👨‍👧‍👦",
+      "👨‍👧‍👧", "👨‍👨‍👦", "👨‍👨‍👦‍👦", "👨‍👨‍👧",
+      "👨‍👨‍👧‍👦", "👨‍👨‍👧‍👧", "👨‍👩‍👦", "👨‍👩‍👦‍👦",
+      "👨‍👩‍👧", "👨‍👩‍👧‍👦", "👨‍👩‍👧‍👧", "👨🏻‍❤‍👨🏻",
+      "👨🏻‍❤️‍👨🏻", "👨🏻‍❤‍👨🏼", "👨🏻‍❤️‍👨🏼",
+      "👨🏻‍❤‍👨🏽", "👨🏻‍❤️‍👨🏽", "👨🏻‍❤‍👨🏾",
+      "👨🏻‍❤️‍👨🏾", "👨🏻‍❤‍👨🏿", "👨🏻‍❤️‍👨🏿",
+      "👨🏻‍❤‍💋‍👨🏻", "👨🏻‍❤️‍💋‍👨🏻", "👨🏻‍❤‍💋‍👨🏼",
+      "👨🏻‍❤️‍💋‍👨🏼", "👨🏻‍❤‍💋‍👨🏽", "👨🏻‍❤️‍💋‍👨🏽",
+      "👨🏻‍❤‍💋‍👨🏾", "👨🏻‍❤️‍💋‍👨🏾", "👨🏻‍❤‍💋‍👨🏿",
+      "👨🏻‍❤️‍💋‍👨🏿", "👨🏻‍🤝‍👨🏼", "👨🏻‍🤝‍👨🏽",
+      "👨🏻‍🤝‍👨🏾", "👨🏻‍🤝‍👨🏿", "👨🏼‍❤‍👨🏻",
+      "👨🏼‍❤️‍👨🏻", "👨🏼‍❤‍👨🏼", "👨🏼‍❤️‍👨🏼",
+      "👨🏼‍❤‍👨🏽", "👨🏼‍❤️‍👨🏽", "👨🏼‍❤‍👨🏾",
+      "👨🏼‍❤️‍👨🏾", "👨🏼‍❤‍👨🏿", "👨🏼‍❤️‍👨🏿",
+      "👨🏼‍❤‍💋‍👨🏻", "👨🏼‍❤️‍💋‍👨🏻", "👨🏼‍❤‍💋‍👨🏼",
+      "👨🏼‍❤️‍💋‍👨🏼", "👨🏼‍❤‍💋‍👨🏽", "👨🏼‍❤️‍💋‍👨🏽",
+      "👨🏼‍❤‍💋‍👨🏾", "👨🏼‍❤️‍💋‍👨🏾", "👨🏼‍❤‍💋‍👨🏿",
+      "👨🏼‍❤️‍💋‍👨🏿", "👨🏼‍🤝‍👨🏻", "👨🏼‍🤝‍👨🏽",
+      "👨🏼‍🤝‍👨🏾", "👨🏼‍🤝‍👨🏿", "👨🏽‍❤‍👨🏻",
       "👨🏽‍❤️‍👨🏻", "👨🏽‍❤‍👨🏼", "👨🏽‍❤️‍👨🏼",
       "👨🏽‍❤‍👨🏽", "👨🏽‍❤️‍👨🏽", "👨🏽‍❤‍👨🏾",
       "👨🏽‍❤️‍👨🏾", "👨🏽‍❤‍👨🏿", "👨🏽‍❤️‍👨🏿",
       "👨🏽‍❤‍💋‍👨🏻", "👨🏽‍❤️‍💋‍👨🏻", "👨🏽‍❤‍💋‍👨🏼",
       "👨🏽‍❤️‍💋‍👨🏼", "👨🏽‍❤‍💋‍👨🏽", "👨🏽‍❤️‍💋‍👨🏽",
       "👨🏽‍❤‍💋‍👨🏾", "👨🏽‍❤️‍💋‍👨🏾", "👨🏽‍❤‍💋‍👨🏿",
-      "👨🏽‍❤️‍💋‍👨🏿", "👨🏽‍🤝‍👨🏻", "👨🏽‍🤝‍👨🏻",
-      "👨🏽‍🤝‍👨🏼", "👨🏽‍🤝‍👨🏼", "👨🏽‍🤝‍👨🏾",
-      "👨🏽‍🤝‍👨🏾", "👨🏽‍🤝‍👨🏿", "👨🏽‍🤝‍👨🏿",
-      "👨🏾‍❤‍👨🏻", "👨🏾‍❤️‍👨🏻", "👨🏾‍❤‍👨🏼",
-      "👨🏾‍❤️‍👨🏼", "👨🏾‍❤‍👨🏽", "👨🏾‍❤️‍👨🏽",
-      "👨🏾‍❤‍👨🏾", "👨🏾‍❤️‍👨🏾", "👨🏾‍❤‍👨🏿",
-      "👨🏾‍❤️‍👨🏿", "👨🏾‍❤‍💋‍👨🏻", "👨🏾‍❤️‍💋‍👨🏻",
-      "👨🏾‍❤‍💋‍👨🏼", "👨🏾‍❤️‍💋‍👨🏼", "👨🏾‍❤‍💋‍👨🏽",
-      "👨🏾‍❤️‍💋‍👨🏽", "👨🏾‍❤‍💋‍👨🏾", "👨🏾‍❤️‍💋‍👨🏾",
-      "👨🏾‍❤‍💋‍👨🏿", "👨🏾‍❤️‍💋‍👨🏿", "👨🏾‍🤝‍👨🏻",
-      "👨🏾‍🤝‍👨🏻", "👨🏾‍🤝‍👨🏼", "👨🏾‍🤝‍👨🏼",
-      "👨🏾‍🤝‍👨🏽", "👨🏾‍🤝‍👨🏽", "👨🏾‍🤝‍👨🏿",
-      "👨🏾‍🤝‍👨🏿", "👨🏿‍❤‍👨🏻", "👨🏿‍❤️‍👨🏻",
-      "👨🏿‍❤‍👨🏼", "👨🏿‍❤️‍👨🏼", "👨🏿‍❤‍👨🏽",
-      "👨🏿‍❤️‍👨🏽", "👨🏿‍❤‍👨🏾", "👨🏿‍❤️‍👨🏾",
-      "👨🏿‍❤‍👨🏿", "👨🏿‍❤️‍👨🏿", "👨🏿‍❤‍💋‍👨🏻",
-      "👨🏿‍❤️‍💋‍👨🏻", "👨🏿‍❤‍💋‍👨🏼", "👨🏿‍❤️‍💋‍👨🏼",
-      "👨🏿‍❤‍💋‍👨🏽", "👨🏿‍❤️‍💋‍👨🏽", "👨🏿‍❤‍💋‍👨🏾",
-      "👨🏿‍❤️‍💋‍👨🏾", "👨🏿‍❤‍💋‍👨🏿", "👨🏿‍❤️‍💋‍👨🏿",
-      "👨🏿‍🤝‍👨🏻", "👨🏿‍🤝‍👨🏻", "👨🏿‍🤝‍👨🏼",
-      "👨🏿‍🤝‍👨🏼", "👨🏿‍🤝‍👨🏽", "👨🏿‍🤝‍👨🏽",
-      "👨🏿‍🤝‍👨🏾", "👨🏿‍🤝‍👨🏾", "👩‍❤‍👨", "👩‍❤️‍👨",
+      "👨🏽‍❤️‍💋‍👨🏿", "👨🏽‍🤝‍👨🏻", "👨🏽‍🤝‍👨🏼",
+      "👨🏽‍🤝‍👨🏾", "👨🏽‍🤝‍👨🏿", "👨🏾‍❤‍👨🏻",
+      "👨🏾‍❤️‍👨🏻", "👨🏾‍❤‍👨🏼", "👨🏾‍❤️‍👨🏼",
+      "👨🏾‍❤‍👨🏽", "👨🏾‍❤️‍👨🏽", "👨🏾‍❤‍👨🏾",
+      "👨🏾‍❤️‍👨🏾", "👨🏾‍❤‍👨🏿", "👨🏾‍❤️‍👨🏿",
+      "👨🏾‍❤‍💋‍👨🏻", "👨🏾‍❤️‍💋‍👨🏻", "👨🏾‍❤‍💋‍👨🏼",
+      "👨🏾‍❤️‍💋‍👨🏼", "👨🏾‍❤‍💋‍👨🏽", "👨🏾‍❤️‍💋‍👨🏽",
+      "👨🏾‍❤‍💋‍👨🏾", "👨🏾‍❤️‍💋‍👨🏾", "👨🏾‍❤‍💋‍👨🏿",
+      "👨🏾‍❤️‍💋‍👨🏿", "👨🏾‍🤝‍👨🏻", "👨🏾‍🤝‍👨🏼",
+      "👨🏾‍🤝‍👨🏽", "👨🏾‍🤝‍👨🏿", "👨🏿‍❤‍👨🏻",
+      "👨🏿‍❤️‍👨🏻", "👨🏿‍❤‍👨🏼", "👨🏿‍❤️‍👨🏼",
+      "👨🏿‍❤‍👨🏽", "👨🏿‍❤️‍👨🏽", "👨🏿‍❤‍👨🏾",
+      "👨🏿‍❤️‍👨🏾", "👨🏿‍❤‍👨🏿", "👨🏿‍❤️‍👨🏿",
+      "👨🏿‍❤‍💋‍👨🏻", "👨🏿‍❤️‍💋‍👨🏻", "👨🏿‍❤‍💋‍👨🏼",
+      "👨🏿‍❤️‍💋‍👨🏼", "👨🏿‍❤‍💋‍👨🏽", "👨🏿‍❤️‍💋‍👨🏽",
+      "👨🏿‍❤‍💋‍👨🏾", "👨🏿‍❤️‍💋‍👨🏾", "👨🏿‍❤‍💋‍👨🏿",
+      "👨🏿‍❤️‍💋‍👨🏿", "👨🏿‍🤝‍👨🏻", "👨🏿‍🤝‍👨🏼",
+      "👨🏿‍🤝‍👨🏽", "👨🏿‍🤝‍👨🏾", "👩‍❤‍👨", "👩‍❤️‍👨",
       "👩‍❤‍👩", "👩‍❤️‍👩", "👩‍❤‍💋‍👨", "👩‍❤️‍💋‍👨",
-      "👩‍❤‍💋‍👩", "👩‍❤️‍💋‍👩", "👩‍👦", "👩‍👦", "👩‍👦‍👦",
-      "👩‍👦‍👦", "👩‍👧", "👩‍👧", "👩‍👧‍👦", "👩‍👧‍👦",
-      "👩‍👧‍👧", "👩‍👧‍👧", "👩‍👩‍👦", "👩‍👩‍👦",
-      "👩‍👩‍👦‍👦", "👩‍👩‍👦‍👦", "👩‍👩‍👧", "👩‍👩‍👧",
-      "👩‍👩‍👧‍👦", "👩‍👩‍👧‍👦", "👩‍👩‍👧‍👧",
-      "👩‍👩‍👧‍👧", "👩🏻‍❤‍👨🏻", "👩🏻‍❤️‍👨🏻",
-      "👩🏻‍❤‍👨🏼", "👩🏻‍❤️‍👨🏼", "👩🏻‍❤‍👨🏽",
-      "👩🏻‍❤️‍👨🏽", "👩🏻‍❤‍👨🏾", "👩🏻‍❤️‍👨🏾",
-      "👩🏻‍❤‍👨🏿", "👩🏻‍❤️‍👨🏿", "👩🏻‍❤‍👩🏻",
-      "👩🏻‍❤️‍👩🏻", "👩🏻‍❤‍👩🏼", "👩🏻‍❤️‍👩🏼",
-      "👩🏻‍❤‍👩🏽", "👩🏻‍❤️‍👩🏽", "👩🏻‍❤‍👩🏾",
-      "👩🏻‍❤️‍👩🏾", "👩🏻‍❤‍👩🏿", "👩🏻‍❤️‍👩🏿",
-      "👩🏻‍❤‍💋‍👨🏻", "👩🏻‍❤️‍💋‍👨🏻", "👩🏻‍❤‍💋‍👨🏼",
-      "👩🏻‍❤️‍💋‍👨🏼", "👩🏻‍❤‍💋‍👨🏽", "👩🏻‍❤️‍💋‍👨🏽",
-      "👩🏻‍❤‍💋‍👨🏾", "👩🏻‍❤️‍💋‍👨🏾", "👩🏻‍❤‍💋‍👨🏿",
-      "👩🏻‍❤️‍💋‍👨🏿", "👩🏻‍❤‍💋‍👩🏻", "👩🏻‍❤️‍💋‍👩🏻",
-      "👩🏻‍❤‍💋‍👩🏼", "👩🏻‍❤️‍💋‍👩🏼", "👩🏻‍❤‍💋‍👩🏽",
-      "👩🏻‍❤️‍💋‍👩🏽", "👩🏻‍❤‍💋‍👩🏾", "👩🏻‍❤️‍💋‍👩🏾",
-      "👩🏻‍❤‍💋‍👩🏿", "👩🏻‍❤️‍💋‍👩🏿", "👩🏻‍🤝‍👨🏼",
-      "👩🏻‍🤝‍👨🏼", "👩🏻‍🤝‍👨🏽", "👩🏻‍🤝‍👨🏽",
-      "👩🏻‍🤝‍👨🏾", "👩🏻‍🤝‍👨🏾", "👩🏻‍🤝‍👨🏿",
-      "👩🏻‍🤝‍👨🏿", "👩🏻‍🤝‍👩🏼", "👩🏻‍🤝‍👩🏼",
-      "👩🏻‍🤝‍👩🏽", "👩🏻‍🤝‍👩🏽", "👩🏻‍🤝‍👩🏾",
-      "👩🏻‍🤝‍👩🏾", "👩🏻‍🤝‍👩🏿", "👩🏻‍🤝‍👩🏿",
-      "👩🏼‍❤‍👨🏻", "👩🏼‍❤️‍👨🏻", "👩🏼‍❤‍👨🏼",
-      "👩🏼‍❤️‍👨🏼", "👩🏼‍❤‍👨🏽", "👩🏼‍❤️‍👨🏽",
-      "👩🏼‍❤‍👨🏾", "👩🏼‍❤️‍👨🏾", "👩🏼‍❤‍👨🏿",
-      "👩🏼‍❤️‍👨🏿", "👩🏼‍❤‍👩🏻", "👩🏼‍❤️‍👩🏻",
-      "👩🏼‍❤‍👩🏼", "👩🏼‍❤️‍👩🏼", "👩🏼‍❤‍👩🏽",
-      "👩🏼‍❤️‍👩🏽", "👩🏼‍❤‍👩🏾", "👩🏼‍❤️‍👩🏾",
-      "👩🏼‍❤‍👩🏿", "👩🏼‍❤️‍👩🏿", "👩🏼‍❤‍💋‍👨🏻",
-      "👩🏼‍❤️‍💋‍👨🏻", "👩🏼‍❤‍💋‍👨🏼", "👩🏼‍❤️‍💋‍👨🏼",
-      "👩🏼‍❤‍💋‍👨🏽", "👩🏼‍❤️‍💋‍👨🏽", "👩🏼‍❤‍💋‍👨🏾",
-      "👩🏼‍❤️‍💋‍👨🏾", "👩🏼‍❤‍💋‍👨🏿", "👩🏼‍❤️‍💋‍👨🏿",
-      "👩🏼‍❤‍💋‍👩🏻", "👩🏼‍❤️‍💋‍👩🏻", "👩🏼‍❤‍💋‍👩🏼",
-      "👩🏼‍❤️‍💋‍👩🏼", "👩🏼‍❤‍💋‍👩🏽", "👩🏼‍❤️‍💋‍👩🏽",
-      "👩🏼‍❤‍💋‍👩🏾", "👩🏼‍❤️‍💋‍👩🏾", "👩🏼‍❤‍💋‍👩🏿",
-      "👩🏼‍❤️‍💋‍👩🏿", "👩🏼‍🤝‍👨🏻", "👩🏼‍🤝‍👨🏻",
-      "👩🏼‍🤝‍👨🏽", "👩🏼‍🤝‍👨🏽", "👩🏼‍🤝‍👨🏾",
-      "👩🏼‍🤝‍👨🏾", "👩🏼‍🤝‍👨🏿", "👩🏼‍🤝‍👨🏿",
-      "👩🏼‍🤝‍👩🏻", "👩🏼‍🤝‍👩🏻", "👩🏼‍🤝‍👩🏽",
-      "👩🏼‍🤝‍👩🏽", "👩🏼‍🤝‍👩🏾", "👩🏼‍🤝‍👩🏾",
-      "👩🏼‍🤝‍👩🏿", "👩🏼‍🤝‍👩🏿", "👩🏽‍❤‍👨🏻",
+      "👩‍❤‍💋‍👩", "👩‍❤️‍💋‍👩", "👩‍👦", "👩‍👦‍👦", "👩‍👧",
+      "👩‍👧‍👦", "👩‍👧‍👧", "👩‍👩‍👦", "👩‍👩‍👦‍👦",
+      "👩‍👩‍👧", "👩‍👩‍👧‍👦", "👩‍👩‍👧‍👧", "👩🏻‍❤‍👨🏻",
+      "👩🏻‍❤️‍👨🏻", "👩🏻‍❤‍👨🏼", "👩🏻‍❤️‍👨🏼",
+      "👩🏻‍❤‍👨🏽", "👩🏻‍❤️‍👨🏽", "👩🏻‍❤‍👨🏾",
+      "👩🏻‍❤️‍👨🏾", "👩🏻‍❤‍👨🏿", "👩🏻‍❤️‍👨🏿",
+      "👩🏻‍❤‍👩🏻", "👩🏻‍❤️‍👩🏻", "👩🏻‍❤‍👩🏼",
+      "👩🏻‍❤️‍👩🏼", "👩🏻‍❤‍👩🏽", "👩🏻‍❤️‍👩🏽",
+      "👩🏻‍❤‍👩🏾", "👩🏻‍❤️‍👩🏾", "👩🏻‍❤‍👩🏿",
+      "👩🏻‍❤️‍👩🏿", "👩🏻‍❤‍💋‍👨🏻", "👩🏻‍❤️‍💋‍👨🏻",
+      "👩🏻‍❤‍💋‍👨🏼", "👩🏻‍❤️‍💋‍👨🏼", "👩🏻‍❤‍💋‍👨🏽",
+      "👩🏻‍❤️‍💋‍👨🏽", "👩🏻‍❤‍💋‍👨🏾", "👩🏻‍❤️‍💋‍👨🏾",
+      "👩🏻‍❤‍💋‍👨🏿", "👩🏻‍❤️‍💋‍👨🏿", "👩🏻‍❤‍💋‍👩🏻",
+      "👩🏻‍❤️‍💋‍👩🏻", "👩🏻‍❤‍💋‍👩🏼", "👩🏻‍❤️‍💋‍👩🏼",
+      "👩🏻‍❤‍💋‍👩🏽", "👩🏻‍❤️‍💋‍👩🏽", "👩🏻‍❤‍💋‍👩🏾",
+      "👩🏻‍❤️‍💋‍👩🏾", "👩🏻‍❤‍💋‍👩🏿", "👩🏻‍❤️‍💋‍👩🏿",
+      "👩🏻‍🤝‍👨🏼", "👩🏻‍🤝‍👨🏽", "👩🏻‍🤝‍👨🏾",
+      "👩🏻‍🤝‍👨🏿", "👩🏻‍🤝‍👩🏼", "👩🏻‍🤝‍👩🏽",
+      "👩🏻‍🤝‍👩🏾", "👩🏻‍🤝‍👩🏿", "👩🏼‍❤‍👨🏻",
+      "👩🏼‍❤️‍👨🏻", "👩🏼‍❤‍👨🏼", "👩🏼‍❤️‍👨🏼",
+      "👩🏼‍❤‍👨🏽", "👩🏼‍❤️‍👨🏽", "👩🏼‍❤‍👨🏾",
+      "👩🏼‍❤️‍👨🏾", "👩🏼‍❤‍👨🏿", "👩🏼‍❤️‍👨🏿",
+      "👩🏼‍❤‍👩🏻", "👩🏼‍❤️‍👩🏻", "👩🏼‍❤‍👩🏼",
+      "👩🏼‍❤️‍👩🏼", "👩🏼‍❤‍👩🏽", "👩🏼‍❤️‍👩🏽",
+      "👩🏼‍❤‍👩🏾", "👩🏼‍❤️‍👩🏾", "👩🏼‍❤‍👩🏿",
+      "👩🏼‍❤️‍👩🏿", "👩🏼‍❤‍💋‍👨🏻", "👩🏼‍❤️‍💋‍👨🏻",
+      "👩🏼‍❤‍💋‍👨🏼", "👩🏼‍❤️‍💋‍👨🏼", "👩🏼‍❤‍💋‍👨🏽",
+      "👩🏼‍❤️‍💋‍👨🏽", "👩🏼‍❤‍💋‍👨🏾", "👩🏼‍❤️‍💋‍👨🏾",
+      "👩🏼‍❤‍💋‍👨🏿", "👩🏼‍❤️‍💋‍👨🏿", "👩🏼‍❤‍💋‍👩🏻",
+      "👩🏼‍❤️‍💋‍👩🏻", "👩🏼‍❤‍💋‍👩🏼", "👩🏼‍❤️‍💋‍👩🏼",
+      "👩🏼‍❤‍💋‍👩🏽", "👩🏼‍❤️‍💋‍👩🏽", "👩🏼‍❤‍💋‍👩🏾",
+      "👩🏼‍❤️‍💋‍👩🏾", "👩🏼‍❤‍💋‍👩🏿", "👩🏼‍❤️‍💋‍👩🏿",
+      "👩🏼‍🤝‍👨🏻", "👩🏼‍🤝‍👨🏽", "👩🏼‍🤝‍👨🏾",
+      "👩🏼‍🤝‍👨🏿", "👩🏼‍🤝‍👩🏻", "👩🏼‍🤝‍👩🏽",
+      "👩🏼‍🤝‍👩🏾", "👩🏼‍🤝‍👩🏿", "👩🏽‍❤‍👨🏻",
       "👩🏽‍❤️‍👨🏻", "👩🏽‍❤‍👨🏼", "👩🏽‍❤️‍👨🏼",
       "👩🏽‍❤‍👨🏽", "👩🏽‍❤️‍👨🏽", "👩🏽‍❤‍👨🏾",
       "👩🏽‍❤️‍👨🏾", "👩🏽‍❤‍👨🏿", "👩🏽‍❤️‍👨🏿",
@@ -373,464 +288,378 @@ bool is_emoji(Slice str) {
       "👩🏽‍❤️‍💋‍👩🏻", "👩🏽‍❤‍💋‍👩🏼", "👩🏽‍❤️‍💋‍👩🏼",
       "👩🏽‍❤‍💋‍👩🏽", "👩🏽‍❤️‍💋‍👩🏽", "👩🏽‍❤‍💋‍👩🏾",
       "👩🏽‍❤️‍💋‍👩🏾", "👩🏽‍❤‍💋‍👩🏿", "👩🏽‍❤️‍💋‍👩🏿",
-      "👩🏽‍🤝‍👨🏻", "👩🏽‍🤝‍👨🏻", "👩🏽‍🤝‍👨🏼",
-      "👩🏽‍🤝‍👨🏼", "👩🏽‍🤝‍👨🏾", "👩🏽‍🤝‍👨🏾",
-      "👩🏽‍🤝‍👨🏿", "👩🏽‍🤝‍👨🏿", "👩🏽‍🤝‍👩🏻",
-      "👩🏽‍🤝‍👩🏻", "👩🏽‍🤝‍👩🏼", "👩🏽‍🤝‍👩🏼",
-      "👩🏽‍🤝‍👩🏾", "👩🏽‍🤝‍👩🏾", "👩🏽‍🤝‍👩🏿",
-      "👩🏽‍🤝‍👩🏿", "👩🏾‍❤‍👨🏻", "👩🏾‍❤️‍👨🏻",
-      "👩🏾‍❤‍👨🏼", "👩🏾‍❤️‍👨🏼", "👩🏾‍❤‍👨🏽",
-      "👩🏾‍❤️‍👨🏽", "👩🏾‍❤‍👨🏾", "👩🏾‍❤️‍👨🏾",
-      "👩🏾‍❤‍👨🏿", "👩🏾‍❤️‍👨🏿", "👩🏾‍❤‍👩🏻",
-      "👩🏾‍❤️‍👩🏻", "👩🏾‍❤‍👩🏼", "👩🏾‍❤️‍👩🏼",
-      "👩🏾‍❤‍👩🏽", "👩🏾‍❤️‍👩🏽", "👩🏾‍❤‍👩🏾",
-      "👩🏾‍❤️‍👩🏾", "👩🏾‍❤‍👩🏿", "👩🏾‍❤️‍👩🏿",
-      "👩🏾‍❤‍💋‍👨🏻", "👩🏾‍❤️‍💋‍👨🏻", "👩🏾‍❤‍💋‍👨🏼",
-      "👩🏾‍❤️‍💋‍👨🏼", "👩🏾‍❤‍💋‍👨🏽", "👩🏾‍❤️‍💋‍👨🏽",
-      "👩🏾‍❤‍💋‍👨🏾", "👩🏾‍❤️‍💋‍👨🏾", "👩🏾‍❤‍💋‍👨🏿",
-      "👩🏾‍❤️‍💋‍👨🏿", "👩🏾‍❤‍💋‍👩🏻", "👩🏾‍❤️‍💋‍👩🏻",
-      "👩🏾‍❤‍💋‍👩🏼", "👩🏾‍❤️‍💋‍👩🏼", "👩🏾‍❤‍💋‍👩🏽",
-      "👩🏾‍❤️‍💋‍👩🏽", "👩🏾‍❤‍💋‍👩🏾", "👩🏾‍❤️‍💋‍👩🏾",
-      "👩🏾‍❤‍💋‍👩🏿", "👩🏾‍❤️‍💋‍👩🏿", "👩🏾‍🤝‍👨🏻",
-      "👩🏾‍🤝‍👨🏻", "👩🏾‍🤝‍👨🏼", "👩🏾‍🤝‍👨🏼",
-      "👩🏾‍🤝‍👨🏽", "👩🏾‍🤝‍👨🏽", "👩🏾‍🤝‍👨🏿",
-      "👩🏾‍🤝‍👨🏿", "👩🏾‍🤝‍👩🏻", "👩🏾‍🤝‍👩🏻",
-      "👩🏾‍🤝‍👩🏼", "👩🏾‍🤝‍👩🏼", "👩🏾‍🤝‍👩🏽",
-      "👩🏾‍🤝‍👩🏽", "👩🏾‍🤝‍👩🏿", "👩🏾‍🤝‍👩🏿",
-      "👩🏿‍❤‍👨🏻", "👩🏿‍❤️‍👨🏻", "👩🏿‍❤‍👨🏼",
-      "👩🏿‍❤️‍👨🏼", "👩🏿‍❤‍👨🏽", "👩🏿‍❤️‍👨🏽",
-      "👩🏿‍❤‍👨🏾", "👩🏿‍❤️‍👨🏾", "👩🏿‍❤‍👨🏿",
-      "👩🏿‍❤️‍👨🏿", "👩🏿‍❤‍👩🏻", "👩🏿‍❤️‍👩🏻",
-      "👩🏿‍❤‍👩🏼", "👩🏿‍❤️‍👩🏼", "👩🏿‍❤‍👩🏽",
-      "👩🏿‍❤️‍👩🏽", "👩🏿‍❤‍👩🏾", "👩🏿‍❤️‍👩🏾",
-      "👩🏿‍❤‍👩🏿", "👩🏿‍❤️‍👩🏿", "👩🏿‍❤‍💋‍👨🏻",
-      "👩🏿‍❤️‍💋‍👨🏻", "👩🏿‍❤‍💋‍👨🏼", "👩🏿‍❤️‍💋‍👨🏼",
-      "👩🏿‍❤‍💋‍👨🏽", "👩🏿‍❤️‍💋‍👨🏽", "👩🏿‍❤‍💋‍👨🏾",
-      "👩🏿‍❤️‍💋‍👨🏾", "👩🏿‍❤‍💋‍👨🏿", "👩🏿‍❤️‍💋‍👨🏿",
-      "👩🏿‍❤‍💋‍👩🏻", "👩🏿‍❤️‍💋‍👩🏻", "👩🏿‍❤‍💋‍👩🏼",
-      "👩🏿‍❤️‍💋‍👩🏼", "👩🏿‍❤‍💋‍👩🏽", "👩🏿‍❤️‍💋‍👩🏽",
-      "👩🏿‍❤‍💋‍👩🏾", "👩🏿‍❤️‍💋‍👩🏾", "👩🏿‍❤‍💋‍👩🏿",
-      "👩🏿‍❤️‍💋‍👩🏿", "👩🏿‍🤝‍👨🏻", "👩🏿‍🤝‍👨🏻",
-      "👩🏿‍🤝‍👨🏼", "👩🏿‍🤝‍👨🏼", "👩🏿‍🤝‍👨🏽",
-      "👩🏿‍🤝‍👨🏽", "👩🏿‍🤝‍👨🏾", "👩🏿‍🤝‍👨🏾",
-      "👩🏿‍🤝‍👩🏻", "👩🏿‍🤝‍👩🏻", "👩🏿‍🤝‍👩🏼",
-      "👩🏿‍🤝‍👩🏼", "👩🏿‍🤝‍👩🏽", "👩🏿‍🤝‍👩🏽",
-      "👩🏿‍🤝‍👩🏾", "👩🏿‍🤝‍👩🏾", "🧑‍🤝‍🧑", "🧑‍🤝‍🧑",
+      "👩🏽‍🤝‍👨🏻", "👩🏽‍🤝‍👨🏼", "👩🏽‍🤝‍👨🏾",
+      "👩🏽‍🤝‍👨🏿", "👩🏽‍🤝‍👩🏻", "👩🏽‍🤝‍👩🏼",
+      "👩🏽‍🤝‍👩🏾", "👩🏽‍🤝‍👩🏿", "👩🏾‍❤‍👨🏻",
+      "👩🏾‍❤️‍👨🏻", "👩🏾‍❤‍👨🏼", "👩🏾‍❤️‍👨🏼",
+      "👩🏾‍❤‍👨🏽", "👩🏾‍❤️‍👨🏽", "👩🏾‍❤‍👨🏾",
+      "👩🏾‍❤️‍👨🏾", "👩🏾‍❤‍👨🏿", "👩🏾‍❤️‍👨🏿",
+      "👩🏾‍❤‍👩🏻", "👩🏾‍❤️‍👩🏻", "👩🏾‍❤‍👩🏼",
+      "👩🏾‍❤️‍👩🏼", "👩🏾‍❤‍👩🏽", "👩🏾‍❤️‍👩🏽",
+      "👩🏾‍❤‍👩🏾", "👩🏾‍❤️‍👩🏾", "👩🏾‍❤‍👩🏿",
+      "👩🏾‍❤️‍👩🏿", "👩🏾‍❤‍💋‍👨🏻", "👩🏾‍❤️‍💋‍👨🏻",
+      "👩🏾‍❤‍💋‍👨🏼", "👩🏾‍❤️‍💋‍👨🏼", "👩🏾‍❤‍💋‍👨🏽",
+      "👩🏾‍❤️‍💋‍👨🏽", "👩🏾‍❤‍💋‍👨🏾", "👩🏾‍❤️‍💋‍👨🏾",
+      "👩🏾‍❤‍💋‍👨🏿", "👩🏾‍❤️‍💋‍👨🏿", "👩🏾‍❤‍💋‍👩🏻",
+      "👩🏾‍❤️‍💋‍👩🏻", "👩🏾‍❤‍💋‍👩🏼", "👩🏾‍❤️‍💋‍👩🏼",
+      "👩🏾‍❤‍💋‍👩🏽", "👩🏾‍❤️‍💋‍👩🏽", "👩🏾‍❤‍💋‍👩🏾",
+      "👩🏾‍❤️‍💋‍👩🏾", "👩🏾‍❤‍💋‍👩🏿", "👩🏾‍❤️‍💋‍👩🏿",
+      "👩🏾‍🤝‍👨🏻", "👩🏾‍🤝‍👨🏼", "👩🏾‍🤝‍👨🏽",
+      "👩🏾‍🤝‍👨🏿", "👩🏾‍🤝‍👩🏻", "👩🏾‍🤝‍👩🏼",
+      "👩🏾‍🤝‍👩🏽", "👩🏾‍🤝‍👩🏿", "👩🏿‍❤‍👨🏻",
+      "👩🏿‍❤️‍👨🏻", "👩🏿‍❤‍👨🏼", "👩🏿‍❤️‍👨🏼",
+      "👩🏿‍❤‍👨🏽", "👩🏿‍❤️‍👨🏽", "👩🏿‍❤‍👨🏾",
+      "👩🏿‍❤️‍👨🏾", "👩🏿‍❤‍👨🏿", "👩🏿‍❤️‍👨🏿",
+      "👩🏿‍❤‍👩🏻", "👩🏿‍❤️‍👩🏻", "👩🏿‍❤‍👩🏼",
+      "👩🏿‍❤️‍👩🏼", "👩🏿‍❤‍👩🏽", "👩🏿‍❤️‍👩🏽",
+      "👩🏿‍❤‍👩🏾", "👩🏿‍❤️‍👩🏾", "👩🏿‍❤‍👩🏿",
+      "👩🏿‍❤️‍👩🏿", "👩🏿‍❤‍💋‍👨🏻", "👩🏿‍❤️‍💋‍👨🏻",
+      "👩🏿‍❤‍💋‍👨🏼", "👩🏿‍❤️‍💋‍👨🏼", "👩🏿‍❤‍💋‍👨🏽",
+      "👩🏿‍❤️‍💋‍👨🏽", "👩🏿‍❤‍💋‍👨🏾", "👩🏿‍❤️‍💋‍👨🏾",
+      "👩🏿‍❤‍💋‍👨🏿", "👩🏿‍❤️‍💋‍👨🏿", "👩🏿‍❤‍💋‍👩🏻",
+      "👩🏿‍❤️‍💋‍👩🏻", "👩🏿‍❤‍💋‍👩🏼", "👩🏿‍❤️‍💋‍👩🏼",
+      "👩🏿‍❤‍💋‍👩🏽", "👩🏿‍❤️‍💋‍👩🏽", "👩🏿‍❤‍💋‍👩🏾",
+      "👩🏿‍❤️‍💋‍👩🏾", "👩🏿‍❤‍💋‍👩🏿", "👩🏿‍❤️‍💋‍👩🏿",
+      "👩🏿‍🤝‍👨🏻", "👩🏿‍🤝‍👨🏼", "👩🏿‍🤝‍👨🏽",
+      "👩🏿‍🤝‍👨🏾", "👩🏿‍🤝‍👩🏻", "👩🏿‍🤝‍👩🏼",
+      "👩🏿‍🤝‍👩🏽", "👩🏿‍🤝‍👩🏾", "🧑‍🤝‍🧑",
       "🧑🏻‍❤‍💋‍🧑🏼", "🧑🏻‍❤️‍💋‍🧑🏼", "🧑🏻‍❤‍💋‍🧑🏽",
       "🧑🏻‍❤️‍💋‍🧑🏽", "🧑🏻‍❤‍💋‍🧑🏾", "🧑🏻‍❤️‍💋‍🧑🏾",
       "🧑🏻‍❤‍💋‍🧑🏿", "🧑🏻‍❤️‍💋‍🧑🏿", "🧑🏻‍❤‍🧑🏼",
       "🧑🏻‍❤️‍🧑🏼", "🧑🏻‍❤‍🧑🏽", "🧑🏻‍❤️‍🧑🏽",
       "🧑🏻‍❤‍🧑🏾", "🧑🏻‍❤️‍🧑🏾", "🧑🏻‍❤‍🧑🏿",
-      "🧑🏻‍❤️‍🧑🏿", "🧑🏻‍🎄", "🧑🏻‍🎄", "🧑🏻‍🤝‍🧑🏻",
-      "🧑🏻‍🤝‍🧑🏻", "🧑🏻‍🤝‍🧑🏼", "🧑🏻‍🤝‍🧑🏼",
-      "🧑🏻‍🤝‍🧑🏽", "🧑🏻‍🤝‍🧑🏽", "🧑🏻‍🤝‍🧑🏾",
-      "🧑🏻‍🤝‍🧑🏾", "🧑🏻‍🤝‍🧑🏿", "🧑🏻‍🤝‍🧑🏿",
+      "🧑🏻‍❤️‍🧑🏿", "🧑🏻‍🎄", "🧑🏻‍🤝‍🧑🏻", "🧑🏻‍🤝‍🧑🏼",
+      "🧑🏻‍🤝‍🧑🏽", "🧑🏻‍🤝‍🧑🏾", "🧑🏻‍🤝‍🧑🏿",
       "🧑🏼‍❤‍💋‍🧑🏻", "🧑🏼‍❤️‍💋‍🧑🏻", "🧑🏼‍❤‍💋‍🧑🏽",
       "🧑🏼‍❤️‍💋‍🧑🏽", "🧑🏼‍❤‍💋‍🧑🏾", "🧑🏼‍❤️‍💋‍🧑🏾",
       "🧑🏼‍❤‍💋‍🧑🏿", "🧑🏼‍❤️‍💋‍🧑🏿", "🧑🏼‍❤‍🧑🏻",
       "🧑🏼‍❤️‍🧑🏻", "🧑🏼‍❤‍🧑🏽", "🧑🏼‍❤️‍🧑🏽",
       "🧑🏼‍❤‍🧑🏾", "🧑🏼‍❤️‍🧑🏾", "🧑🏼‍❤‍🧑🏿",
-      "🧑🏼‍❤️‍🧑🏿", "🧑🏼‍🎄", "🧑🏼‍🎄", "🧑🏼‍🤝‍🧑🏻",
-      "🧑🏼‍🤝‍🧑🏻", "🧑🏼‍🤝‍🧑🏼", "🧑🏼‍🤝‍🧑🏼",
-      "🧑🏼‍🤝‍🧑🏽", "🧑🏼‍🤝‍🧑🏽", "🧑🏼‍🤝‍🧑🏾",
-      "🧑🏼‍🤝‍🧑🏾", "🧑🏼‍🤝‍🧑🏿", "🧑🏼‍🤝‍🧑🏿",
+      "🧑🏼‍❤️‍🧑🏿", "🧑🏼‍🎄", "🧑🏼‍🤝‍🧑🏻", "🧑🏼‍🤝‍🧑🏼",
+      "🧑🏼‍🤝‍🧑🏽", "🧑🏼‍🤝‍🧑🏾", "🧑🏼‍🤝‍🧑🏿",
       "🧑🏽‍❤‍💋‍🧑🏻", "🧑🏽‍❤️‍💋‍🧑🏻", "🧑🏽‍❤‍💋‍🧑🏼",
       "🧑🏽‍❤️‍💋‍🧑🏼", "🧑🏽‍❤‍💋‍🧑🏾", "🧑🏽‍❤️‍💋‍🧑🏾",
       "🧑🏽‍❤‍💋‍🧑🏿", "🧑🏽‍❤️‍💋‍🧑🏿", "🧑🏽‍❤‍🧑🏻",
       "🧑🏽‍❤️‍🧑🏻", "🧑🏽‍❤‍🧑🏼", "🧑🏽‍❤️‍🧑🏼",
       "🧑🏽‍❤‍🧑🏾", "🧑🏽‍❤️‍🧑🏾", "🧑🏽‍❤‍🧑🏿",
-      "🧑🏽‍❤️‍🧑🏿", "🧑🏽‍🎄", "🧑🏽‍🎄", "🧑🏽‍🤝‍🧑🏻",
-      "🧑🏽‍🤝‍🧑🏻", "🧑🏽‍🤝‍🧑🏼", "🧑🏽‍🤝‍🧑🏼",
-      "🧑🏽‍🤝‍🧑🏽", "🧑🏽‍🤝‍🧑🏽", "🧑🏽‍🤝‍🧑🏾",
-      "🧑🏽‍🤝‍🧑🏾", "🧑🏽‍🤝‍🧑🏿", "🧑🏽‍🤝‍🧑🏿",
+      "🧑🏽‍❤️‍🧑🏿", "🧑🏽‍🎄", "🧑🏽‍🤝‍🧑🏻", "🧑🏽‍🤝‍🧑🏼",
+      "🧑🏽‍🤝‍🧑🏽", "🧑🏽‍🤝‍🧑🏾", "🧑🏽‍🤝‍🧑🏿",
       "🧑🏾‍❤‍💋‍🧑🏻", "🧑🏾‍❤️‍💋‍🧑🏻", "🧑🏾‍❤‍💋‍🧑🏼",
       "🧑🏾‍❤️‍💋‍🧑🏼", "🧑🏾‍❤‍💋‍🧑🏽", "🧑🏾‍❤️‍💋‍🧑🏽",
       "🧑🏾‍❤‍💋‍🧑🏿", "🧑🏾‍❤️‍💋‍🧑🏿", "🧑🏾‍❤‍🧑🏻",
       "🧑🏾‍❤️‍🧑🏻", "🧑🏾‍❤‍🧑🏼", "🧑🏾‍❤️‍🧑🏼",
       "🧑🏾‍❤‍🧑🏽", "🧑🏾‍❤️‍🧑🏽", "🧑🏾‍❤‍🧑🏿",
-      "🧑🏾‍❤️‍🧑🏿", "🧑🏾‍🎄", "🧑🏾‍🎄", "🧑🏾‍🤝‍🧑🏻",
-      "🧑🏾‍🤝‍🧑🏻", "🧑🏾‍🤝‍🧑🏼", "🧑🏾‍🤝‍🧑🏼",
-      "🧑🏾‍🤝‍🧑🏽", "🧑🏾‍🤝‍🧑🏽", "🧑🏾‍🤝‍🧑🏾",
-      "🧑🏾‍🤝‍🧑🏾", "🧑🏾‍🤝‍🧑🏿", "🧑🏾‍🤝‍🧑🏿",
+      "🧑🏾‍❤️‍🧑🏿", "🧑🏾‍🎄", "🧑🏾‍🤝‍🧑🏻", "🧑🏾‍🤝‍🧑🏼",
+      "🧑🏾‍🤝‍🧑🏽", "🧑🏾‍🤝‍🧑🏾", "🧑🏾‍🤝‍🧑🏿",
       "🧑🏿‍❤‍💋‍🧑🏻", "🧑🏿‍❤️‍💋‍🧑🏻", "🧑🏿‍❤‍💋‍🧑🏼",
       "🧑🏿‍❤️‍💋‍🧑🏼", "🧑🏿‍❤‍💋‍🧑🏽", "🧑🏿‍❤️‍💋‍🧑🏽",
       "🧑🏿‍❤‍💋‍🧑🏾", "🧑🏿‍❤️‍💋‍🧑🏾", "🧑🏿‍❤‍🧑🏻",
       "🧑🏿‍❤️‍🧑🏻", "🧑🏿‍❤‍🧑🏼", "🧑🏿‍❤️‍🧑🏼",
       "🧑🏿‍❤‍🧑🏽", "🧑🏿‍❤️‍🧑🏽", "🧑🏿‍❤‍🧑🏾",
-      "🧑🏿‍❤️‍🧑🏾", "🧑🏿‍🎄", "🧑🏿‍🎄", "🧑🏿‍🤝‍🧑🏻",
-      "🧑🏿‍🤝‍🧑🏻", "🧑🏿‍🤝‍🧑🏼", "🧑🏿‍🤝‍🧑🏼",
-      "🧑🏿‍🤝‍🧑🏽", "🧑🏿‍🤝‍🧑🏽", "🧑🏿‍🤝‍🧑🏾",
-      "🧑🏿‍🤝‍🧑🏾", "🧑🏿‍🤝‍🧑🏿", "🧑🏿‍🤝‍🧑🏿", "🫱🏻‍🫲🏼",
-      "🫱🏻‍🫲🏼", "🫱🏻‍🫲🏽", "🫱🏻‍🫲🏽", "🫱🏻‍🫲🏾", "🫱🏻‍🫲🏾",
-      "🫱🏻‍🫲🏿", "🫱🏻‍🫲🏿", "🫱🏼‍🫲🏻", "🫱🏼‍🫲🏻", "🫱🏼‍🫲🏽",
-      "🫱🏼‍🫲🏽", "🫱🏼‍🫲🏾", "🫱🏼‍🫲🏾", "🫱🏼‍🫲🏿", "🫱🏼‍🫲🏿",
-      "🫱🏽‍🫲🏻", "🫱🏽‍🫲🏻", "🫱🏽‍🫲🏼", "🫱🏽‍🫲🏼", "🫱🏽‍🫲🏾",
-      "🫱🏽‍🫲🏾", "🫱🏽‍🫲🏿", "🫱🏽‍🫲🏿", "🫱🏾‍🫲🏻", "🫱🏾‍🫲🏻",
-      "🫱🏾‍🫲🏼", "🫱🏾‍🫲🏼", "🫱🏾‍🫲🏽", "🫱🏾‍🫲🏽", "🫱🏾‍🫲🏿",
-      "🫱🏾‍🫲🏿", "🫱🏿‍🫲🏻", "🫱🏿‍🫲🏻", "🫱🏿‍🫲🏼", "🫱🏿‍🫲🏼",
-      "🫱🏿‍🫲🏽", "🫱🏿‍🫲🏽", "🫱🏿‍🫲🏾", "🫱🏿‍🫲🏾", "👨‍⚕",
-      "👨‍⚕️", "👨‍⚖", "👨‍⚖️", "👨‍✈", "👨‍✈️", "👨‍🌾", "👨‍🌾",
-      "👨‍🍳", "👨‍🍳", "👨‍🍼", "👨‍🍼", "👨‍🎓", "👨‍🎓", "👨‍🎤",
-      "👨‍🎤", "👨‍🎨", "👨‍🎨", "👨‍🏫", "👨‍🏫", "👨‍🏭", "👨‍🏭",
-      "👨‍💻", "👨‍💻", "👨‍💼", "👨‍💼", "👨‍🔧", "👨‍🔧", "👨‍🔬",
-      "👨‍🔬", "👨‍🚀", "👨‍🚀", "👨‍🚒", "👨‍🚒", "👨‍🦯", "👨‍🦯",
-      "👨‍🦼", "👨‍🦼", "👨‍🦽", "👨‍🦽", "👨🏻‍⚕", "👨🏻‍⚕️",
-      "👨🏻‍⚖", "👨🏻‍⚖️", "👨🏻‍✈", "👨🏻‍✈️", "👨🏻‍🌾",
-      "👨🏻‍🌾", "👨🏻‍🍳", "👨🏻‍🍳", "👨🏻‍🍼", "👨🏻‍🍼", "👨🏻‍🎓",
-      "👨🏻‍🎓", "👨🏻‍🎤", "👨🏻‍🎤", "👨🏻‍🎨", "👨🏻‍🎨", "👨🏻‍🏫",
-      "👨🏻‍🏫", "👨🏻‍🏭", "👨🏻‍🏭", "👨🏻‍💻", "👨🏻‍💻", "👨🏻‍💼",
-      "👨🏻‍💼", "👨🏻‍🔧", "👨🏻‍🔧", "👨🏻‍🔬", "👨🏻‍🔬", "👨🏻‍🚀",
-      "👨🏻‍🚀", "👨🏻‍🚒", "👨🏻‍🚒", "👨🏻‍🦯", "👨🏻‍🦯", "👨🏻‍🦼",
-      "👨🏻‍🦼", "👨🏻‍🦽", "👨🏻‍🦽", "👨🏼‍⚕", "👨🏼‍⚕️", "👨🏼‍⚖",
-      "👨🏼‍⚖️", "👨🏼‍✈", "👨🏼‍✈️", "👨🏼‍🌾", "👨🏼‍🌾",
-      "👨🏼‍🍳", "👨🏼‍🍳", "👨🏼‍🍼", "👨🏼‍🍼", "👨🏼‍🎓", "👨🏼‍🎓",
-      "👨🏼‍🎤", "👨🏼‍🎤", "👨🏼‍🎨", "👨🏼‍🎨", "👨🏼‍🏫", "👨🏼‍🏫",
-      "👨🏼‍🏭", "👨🏼‍🏭", "👨🏼‍💻", "👨🏼‍💻", "👨🏼‍💼", "👨🏼‍💼",
-      "👨🏼‍🔧", "👨🏼‍🔧", "👨🏼‍🔬", "👨🏼‍🔬", "👨🏼‍🚀", "👨🏼‍🚀",
-      "👨🏼‍🚒", "👨🏼‍🚒", "👨🏼‍🦯", "👨🏼‍🦯", "👨🏼‍🦼", "👨🏼‍🦼",
-      "👨🏼‍🦽", "👨🏼‍🦽", "👨🏽‍⚕", "👨🏽‍⚕️", "👨🏽‍⚖",
-      "👨🏽‍⚖️", "👨🏽‍✈", "👨🏽‍✈️", "👨🏽‍🌾", "👨🏽‍🌾",
-      "👨🏽‍🍳", "👨🏽‍🍳", "👨🏽‍🍼", "👨🏽‍🍼", "👨🏽‍🎓", "👨🏽‍🎓",
-      "👨🏽‍🎤", "👨🏽‍🎤", "👨🏽‍🎨", "👨🏽‍🎨", "👨🏽‍🏫", "👨🏽‍🏫",
-      "👨🏽‍🏭", "👨🏽‍🏭", "👨🏽‍💻", "👨🏽‍💻", "👨🏽‍💼", "👨🏽‍💼",
-      "👨🏽‍🔧", "👨🏽‍🔧", "👨🏽‍🔬", "👨🏽‍🔬", "👨🏽‍🚀", "👨🏽‍🚀",
-      "👨🏽‍🚒", "👨🏽‍🚒", "👨🏽‍🦯", "👨🏽‍🦯", "👨🏽‍🦼", "👨🏽‍🦼",
-      "👨🏽‍🦽", "👨🏽‍🦽", "👨🏾‍⚕", "👨🏾‍⚕️", "👨🏾‍⚖",
-      "👨🏾‍⚖️", "👨🏾‍✈", "👨🏾‍✈️", "👨🏾‍🌾", "👨🏾‍🌾",
-      "👨🏾‍🍳", "👨🏾‍🍳", "👨🏾‍🍼", "👨🏾‍🍼", "👨🏾‍🎓", "👨🏾‍🎓",
-      "👨🏾‍🎤", "👨🏾‍🎤", "👨🏾‍🎨", "👨🏾‍🎨", "👨🏾‍🏫", "👨🏾‍🏫",
-      "👨🏾‍🏭", "👨🏾‍🏭", "👨🏾‍💻", "👨🏾‍💻", "👨🏾‍💼", "👨🏾‍💼",
-      "👨🏾‍🔧", "👨🏾‍🔧", "👨🏾‍🔬", "👨🏾‍🔬", "👨🏾‍🚀", "👨🏾‍🚀",
-      "👨🏾‍🚒", "👨🏾‍🚒", "👨🏾‍🦯", "👨🏾‍🦯", "👨🏾‍🦼", "👨🏾‍🦼",
-      "👨🏾‍🦽", "👨🏾‍🦽", "👨🏿‍⚕", "👨🏿‍⚕️", "👨🏿‍⚖",
-      "👨🏿‍⚖️", "👨🏿‍✈", "👨🏿‍✈️", "👨🏿‍🌾", "👨🏿‍🌾",
-      "👨🏿‍🍳", "👨🏿‍🍳", "👨🏿‍🍼", "👨🏿‍🍼", "👨🏿‍🎓", "👨🏿‍🎓",
-      "👨🏿‍🎤", "👨🏿‍🎤", "👨🏿‍🎨", "👨🏿‍🎨", "👨🏿‍🏫", "👨🏿‍🏫",
-      "👨🏿‍🏭", "👨🏿‍🏭", "👨🏿‍💻", "👨🏿‍💻", "👨🏿‍💼", "👨🏿‍💼",
-      "👨🏿‍🔧", "👨🏿‍🔧", "👨🏿‍🔬", "👨🏿‍🔬", "👨🏿‍🚀", "👨🏿‍🚀",
-      "👨🏿‍🚒", "👨🏿‍🚒", "👨🏿‍🦯", "👨🏿‍🦯", "👨🏿‍🦼", "👨🏿‍🦼",
-      "👨🏿‍🦽", "👨🏿‍🦽", "👩‍⚕", "👩‍⚕️", "👩‍⚖", "👩‍⚖️", "👩‍✈",
-      "👩‍✈️", "👩‍🌾", "👩‍🌾", "👩‍🍳", "👩‍🍳", "👩‍🍼", "👩‍🍼",
-      "👩‍🎓", "👩‍🎓", "👩‍🎤", "👩‍🎤", "👩‍🎨", "👩‍🎨", "👩‍🏫",
-      "👩‍🏫", "👩‍🏭", "👩‍🏭", "👩‍💻", "👩‍💻", "👩‍💼", "👩‍💼",
-      "👩‍🔧", "👩‍🔧", "👩‍🔬", "👩‍🔬", "👩‍🚀", "👩‍🚀", "👩‍🚒",
-      "👩‍🚒", "👩‍🦯", "👩‍🦯", "👩‍🦼", "👩‍🦼", "👩‍🦽", "👩‍🦽",
-      "👩🏻‍⚕", "👩🏻‍⚕️", "👩🏻‍⚖", "👩🏻‍⚖️", "👩🏻‍✈",
-      "👩🏻‍✈️", "👩🏻‍🌾", "👩🏻‍🌾", "👩🏻‍🍳", "👩🏻‍🍳",
-      "👩🏻‍🍼", "👩🏻‍🍼", "👩🏻‍🎓", "👩🏻‍🎓", "👩🏻‍🎤", "👩🏻‍🎤",
-      "👩🏻‍🎨", "👩🏻‍🎨", "👩🏻‍🏫", "👩🏻‍🏫", "👩🏻‍🏭", "👩🏻‍🏭",
-      "👩🏻‍💻", "👩🏻‍💻", "👩🏻‍💼", "👩🏻‍💼", "👩🏻‍🔧", "👩🏻‍🔧",
-      "👩🏻‍🔬", "👩🏻‍🔬", "👩🏻‍🚀", "👩🏻‍🚀", "👩🏻‍🚒", "👩🏻‍🚒",
-      "👩🏻‍🦯", "👩🏻‍🦯", "👩🏻‍🦼", "👩🏻‍🦼", "👩🏻‍🦽", "👩🏻‍🦽",
-      "👩🏼‍⚕", "👩🏼‍⚕️", "👩🏼‍⚖", "👩🏼‍⚖️", "👩🏼‍✈",
-      "👩🏼‍✈️", "👩🏼‍🌾", "👩🏼‍🌾", "👩🏼‍🍳", "👩🏼‍🍳",
-      "👩🏼‍🍼", "👩🏼‍🍼", "👩🏼‍🎓", "👩🏼‍🎓", "👩🏼‍🎤", "👩🏼‍🎤",
-      "👩🏼‍🎨", "👩🏼‍🎨", "👩🏼‍🏫", "👩🏼‍🏫", "👩🏼‍🏭", "👩🏼‍🏭",
-      "👩🏼‍💻", "👩🏼‍💻", "👩🏼‍💼", "👩🏼‍💼", "👩🏼‍🔧", "👩🏼‍🔧",
-      "👩🏼‍🔬", "👩🏼‍🔬", "👩🏼‍🚀", "👩🏼‍🚀", "👩🏼‍🚒", "👩🏼‍🚒",
-      "👩🏼‍🦯", "👩🏼‍🦯", "👩🏼‍🦼", "👩🏼‍🦼", "👩🏼‍🦽", "👩🏼‍🦽",
-      "👩🏽‍⚕", "👩🏽‍⚕️", "👩🏽‍⚖", "👩🏽‍⚖️", "👩🏽‍✈",
-      "👩🏽‍✈️", "👩🏽‍🌾", "👩🏽‍🌾", "👩🏽‍🍳", "👩🏽‍🍳",
-      "👩🏽‍🍼", "👩🏽‍🍼", "👩🏽‍🎓", "👩🏽‍🎓", "👩🏽‍🎤", "👩🏽‍🎤",
-      "👩🏽‍🎨", "👩🏽‍🎨", "👩🏽‍🏫", "👩🏽‍🏫", "👩🏽‍🏭", "👩🏽‍🏭",
-      "👩🏽‍💻", "👩🏽‍💻", "👩🏽‍💼", "👩🏽‍💼", "👩🏽‍🔧", "👩🏽‍🔧",
-      "👩🏽‍🔬", "👩🏽‍🔬", "👩🏽‍🚀", "👩🏽‍🚀", "👩🏽‍🚒", "👩🏽‍🚒",
-      "👩🏽‍🦯", "👩🏽‍🦯", "👩🏽‍🦼", "👩🏽‍🦼", "👩🏽‍🦽", "👩🏽‍🦽",
-      "👩🏾‍⚕", "👩🏾‍⚕️", "👩🏾‍⚖", "👩🏾‍⚖️", "👩🏾‍✈",
-      "👩🏾‍✈️", "👩🏾‍🌾", "👩🏾‍🌾", "👩🏾‍🍳", "👩🏾‍🍳",
-      "👩🏾‍🍼", "👩🏾‍🍼", "👩🏾‍🎓", "👩🏾‍🎓", "👩🏾‍🎤", "👩🏾‍🎤",
-      "👩🏾‍🎨", "👩🏾‍🎨", "👩🏾‍🏫", "👩🏾‍🏫", "👩🏾‍🏭", "👩🏾‍🏭",
-      "👩🏾‍💻", "👩🏾‍💻", "👩🏾‍💼", "👩🏾‍💼", "👩🏾‍🔧", "👩🏾‍🔧",
-      "👩🏾‍🔬", "👩🏾‍🔬", "👩🏾‍🚀", "👩🏾‍🚀", "👩🏾‍🚒", "👩🏾‍🚒",
-      "👩🏾‍🦯", "👩🏾‍🦯", "👩🏾‍🦼", "👩🏾‍🦼", "👩🏾‍🦽", "👩🏾‍🦽",
-      "👩🏿‍⚕", "👩🏿‍⚕️", "👩🏿‍⚖", "👩🏿‍⚖️", "👩🏿‍✈",
-      "👩🏿‍✈️", "👩🏿‍🌾", "👩🏿‍🌾", "👩🏿‍🍳", "👩🏿‍🍳",
-      "👩🏿‍🍼", "👩🏿‍🍼", "👩🏿‍🎓", "👩🏿‍🎓", "👩🏿‍🎤", "👩🏿‍🎤",
-      "👩🏿‍🎨", "👩🏿‍🎨", "👩🏿‍🏫", "👩🏿‍🏫", "👩🏿‍🏭", "👩🏿‍🏭",
-      "👩🏿‍💻", "👩🏿‍💻", "👩🏿‍💼", "👩🏿‍💼", "👩🏿‍🔧", "👩🏿‍🔧",
-      "👩🏿‍🔬", "👩🏿‍🔬", "👩🏿‍🚀", "👩🏿‍🚀", "👩🏿‍🚒", "👩🏿‍🚒",
-      "👩🏿‍🦯", "👩🏿‍🦯", "👩🏿‍🦼", "👩🏿‍🦼", "👩🏿‍🦽", "👩🏿‍🦽",
-      "🧑‍⚕", "🧑‍⚕️", "🧑‍⚖", "🧑‍⚖️", "🧑‍✈", "🧑‍✈️", "🧑‍🌾",
-      "🧑‍🌾", "🧑‍🍳", "🧑‍🍳", "🧑‍🍼", "🧑‍🍼", "🧑‍🎓", "🧑‍🎓",
-      "🧑‍🎤", "🧑‍🎤", "🧑‍🎨", "🧑‍🎨", "🧑‍🏫", "🧑‍🏫", "🧑‍🏭",
-      "🧑‍🏭", "🧑‍💻", "🧑‍💻", "🧑‍💼", "🧑‍💼", "🧑‍🔧", "🧑‍🔧",
-      "🧑‍🔬", "🧑‍🔬", "🧑‍🚀", "🧑‍🚀", "🧑‍🚒", "🧑‍🚒", "🧑‍🦯",
-      "🧑‍🦯", "🧑‍🦼", "🧑‍🦼", "🧑‍🦽", "🧑‍🦽", "🧑🏻‍⚕", "🧑🏻‍⚕️",
-      "🧑🏻‍⚖", "🧑🏻‍⚖️", "🧑🏻‍✈", "🧑🏻‍✈️", "🧑🏻‍🌾",
-      "🧑🏻‍🌾", "🧑🏻‍🍳", "🧑🏻‍🍳", "🧑🏻‍🍼", "🧑🏻‍🍼", "🧑🏻‍🎓",
-      "🧑🏻‍🎓", "🧑🏻‍🎤", "🧑🏻‍🎤", "🧑🏻‍🎨", "🧑🏻‍🎨", "🧑🏻‍🏫",
-      "🧑🏻‍🏫", "🧑🏻‍🏭", "🧑🏻‍🏭", "🧑🏻‍💻", "🧑🏻‍💻", "🧑🏻‍💼",
-      "🧑🏻‍💼", "🧑🏻‍🔧", "🧑🏻‍🔧", "🧑🏻‍🔬", "🧑🏻‍🔬", "🧑🏻‍🚀",
-      "🧑🏻‍🚀", "🧑🏻‍🚒", "🧑🏻‍🚒", "🧑🏻‍🦯", "🧑🏻‍🦯", "🧑🏻‍🦼",
-      "🧑🏻‍🦼", "🧑🏻‍🦽", "🧑🏻‍🦽", "🧑🏼‍⚕", "🧑🏼‍⚕️", "🧑🏼‍⚖",
-      "🧑🏼‍⚖️", "🧑🏼‍✈", "🧑🏼‍✈️", "🧑🏼‍🌾", "🧑🏼‍🌾",
-      "🧑🏼‍🍳", "🧑🏼‍🍳", "🧑🏼‍🍼", "🧑🏼‍🍼", "🧑🏼‍🎓", "🧑🏼‍🎓",
-      "🧑🏼‍🎤", "🧑🏼‍🎤", "🧑🏼‍🎨", "🧑🏼‍🎨", "🧑🏼‍🏫", "🧑🏼‍🏫",
-      "🧑🏼‍🏭", "🧑🏼‍🏭", "🧑🏼‍💻", "🧑🏼‍💻", "🧑🏼‍💼", "🧑🏼‍💼",
-      "🧑🏼‍🔧", "🧑🏼‍🔧", "🧑🏼‍🔬", "🧑🏼‍🔬", "🧑🏼‍🚀", "🧑🏼‍🚀",
-      "🧑🏼‍🚒", "🧑🏼‍🚒", "🧑🏼‍🦯", "🧑🏼‍🦯", "🧑🏼‍🦼", "🧑🏼‍🦼",
-      "🧑🏼‍🦽", "🧑🏼‍🦽", "🧑🏽‍⚕", "🧑🏽‍⚕️", "🧑🏽‍⚖",
-      "🧑🏽‍⚖️", "🧑🏽‍✈", "🧑🏽‍✈️", "🧑🏽‍🌾", "🧑🏽‍🌾",
-      "🧑🏽‍🍳", "🧑🏽‍🍳", "🧑🏽‍🍼", "🧑🏽‍🍼", "🧑🏽‍🎓", "🧑🏽‍🎓",
-      "🧑🏽‍🎤", "🧑🏽‍🎤", "🧑🏽‍🎨", "🧑🏽‍🎨", "🧑🏽‍🏫", "🧑🏽‍🏫",
-      "🧑🏽‍🏭", "🧑🏽‍🏭", "🧑🏽‍💻", "🧑🏽‍💻", "🧑🏽‍💼", "🧑🏽‍💼",
-      "🧑🏽‍🔧", "🧑🏽‍🔧", "🧑🏽‍🔬", "🧑🏽‍🔬", "🧑🏽‍🚀", "🧑🏽‍🚀",
-      "🧑🏽‍🚒", "🧑🏽‍🚒", "🧑🏽‍🦯", "🧑🏽‍🦯", "🧑🏽‍🦼", "🧑🏽‍🦼",
-      "🧑🏽‍🦽", "🧑🏽‍🦽", "🧑🏾‍⚕", "🧑🏾‍⚕️", "🧑🏾‍⚖",
-      "🧑🏾‍⚖️", "🧑🏾‍✈", "🧑🏾‍✈️", "🧑🏾‍🌾", "🧑🏾‍🌾",
-      "🧑🏾‍🍳", "🧑🏾‍🍳", "🧑🏾‍🍼", "🧑🏾‍🍼", "🧑🏾‍🎓", "🧑🏾‍🎓",
-      "🧑🏾‍🎤", "🧑🏾‍🎤", "🧑🏾‍🎨", "🧑🏾‍🎨", "🧑🏾‍🏫", "🧑🏾‍🏫",
-      "🧑🏾‍🏭", "🧑🏾‍🏭", "🧑🏾‍💻", "🧑🏾‍💻", "🧑🏾‍💼", "🧑🏾‍💼",
-      "🧑🏾‍🔧", "🧑🏾‍🔧", "🧑🏾‍🔬", "🧑🏾‍🔬", "🧑🏾‍🚀", "🧑🏾‍🚀",
-      "🧑🏾‍🚒", "🧑🏾‍🚒", "🧑🏾‍🦯", "🧑🏾‍🦯", "🧑🏾‍🦼", "🧑🏾‍🦼",
-      "🧑🏾‍🦽", "🧑🏾‍🦽", "🧑🏿‍⚕", "🧑🏿‍⚕️", "🧑🏿‍⚖",
-      "🧑🏿‍⚖️", "🧑🏿‍✈", "🧑🏿‍✈️", "🧑🏿‍🌾", "🧑🏿‍🌾",
-      "🧑🏿‍🍳", "🧑🏿‍🍳", "🧑🏿‍🍼", "🧑🏿‍🍼", "🧑🏿‍🎓", "🧑🏿‍🎓",
-      "🧑🏿‍🎤", "🧑🏿‍🎤", "🧑🏿‍🎨", "🧑🏿‍🎨", "🧑🏿‍🏫", "🧑🏿‍🏫",
-      "🧑🏿‍🏭", "🧑🏿‍🏭", "🧑🏿‍💻", "🧑🏿‍💻", "🧑🏿‍💼", "🧑🏿‍💼",
-      "🧑🏿‍🔧", "🧑🏿‍🔧", "🧑🏿‍🔬", "🧑🏿‍🔬", "🧑🏿‍🚀", "🧑🏿‍🚀",
-      "🧑🏿‍🚒", "🧑🏿‍🚒", "🧑🏿‍🦯", "🧑🏿‍🦯", "🧑🏿‍🦼", "🧑🏿‍🦼",
-      "🧑🏿‍🦽", "🧑🏿‍🦽", "⛹🏻‍♀", "⛹🏻‍♀️", "⛹🏻‍♂", "⛹🏻‍♂️",
-      "⛹🏼‍♀", "⛹🏼‍♀️", "⛹🏼‍♂", "⛹🏼‍♂️", "⛹🏽‍♀", "⛹🏽‍♀️",
-      "⛹🏽‍♂", "⛹🏽‍♂️", "⛹🏾‍♀", "⛹🏾‍♀️", "⛹🏾‍♂", "⛹🏾‍♂️",
-      "⛹🏿‍♀", "⛹🏿‍♀️", "⛹🏿‍♂", "⛹🏿‍♂️", "⛹‍♀", "⛹️‍♀️",
-      "⛹‍♂", "⛹️‍♂️", "🏃‍♀", "🏃‍♀️", "🏃‍♂", "🏃‍♂️", "🏃🏻‍♀",
-      "🏃🏻‍♀️", "🏃🏻‍♂", "🏃🏻‍♂️", "🏃🏼‍♀", "🏃🏼‍♀️",
-      "🏃🏼‍♂", "🏃🏼‍♂️", "🏃🏽‍♀", "🏃🏽‍♀️", "🏃🏽‍♂",
-      "🏃🏽‍♂️", "🏃🏾‍♀", "🏃🏾‍♀️", "🏃🏾‍♂", "🏃🏾‍♂️",
-      "🏃🏿‍♀", "🏃🏿‍♀️", "🏃🏿‍♂", "🏃🏿‍♂️", "🏄‍♀", "🏄‍♀️",
-      "🏄‍♂", "🏄‍♂️", "🏄🏻‍♀", "🏄🏻‍♀️", "🏄🏻‍♂", "🏄🏻‍♂️",
-      "🏄🏼‍♀", "🏄🏼‍♀️", "🏄🏼‍♂", "🏄🏼‍♂️", "🏄🏽‍♀",
-      "🏄🏽‍♀️", "🏄🏽‍♂", "🏄🏽‍♂️", "🏄🏾‍♀", "🏄🏾‍♀️",
-      "🏄🏾‍♂", "🏄🏾‍♂️", "🏄🏿‍♀", "🏄🏿‍♀️", "🏄🏿‍♂",
-      "🏄🏿‍♂️", "🏊‍♀", "🏊‍♀️", "🏊‍♂", "🏊‍♂️", "🏊🏻‍♀",
-      "🏊🏻‍♀️", "🏊🏻‍♂", "🏊🏻‍♂️", "🏊🏼‍♀", "🏊🏼‍♀️",
-      "🏊🏼‍♂", "🏊🏼‍♂️", "🏊🏽‍♀", "🏊🏽‍♀️", "🏊🏽‍♂",
-      "🏊🏽‍♂️", "🏊🏾‍♀", "🏊🏾‍♀️", "🏊🏾‍♂", "🏊🏾‍♂️",
-      "🏊🏿‍♀", "🏊🏿‍♀️", "🏊🏿‍♂", "🏊🏿‍♂️", "🏋🏻‍♀",
-      "🏋🏻‍♀️", "🏋🏻‍♂", "🏋🏻‍♂️", "🏋🏼‍♀", "🏋🏼‍♀️",
-      "🏋🏼‍♂", "🏋🏼‍♂️", "🏋🏽‍♀", "🏋🏽‍♀️", "🏋🏽‍♂",
-      "🏋🏽‍♂️", "🏋🏾‍♀", "🏋🏾‍♀️", "🏋🏾‍♂", "🏋🏾‍♂️",
-      "🏋🏿‍♀", "🏋🏿‍♀️", "🏋🏿‍♂", "🏋🏿‍♂️", "🏋‍♀", "🏋️‍♀️",
-      "🏋‍♂", "🏋️‍♂️", "🏌🏻‍♀", "🏌🏻‍♀️", "🏌🏻‍♂", "🏌🏻‍♂️",
-      "🏌🏼‍♀", "🏌🏼‍♀️", "🏌🏼‍♂", "🏌🏼‍♂️", "🏌🏽‍♀",
-      "🏌🏽‍♀️", "🏌🏽‍♂", "🏌🏽‍♂️", "🏌🏾‍♀", "🏌🏾‍♀️",
-      "🏌🏾‍♂", "🏌🏾‍♂️", "🏌🏿‍♀", "🏌🏿‍♀️", "🏌🏿‍♂",
-      "🏌🏿‍♂️", "🏌‍♀", "🏌️‍♀️", "🏌‍♂", "🏌️‍♂️", "👮‍♀",
-      "👮‍♀️", "👮‍♂", "👮‍♂️", "👮🏻‍♀", "👮🏻‍♀️", "👮🏻‍♂",
-      "👮🏻‍♂️", "👮🏼‍♀", "👮🏼‍♀️", "👮🏼‍♂", "👮🏼‍♂️",
-      "👮🏽‍♀", "👮🏽‍♀️", "👮🏽‍♂", "👮🏽‍♂️", "👮🏾‍♀",
-      "👮🏾‍♀️", "👮🏾‍♂", "👮🏾‍♂️", "👮🏿‍♀", "👮🏿‍♀️",
-      "👮🏿‍♂", "👮🏿‍♂️", "👯‍♀", "👯‍♀️", "👯‍♂", "👯‍♂️", "👰‍♀",
-      "👰‍♀️", "👰‍♂", "👰‍♂️", "👰🏻‍♀", "👰🏻‍♀️", "👰🏻‍♂",
-      "👰🏻‍♂️", "👰🏼‍♀", "👰🏼‍♀️", "👰🏼‍♂", "👰🏼‍♂️",
-      "👰🏽‍♀", "👰🏽‍♀️", "👰🏽‍♂", "👰🏽‍♂️", "👰🏾‍♀",
-      "👰🏾‍♀️", "👰🏾‍♂", "👰🏾‍♂️", "👰🏿‍♀", "👰🏿‍♀️",
-      "👰🏿‍♂", "👰🏿‍♂️", "👱‍♀", "👱‍♀️", "👱‍♂", "👱‍♂️",
-      "👱🏻‍♀", "👱🏻‍♀️", "👱🏻‍♂", "👱🏻‍♂️", "👱🏼‍♀",
-      "👱🏼‍♀️", "👱🏼‍♂", "👱🏼‍♂️", "👱🏽‍♀", "👱🏽‍♀️",
-      "👱🏽‍♂", "👱🏽‍♂️", "👱🏾‍♀", "👱🏾‍♀️", "👱🏾‍♂",
-      "👱🏾‍♂️", "👱🏿‍♀", "👱🏿‍♀️", "👱🏿‍♂", "👱🏿‍♂️", "👳‍♀",
-      "👳‍♀️", "👳‍♂", "👳‍♂️", "👳🏻‍♀", "👳🏻‍♀️", "👳🏻‍♂",
-      "👳🏻‍♂️", "👳🏼‍♀", "👳🏼‍♀️", "👳🏼‍♂", "👳🏼‍♂️",
-      "👳🏽‍♀", "👳🏽‍♀️", "👳🏽‍♂", "👳🏽‍♂️", "👳🏾‍♀",
-      "👳🏾‍♀️", "👳🏾‍♂", "👳🏾‍♂️", "👳🏿‍♀", "👳🏿‍♀️",
-      "👳🏿‍♂", "👳🏿‍♂️", "👷‍♀", "👷‍♀️", "👷‍♂", "👷‍♂️",
-      "👷🏻‍♀", "👷🏻‍♀️", "👷🏻‍♂", "👷🏻‍♂️", "👷🏼‍♀",
-      "👷🏼‍♀️", "👷🏼‍♂", "👷🏼‍♂️", "👷🏽‍♀", "👷🏽‍♀️",
-      "👷🏽‍♂", "👷🏽‍♂️", "👷🏾‍♀", "👷🏾‍♀️", "👷🏾‍♂",
-      "👷🏾‍♂️", "👷🏿‍♀", "👷🏿‍♀️", "👷🏿‍♂", "👷🏿‍♂️", "💁‍♀",
-      "💁‍♀️", "💁‍♂", "💁‍♂️", "💁🏻‍♀", "💁🏻‍♀️", "💁🏻‍♂",
-      "💁🏻‍♂️", "💁🏼‍♀", "💁🏼‍♀️", "💁🏼‍♂", "💁🏼‍♂️",
-      "💁🏽‍♀", "💁🏽‍♀️", "💁🏽‍♂", "💁🏽‍♂️", "💁🏾‍♀",
-      "💁🏾‍♀️", "💁🏾‍♂", "💁🏾‍♂️", "💁🏿‍♀", "💁🏿‍♀️",
-      "💁🏿‍♂", "💁🏿‍♂️", "💂‍♀", "💂‍♀️", "💂‍♂", "💂‍♂️",
-      "💂🏻‍♀", "💂🏻‍♀️", "💂🏻‍♂", "💂🏻‍♂️", "💂🏼‍♀",
-      "💂🏼‍♀️", "💂🏼‍♂", "💂🏼‍♂️", "💂🏽‍♀", "💂🏽‍♀️",
-      "💂🏽‍♂", "💂🏽‍♂️", "💂🏾‍♀", "💂🏾‍♀️", "💂🏾‍♂",
-      "💂🏾‍♂️", "💂🏿‍♀", "💂🏿‍♀️", "💂🏿‍♂", "💂🏿‍♂️", "💆‍♀",
-      "💆‍♀️", "💆‍♂", "💆‍♂️", "💆🏻‍♀", "💆🏻‍♀️", "💆🏻‍♂",
-      "💆🏻‍♂️", "💆🏼‍♀", "💆🏼‍♀️", "💆🏼‍♂", "💆🏼‍♂️",
-      "💆🏽‍♀", "💆🏽‍♀️", "💆🏽‍♂", "💆🏽‍♂️", "💆🏾‍♀",
-      "💆🏾‍♀️", "💆🏾‍♂", "💆🏾‍♂️", "💆🏿‍♀", "💆🏿‍♀️",
-      "💆🏿‍♂", "💆🏿‍♂️", "💇‍♀", "💇‍♀️", "💇‍♂", "💇‍♂️",
-      "💇🏻‍♀", "💇🏻‍♀️", "💇🏻‍♂", "💇🏻‍♂️", "💇🏼‍♀",
-      "💇🏼‍♀️", "💇🏼‍♂", "💇🏼‍♂️", "💇🏽‍♀", "💇🏽‍♀️",
-      "💇🏽‍♂", "💇🏽‍♂️", "💇🏾‍♀", "💇🏾‍♀️", "💇🏾‍♂",
-      "💇🏾‍♂️", "💇🏿‍♀", "💇🏿‍♀️", "💇🏿‍♂", "💇🏿‍♂️",
-      "🕵🏻‍♀", "🕵🏻‍♀️", "🕵🏻‍♂", "🕵🏻‍♂️", "🕵🏼‍♀",
-      "🕵🏼‍♀️", "🕵🏼‍♂", "🕵🏼‍♂️", "🕵🏽‍♀", "🕵🏽‍♀️",
-      "🕵🏽‍♂", "🕵🏽‍♂️", "🕵🏾‍♀", "🕵🏾‍♀️", "🕵🏾‍♂",
-      "🕵🏾‍♂️", "🕵🏿‍♀", "🕵🏿‍♀️", "🕵🏿‍♂", "🕵🏿‍♂️", "🕵‍♀",
-      "🕵️‍♀️", "🕵‍♂", "🕵️‍♂️", "🙅‍♀", "🙅‍♀️", "🙅‍♂",
-      "🙅‍♂️", "🙅🏻‍♀", "🙅🏻‍♀️", "🙅🏻‍♂", "🙅🏻‍♂️", "🙅🏼‍♀",
-      "🙅🏼‍♀️", "🙅🏼‍♂", "🙅🏼‍♂️", "🙅🏽‍♀", "🙅🏽‍♀️",
-      "🙅🏽‍♂", "🙅🏽‍♂️", "🙅🏾‍♀", "🙅🏾‍♀️", "🙅🏾‍♂",
-      "🙅🏾‍♂️", "🙅🏿‍♀", "🙅🏿‍♀️", "🙅🏿‍♂", "🙅🏿‍♂️", "🙆‍♀",
-      "🙆‍♀️", "🙆‍♂", "🙆‍♂️", "🙆🏻‍♀", "🙆🏻‍♀️", "🙆🏻‍♂",
-      "🙆🏻‍♂️", "🙆🏼‍♀", "🙆🏼‍♀️", "🙆🏼‍♂", "🙆🏼‍♂️",
-      "🙆🏽‍♀", "🙆🏽‍♀️", "🙆🏽‍♂", "🙆🏽‍♂️", "🙆🏾‍♀",
-      "🙆🏾‍♀️", "🙆🏾‍♂", "🙆🏾‍♂️", "🙆🏿‍♀", "🙆🏿‍♀️",
-      "🙆🏿‍♂", "🙆🏿‍♂️", "🙇‍♀", "🙇‍♀️", "🙇‍♂", "🙇‍♂️",
-      "🙇🏻‍♀", "🙇🏻‍♀️", "🙇🏻‍♂", "🙇🏻‍♂️", "🙇🏼‍♀",
-      "🙇🏼‍♀️", "🙇🏼‍♂", "🙇🏼‍♂️", "🙇🏽‍♀", "🙇🏽‍♀️",
-      "🙇🏽‍♂", "🙇🏽‍♂️", "🙇🏾‍♀", "🙇🏾‍♀️", "🙇🏾‍♂",
-      "🙇🏾‍♂️", "🙇🏿‍♀", "🙇🏿‍♀️", "🙇🏿‍♂", "🙇🏿‍♂️", "🙋‍♀",
-      "🙋‍♀️", "🙋‍♂", "🙋‍♂️", "🙋🏻‍♀", "🙋🏻‍♀️", "🙋🏻‍♂",
-      "🙋🏻‍♂️", "🙋🏼‍♀", "🙋🏼‍♀️", "🙋🏼‍♂", "🙋🏼‍♂️",
-      "🙋🏽‍♀", "🙋🏽‍♀️", "🙋🏽‍♂", "🙋🏽‍♂️", "🙋🏾‍♀",
-      "🙋🏾‍♀️", "🙋🏾‍♂", "🙋🏾‍♂️", "🙋🏿‍♀", "🙋🏿‍♀️",
-      "🙋🏿‍♂", "🙋🏿‍♂️", "🙍‍♀", "🙍‍♀️", "🙍‍♂", "🙍‍♂️",
-      "🙍🏻‍♀", "🙍🏻‍♀️", "🙍🏻‍♂", "🙍🏻‍♂️", "🙍🏼‍♀",
-      "🙍🏼‍♀️", "🙍🏼‍♂", "🙍🏼‍♂️", "🙍🏽‍♀", "🙍🏽‍♀️",
-      "🙍🏽‍♂", "🙍🏽‍♂️", "🙍🏾‍♀", "🙍🏾‍♀️", "🙍🏾‍♂",
-      "🙍🏾‍♂️", "🙍🏿‍♀", "🙍🏿‍♀️", "🙍🏿‍♂", "🙍🏿‍♂️", "🙎‍♀",
-      "🙎‍♀️", "🙎‍♂", "🙎‍♂️", "🙎🏻‍♀", "🙎🏻‍♀️", "🙎🏻‍♂",
-      "🙎🏻‍♂️", "🙎🏼‍♀", "🙎🏼‍♀️", "🙎🏼‍♂", "🙎🏼‍♂️",
-      "🙎🏽‍♀", "🙎🏽‍♀️", "🙎🏽‍♂", "🙎🏽‍♂️", "🙎🏾‍♀",
-      "🙎🏾‍♀️", "🙎🏾‍♂", "🙎🏾‍♂️", "🙎🏿‍♀", "🙎🏿‍♀️",
-      "🙎🏿‍♂", "🙎🏿‍♂️", "🚣‍♀", "🚣‍♀️", "🚣‍♂", "🚣‍♂️",
-      "🚣🏻‍♀", "🚣🏻‍♀️", "🚣🏻‍♂", "🚣🏻‍♂️", "🚣🏼‍♀",
-      "🚣🏼‍♀️", "🚣🏼‍♂", "🚣🏼‍♂️", "🚣🏽‍♀", "🚣🏽‍♀️",
-      "🚣🏽‍♂", "🚣🏽‍♂️", "🚣🏾‍♀", "🚣🏾‍♀️", "🚣🏾‍♂",
-      "🚣🏾‍♂️", "🚣🏿‍♀", "🚣🏿‍♀️", "🚣🏿‍♂", "🚣🏿‍♂️", "🚴‍♀",
-      "🚴‍♀️", "🚴‍♂", "🚴‍♂️", "🚴🏻‍♀", "🚴🏻‍♀️", "🚴🏻‍♂",
-      "🚴🏻‍♂️", "🚴🏼‍♀", "🚴🏼‍♀️", "🚴🏼‍♂", "🚴🏼‍♂️",
-      "🚴🏽‍♀", "🚴🏽‍♀️", "🚴🏽‍♂", "🚴🏽‍♂️", "🚴🏾‍♀",
-      "🚴🏾‍♀️", "🚴🏾‍♂", "🚴🏾‍♂️", "🚴🏿‍♀", "🚴🏿‍♀️",
-      "🚴🏿‍♂", "🚴🏿‍♂️", "🚵‍♀", "🚵‍♀️", "🚵‍♂", "🚵‍♂️",
-      "🚵🏻‍♀", "🚵🏻‍♀️", "🚵🏻‍♂", "🚵🏻‍♂️", "🚵🏼‍♀",
-      "🚵🏼‍♀️", "🚵🏼‍♂", "🚵🏼‍♂️", "🚵🏽‍♀", "🚵🏽‍♀️",
-      "🚵🏽‍♂", "🚵🏽‍♂️", "🚵🏾‍♀", "🚵🏾‍♀️", "🚵🏾‍♂",
-      "🚵🏾‍♂️", "🚵🏿‍♀", "🚵🏿‍♀️", "🚵🏿‍♂", "🚵🏿‍♂️", "🚶‍♀",
-      "🚶‍♀️", "🚶‍♂", "🚶‍♂️", "🚶🏻‍♀", "🚶🏻‍♀️", "🚶🏻‍♂",
-      "🚶🏻‍♂️", "🚶🏼‍♀", "🚶🏼‍♀️", "🚶🏼‍♂", "🚶🏼‍♂️",
-      "🚶🏽‍♀", "🚶🏽‍♀️", "🚶🏽‍♂", "🚶🏽‍♂️", "🚶🏾‍♀",
-      "🚶🏾‍♀️", "🚶🏾‍♂", "🚶🏾‍♂️", "🚶🏿‍♀", "🚶🏿‍♀️",
-      "🚶🏿‍♂", "🚶🏿‍♂️", "🤦‍♀", "🤦‍♀️", "🤦‍♂", "🤦‍♂️",
-      "🤦🏻‍♀", "🤦🏻‍♀️", "🤦🏻‍♂", "🤦🏻‍♂️", "🤦🏼‍♀",
-      "🤦🏼‍♀️", "🤦🏼‍♂", "🤦🏼‍♂️", "🤦🏽‍♀", "🤦🏽‍♀️",
-      "🤦🏽‍♂", "🤦🏽‍♂️", "🤦🏾‍♀", "🤦🏾‍♀️", "🤦🏾‍♂",
-      "🤦🏾‍♂️", "🤦🏿‍♀", "🤦🏿‍♀️", "🤦🏿‍♂", "🤦🏿‍♂️", "🤵‍♀",
-      "🤵‍♀️", "🤵‍♂", "🤵‍♂️", "🤵🏻‍♀", "🤵🏻‍♀️", "🤵🏻‍♂",
-      "🤵🏻‍♂️", "🤵🏼‍♀", "🤵🏼‍♀️", "🤵🏼‍♂", "🤵🏼‍♂️",
-      "🤵🏽‍♀", "🤵🏽‍♀️", "🤵🏽‍♂", "🤵🏽‍♂️", "🤵🏾‍♀",
-      "🤵🏾‍♀️", "🤵🏾‍♂", "🤵🏾‍♂️", "🤵🏿‍♀", "🤵🏿‍♀️",
-      "🤵🏿‍♂", "🤵🏿‍♂️", "🤷‍♀", "🤷‍♀️", "🤷‍♂", "🤷‍♂️",
-      "🤷🏻‍♀", "🤷🏻‍♀️", "🤷🏻‍♂", "🤷🏻‍♂️", "🤷🏼‍♀",
-      "🤷🏼‍♀️", "🤷🏼‍♂", "🤷🏼‍♂️", "🤷🏽‍♀", "🤷🏽‍♀️",
-      "🤷🏽‍♂", "🤷🏽‍♂️", "🤷🏾‍♀", "🤷🏾‍♀️", "🤷🏾‍♂",
-      "🤷🏾‍♂️", "🤷🏿‍♀", "🤷🏿‍♀️", "🤷🏿‍♂", "🤷🏿‍♂️", "🤸‍♀",
-      "🤸‍♀️", "🤸‍♂", "🤸‍♂️", "🤸🏻‍♀", "🤸🏻‍♀️", "🤸🏻‍♂",
-      "🤸🏻‍♂️", "🤸🏼‍♀", "🤸🏼‍♀️", "🤸🏼‍♂", "🤸🏼‍♂️",
-      "🤸🏽‍♀", "🤸🏽‍♀️", "🤸🏽‍♂", "🤸🏽‍♂️", "🤸🏾‍♀",
-      "🤸🏾‍♀️", "🤸🏾‍♂", "🤸🏾‍♂️", "🤸🏿‍♀", "🤸🏿‍♀️",
-      "🤸🏿‍♂", "🤸🏿‍♂️", "🤹‍♀", "🤹‍♀️", "🤹‍♂", "🤹‍♂️",
-      "🤹🏻‍♀", "🤹🏻‍♀️", "🤹🏻‍♂", "🤹🏻‍♂️", "🤹🏼‍♀",
-      "🤹🏼‍♀️", "🤹🏼‍♂", "🤹🏼‍♂️", "🤹🏽‍♀", "🤹🏽‍♀️",
-      "🤹🏽‍♂", "🤹🏽‍♂️", "🤹🏾‍♀", "🤹🏾‍♀️", "🤹🏾‍♂",
-      "🤹🏾‍♂️", "🤹🏿‍♀", "🤹🏿‍♀️", "🤹🏿‍♂", "🤹🏿‍♂️", "🤼‍♀",
-      "🤼‍♀️", "🤼‍♂", "🤼‍♂️", "🤽‍♀", "🤽‍♀️", "🤽‍♂", "🤽‍♂️",
-      "🤽🏻‍♀", "🤽🏻‍♀️", "🤽🏻‍♂", "🤽🏻‍♂️", "🤽🏼‍♀",
-      "🤽🏼‍♀️", "🤽🏼‍♂", "🤽🏼‍♂️", "🤽🏽‍♀", "🤽🏽‍♀️",
-      "🤽🏽‍♂", "🤽🏽‍♂️", "🤽🏾‍♀", "🤽🏾‍♀️", "🤽🏾‍♂",
-      "🤽🏾‍♂️", "🤽🏿‍♀", "🤽🏿‍♀️", "🤽🏿‍♂", "🤽🏿‍♂️", "🤾‍♀",
-      "🤾‍♀️", "🤾‍♂", "🤾‍♂️", "🤾🏻‍♀", "🤾🏻‍♀️", "🤾🏻‍♂",
-      "🤾🏻‍♂️", "🤾🏼‍♀", "🤾🏼‍♀️", "🤾🏼‍♂", "🤾🏼‍♂️",
-      "🤾🏽‍♀", "🤾🏽‍♀️", "🤾🏽‍♂", "🤾🏽‍♂️", "🤾🏾‍♀",
-      "🤾🏾‍♀️", "🤾🏾‍♂", "🤾🏾‍♂️", "🤾🏿‍♀", "🤾🏿‍♀️",
-      "🤾🏿‍♂", "🤾🏿‍♂️", "🦸‍♀", "🦸‍♀️", "🦸‍♂", "🦸‍♂️",
-      "🦸🏻‍♀", "🦸🏻‍♀️", "🦸🏻‍♂", "🦸🏻‍♂️", "🦸🏼‍♀",
-      "🦸🏼‍♀️", "🦸🏼‍♂", "🦸🏼‍♂️", "🦸🏽‍♀", "🦸🏽‍♀️",
-      "🦸🏽‍♂", "🦸🏽‍♂️", "🦸🏾‍♀", "🦸🏾‍♀️", "🦸🏾‍♂",
-      "🦸🏾‍♂️", "🦸🏿‍♀", "🦸🏿‍♀️", "🦸🏿‍♂", "🦸🏿‍♂️", "🦹‍♀",
-      "🦹‍♀️", "🦹‍♂", "🦹‍♂️", "🦹🏻‍♀", "🦹🏻‍♀️", "🦹🏻‍♂",
-      "🦹🏻‍♂️", "🦹🏼‍♀", "🦹🏼‍♀️", "🦹🏼‍♂", "🦹🏼‍♂️",
-      "🦹🏽‍♀", "🦹🏽‍♀️", "🦹🏽‍♂", "🦹🏽‍♂️", "🦹🏾‍♀",
-      "🦹🏾‍♀️", "🦹🏾‍♂", "🦹🏾‍♂️", "🦹🏿‍♀", "🦹🏿‍♀️",
-      "🦹🏿‍♂", "🦹🏿‍♂️", "🧍‍♀", "🧍‍♀️", "🧍‍♂", "🧍‍♂️",
-      "🧍🏻‍♀", "🧍🏻‍♀️", "🧍🏻‍♂", "🧍🏻‍♂️", "🧍🏼‍♀",
-      "🧍🏼‍♀️", "🧍🏼‍♂", "🧍🏼‍♂️", "🧍🏽‍♀", "🧍🏽‍♀️",
-      "🧍🏽‍♂", "🧍🏽‍♂️", "🧍🏾‍♀", "🧍🏾‍♀️", "🧍🏾‍♂",
-      "🧍🏾‍♂️", "🧍🏿‍♀", "🧍🏿‍♀️", "🧍🏿‍♂", "🧍🏿‍♂️", "🧎‍♀",
-      "🧎‍♀️", "🧎‍♂", "🧎‍♂️", "🧎🏻‍♀", "🧎🏻‍♀️", "🧎🏻‍♂",
-      "🧎🏻‍♂️", "🧎🏼‍♀", "🧎🏼‍♀️", "🧎🏼‍♂", "🧎🏼‍♂️",
-      "🧎🏽‍♀", "🧎🏽‍♀️", "🧎🏽‍♂", "🧎🏽‍♂️", "🧎🏾‍♀",
-      "🧎🏾‍♀️", "🧎🏾‍♂", "🧎🏾‍♂️", "🧎🏿‍♀", "🧎🏿‍♀️",
-      "🧎🏿‍♂", "🧎🏿‍♂️", "🧏‍♀", "🧏‍♀️", "🧏‍♂", "🧏‍♂️",
-      "🧏🏻‍♀", "🧏🏻‍♀️", "🧏🏻‍♂", "🧏🏻‍♂️", "🧏🏼‍♀",
-      "🧏🏼‍♀️", "🧏🏼‍♂", "🧏🏼‍♂️", "🧏🏽‍♀", "🧏🏽‍♀️",
-      "🧏🏽‍♂", "🧏🏽‍♂️", "🧏🏾‍♀", "🧏🏾‍♀️", "🧏🏾‍♂",
-      "🧏🏾‍♂️", "🧏🏿‍♀", "🧏🏿‍♀️", "🧏🏿‍♂", "🧏🏿‍♂️", "🧔‍♀",
-      "🧔‍♀️", "🧔‍♂", "🧔‍♂️", "🧔🏻‍♀", "🧔🏻‍♀️", "🧔🏻‍♂",
-      "🧔🏻‍♂️", "🧔🏼‍♀", "🧔🏼‍♀️", "🧔🏼‍♂", "🧔🏼‍♂️",
-      "🧔🏽‍♀", "🧔🏽‍♀️", "🧔🏽‍♂", "🧔🏽‍♂️", "🧔🏾‍♀",
-      "🧔🏾‍♀️", "🧔🏾‍♂", "🧔🏾‍♂️", "🧔🏿‍♀", "🧔🏿‍♀️",
-      "🧔🏿‍♂", "🧔🏿‍♂️", "🧖‍♀", "🧖‍♀️", "🧖‍♂", "🧖‍♂️",
-      "🧖🏻‍♀", "🧖🏻‍♀️", "🧖🏻‍♂", "🧖🏻‍♂️", "🧖🏼‍♀",
-      "🧖🏼‍♀️", "🧖🏼‍♂", "🧖🏼‍♂️", "🧖🏽‍♀", "🧖🏽‍♀️",
-      "🧖🏽‍♂", "🧖🏽‍♂️", "🧖🏾‍♀", "🧖🏾‍♀️", "🧖🏾‍♂",
-      "🧖🏾‍♂️", "🧖🏿‍♀", "🧖🏿‍♀️", "🧖🏿‍♂", "🧖🏿‍♂️", "🧗‍♀",
-      "🧗‍♀️", "🧗‍♂", "🧗‍♂️", "🧗🏻‍♀", "🧗🏻‍♀️", "🧗🏻‍♂",
-      "🧗🏻‍♂️", "🧗🏼‍♀", "🧗🏼‍♀️", "🧗🏼‍♂", "🧗🏼‍♂️",
-      "🧗🏽‍♀", "🧗🏽‍♀️", "🧗🏽‍♂", "🧗🏽‍♂️", "🧗🏾‍♀",
-      "🧗🏾‍♀️", "🧗🏾‍♂", "🧗🏾‍♂️", "🧗🏿‍♀", "🧗🏿‍♀️",
-      "🧗🏿‍♂", "🧗🏿‍♂️", "🧘‍♀", "🧘‍♀️", "🧘‍♂", "🧘‍♂️",
-      "🧘🏻‍♀", "🧘🏻‍♀️", "🧘🏻‍♂", "🧘🏻‍♂️", "🧘🏼‍♀",
-      "🧘🏼‍♀️", "🧘🏼‍♂", "🧘🏼‍♂️", "🧘🏽‍♀", "🧘🏽‍♀️",
-      "🧘🏽‍♂", "🧘🏽‍♂️", "🧘🏾‍♀", "🧘🏾‍♀️", "🧘🏾‍♂",
-      "🧘🏾‍♂️", "🧘🏿‍♀", "🧘🏿‍♀️", "🧘🏿‍♂", "🧘🏿‍♂️", "🧙‍♀",
-      "🧙‍♀️", "🧙‍♂", "🧙‍♂️", "🧙🏻‍♀", "🧙🏻‍♀️", "🧙🏻‍♂",
-      "🧙🏻‍♂️", "🧙🏼‍♀", "🧙🏼‍♀️", "🧙🏼‍♂", "🧙🏼‍♂️",
-      "🧙🏽‍♀", "🧙🏽‍♀️", "🧙🏽‍♂", "🧙🏽‍♂️", "🧙🏾‍♀",
-      "🧙🏾‍♀️", "🧙🏾‍♂", "🧙🏾‍♂️", "🧙🏿‍♀", "🧙🏿‍♀️",
-      "🧙🏿‍♂", "🧙🏿‍♂️", "🧚‍♀", "🧚‍♀️", "🧚‍♂", "🧚‍♂️",
-      "🧚🏻‍♀", "🧚🏻‍♀️", "🧚🏻‍♂", "🧚🏻‍♂️", "🧚🏼‍♀",
-      "🧚🏼‍♀️", "🧚🏼‍♂", "🧚🏼‍♂️", "🧚🏽‍♀", "🧚🏽‍♀️",
-      "🧚🏽‍♂", "🧚🏽‍♂️", "🧚🏾‍♀", "🧚🏾‍♀️", "🧚🏾‍♂",
-      "🧚🏾‍♂️", "🧚🏿‍♀", "🧚🏿‍♀️", "🧚🏿‍♂", "🧚🏿‍♂️", "🧛‍♀",
-      "🧛‍♀️", "🧛‍♂", "🧛‍♂️", "🧛🏻‍♀", "🧛🏻‍♀️", "🧛🏻‍♂",
-      "🧛🏻‍♂️", "🧛🏼‍♀", "🧛🏼‍♀️", "🧛🏼‍♂", "🧛🏼‍♂️",
-      "🧛🏽‍♀", "🧛🏽‍♀️", "🧛🏽‍♂", "🧛🏽‍♂️", "🧛🏾‍♀",
-      "🧛🏾‍♀️", "🧛🏾‍♂", "🧛🏾‍♂️", "🧛🏿‍♀", "🧛🏿‍♀️",
-      "🧛🏿‍♂", "🧛🏿‍♂️", "🧜‍♀", "🧜‍♀️", "🧜‍♂", "🧜‍♂️",
-      "🧜🏻‍♀", "🧜🏻‍♀️", "🧜🏻‍♂", "🧜🏻‍♂️", "🧜🏼‍♀",
-      "🧜🏼‍♀️", "🧜🏼‍♂", "🧜🏼‍♂️", "🧜🏽‍♀", "🧜🏽‍♀️",
-      "🧜🏽‍♂", "🧜🏽‍♂️", "🧜🏾‍♀", "🧜🏾‍♀️", "🧜🏾‍♂",
-      "🧜🏾‍♂️", "🧜🏿‍♀", "🧜🏿‍♀️", "🧜🏿‍♂", "🧜🏿‍♂️", "🧝‍♀",
-      "🧝‍♀️", "🧝‍♂", "🧝‍♂️", "🧝🏻‍♀", "🧝🏻‍♀️", "🧝🏻‍♂",
-      "🧝🏻‍♂️", "🧝🏼‍♀", "🧝🏼‍♀️", "🧝🏼‍♂", "🧝🏼‍♂️",
-      "🧝🏽‍♀", "🧝🏽‍♀️", "🧝🏽‍♂", "🧝🏽‍♂️", "🧝🏾‍♀",
-      "🧝🏾‍♀️", "🧝🏾‍♂", "🧝🏾‍♂️", "🧝🏿‍♀", "🧝🏿‍♀️",
-      "🧝🏿‍♂", "🧝🏿‍♂️", "🧞‍♀", "🧞‍♀️", "🧞‍♂", "🧞‍♂️", "🧟‍♀",
-      "🧟‍♀️", "🧟‍♂", "🧟‍♂️", "👨‍🦰", "👨‍🦰", "👨‍🦱", "👨‍🦱",
-      "👨‍🦲", "👨‍🦲", "👨‍🦳", "👨‍🦳", "👨🏻‍🦰", "👨🏻‍🦰",
-      "👨🏻‍🦱", "👨🏻‍🦱", "👨🏻‍🦲", "👨🏻‍🦲", "👨🏻‍🦳", "👨🏻‍🦳",
-      "👨🏼‍🦰", "👨🏼‍🦰", "👨🏼‍🦱", "👨🏼‍🦱", "👨🏼‍🦲", "👨🏼‍🦲",
-      "👨🏼‍🦳", "👨🏼‍🦳", "👨🏽‍🦰", "👨🏽‍🦰", "👨🏽‍🦱", "👨🏽‍🦱",
-      "👨🏽‍🦲", "👨🏽‍🦲", "👨🏽‍🦳", "👨🏽‍🦳", "👨🏾‍🦰", "👨🏾‍🦰",
-      "👨🏾‍🦱", "👨🏾‍🦱", "👨🏾‍🦲", "👨🏾‍🦲", "👨🏾‍🦳", "👨🏾‍🦳",
-      "👨🏿‍🦰", "👨🏿‍🦰", "👨🏿‍🦱", "👨🏿‍🦱", "👨🏿‍🦲", "👨🏿‍🦲",
-      "👨🏿‍🦳", "👨🏿‍🦳", "👩‍🦰", "👩‍🦰", "👩‍🦱", "👩‍🦱", "👩‍🦲",
-      "👩‍🦲", "👩‍🦳", "👩‍🦳", "👩🏻‍🦰", "👩🏻‍🦰", "👩🏻‍🦱",
-      "👩🏻‍🦱", "👩🏻‍🦲", "👩🏻‍🦲", "👩🏻‍🦳", "👩🏻‍🦳", "👩🏼‍🦰",
-      "👩🏼‍🦰", "👩🏼‍🦱", "👩🏼‍🦱", "👩🏼‍🦲", "👩🏼‍🦲", "👩🏼‍🦳",
-      "👩🏼‍🦳", "👩🏽‍🦰", "👩🏽‍🦰", "👩🏽‍🦱", "👩🏽‍🦱", "👩🏽‍🦲",
-      "👩🏽‍🦲", "👩🏽‍🦳", "👩🏽‍🦳", "👩🏾‍🦰", "👩🏾‍🦰", "👩🏾‍🦱",
-      "👩🏾‍🦱", "👩🏾‍🦲", "👩🏾‍🦲", "👩🏾‍🦳", "👩🏾‍🦳", "👩🏿‍🦰",
-      "👩🏿‍🦰", "👩🏿‍🦱", "👩🏿‍🦱", "👩🏿‍🦲", "👩🏿‍🦲", "👩🏿‍🦳",
-      "👩🏿‍🦳", "🧑‍🦰", "🧑‍🦰", "🧑‍🦱", "🧑‍🦱", "🧑‍🦲", "🧑‍🦲",
-      "🧑‍🦳", "🧑‍🦳", "🧑🏻‍🦰", "🧑🏻‍🦰", "🧑🏻‍🦱", "🧑🏻‍🦱",
-      "🧑🏻‍🦲", "🧑🏻‍🦲", "🧑🏻‍🦳", "🧑🏻‍🦳", "🧑🏼‍🦰", "🧑🏼‍🦰",
-      "🧑🏼‍🦱", "🧑🏼‍🦱", "🧑🏼‍🦲", "🧑🏼‍🦲", "🧑🏼‍🦳", "🧑🏼‍🦳",
-      "🧑🏽‍🦰", "🧑🏽‍🦰", "🧑🏽‍🦱", "🧑🏽‍🦱", "🧑🏽‍🦲", "🧑🏽‍🦲",
-      "🧑🏽‍🦳", "🧑🏽‍🦳", "🧑🏾‍🦰", "🧑🏾‍🦰", "🧑🏾‍🦱", "🧑🏾‍🦱",
-      "🧑🏾‍🦲", "🧑🏾‍🦲", "🧑🏾‍🦳", "🧑🏾‍🦳", "🧑🏿‍🦰", "🧑🏿‍🦰",
-      "🧑🏿‍🦱", "🧑🏿‍🦱", "🧑🏿‍🦲", "🧑🏿‍🦲", "🧑🏿‍🦳", "🧑🏿‍🦳",
+      "🧑🏿‍❤️‍🧑🏾", "🧑🏿‍🎄", "🧑🏿‍🤝‍🧑🏻", "🧑🏿‍🤝‍🧑🏼",
+      "🧑🏿‍🤝‍🧑🏽", "🧑🏿‍🤝‍🧑🏾", "🧑🏿‍🤝‍🧑🏿", "🫱🏻‍🫲🏼",
+      "🫱🏻‍🫲🏽", "🫱🏻‍🫲🏾", "🫱🏻‍🫲🏿", "🫱🏼‍🫲🏻", "🫱🏼‍🫲🏽",
+      "🫱🏼‍🫲🏾", "🫱🏼‍🫲🏿", "🫱🏽‍🫲🏻", "🫱🏽‍🫲🏼", "🫱🏽‍🫲🏾",
+      "🫱🏽‍🫲🏿", "🫱🏾‍🫲🏻", "🫱🏾‍🫲🏼", "🫱🏾‍🫲🏽", "🫱🏾‍🫲🏿",
+      "🫱🏿‍🫲🏻", "🫱🏿‍🫲🏼", "🫱🏿‍🫲🏽", "🫱🏿‍🫲🏾", "👨‍⚕",
+      "👨‍⚕️", "👨‍⚖", "👨‍⚖️", "👨‍✈", "👨‍✈️", "👨‍🌾", "👨‍🍳",
+      "👨‍🍼", "👨‍🎓", "👨‍🎤", "👨‍🎨", "👨‍🏫", "👨‍🏭", "👨‍💻",
+      "👨‍💼", "👨‍🔧", "👨‍🔬", "👨‍🚀", "👨‍🚒", "👨‍🦯", "👨‍🦼",
+      "👨‍🦽", "👨🏻‍⚕", "👨🏻‍⚕️", "👨🏻‍⚖", "👨🏻‍⚖️", "👨🏻‍✈",
+      "👨🏻‍✈️", "👨🏻‍🌾", "👨🏻‍🍳", "👨🏻‍🍼", "👨🏻‍🎓",
+      "👨🏻‍🎤", "👨🏻‍🎨", "👨🏻‍🏫", "👨🏻‍🏭", "👨🏻‍💻", "👨🏻‍💼",
+      "👨🏻‍🔧", "👨🏻‍🔬", "👨🏻‍🚀", "👨🏻‍🚒", "👨🏻‍🦯", "👨🏻‍🦼",
+      "👨🏻‍🦽", "👨🏼‍⚕", "👨🏼‍⚕️", "👨🏼‍⚖", "👨🏼‍⚖️", "👨🏼‍✈",
+      "👨🏼‍✈️", "👨🏼‍🌾", "👨🏼‍🍳", "👨🏼‍🍼", "👨🏼‍🎓",
+      "👨🏼‍🎤", "👨🏼‍🎨", "👨🏼‍🏫", "👨🏼‍🏭", "👨🏼‍💻", "👨🏼‍💼",
+      "👨🏼‍🔧", "👨🏼‍🔬", "👨🏼‍🚀", "👨🏼‍🚒", "👨🏼‍🦯", "👨🏼‍🦼",
+      "👨🏼‍🦽", "👨🏽‍⚕", "👨🏽‍⚕️", "👨🏽‍⚖", "👨🏽‍⚖️", "👨🏽‍✈",
+      "👨🏽‍✈️", "👨🏽‍🌾", "👨🏽‍🍳", "👨🏽‍🍼", "👨🏽‍🎓",
+      "👨🏽‍🎤", "👨🏽‍🎨", "👨🏽‍🏫", "👨🏽‍🏭", "👨🏽‍💻", "👨🏽‍💼",
+      "👨🏽‍🔧", "👨🏽‍🔬", "👨🏽‍🚀", "👨🏽‍🚒", "👨🏽‍🦯", "👨🏽‍🦼",
+      "👨🏽‍🦽", "👨🏾‍⚕", "👨🏾‍⚕️", "👨🏾‍⚖", "👨🏾‍⚖️", "👨🏾‍✈",
+      "👨🏾‍✈️", "👨🏾‍🌾", "👨🏾‍🍳", "👨🏾‍🍼", "👨🏾‍🎓",
+      "👨🏾‍🎤", "👨🏾‍🎨", "👨🏾‍🏫", "👨🏾‍🏭", "👨🏾‍💻", "👨🏾‍💼",
+      "👨🏾‍🔧", "👨🏾‍🔬", "👨🏾‍🚀", "👨🏾‍🚒", "👨🏾‍🦯", "👨🏾‍🦼",
+      "👨🏾‍🦽", "👨🏿‍⚕", "👨🏿‍⚕️", "👨🏿‍⚖", "👨🏿‍⚖️", "👨🏿‍✈",
+      "👨🏿‍✈️", "👨🏿‍🌾", "👨🏿‍🍳", "👨🏿‍🍼", "👨🏿‍🎓",
+      "👨🏿‍🎤", "👨🏿‍🎨", "👨🏿‍🏫", "👨🏿‍🏭", "👨🏿‍💻", "👨🏿‍💼",
+      "👨🏿‍🔧", "👨🏿‍🔬", "👨🏿‍🚀", "👨🏿‍🚒", "👨🏿‍🦯", "👨🏿‍🦼",
+      "👨🏿‍🦽", "👩‍⚕", "👩‍⚕️", "👩‍⚖", "👩‍⚖️", "👩‍✈", "👩‍✈️",
+      "👩‍🌾", "👩‍🍳", "👩‍🍼", "👩‍🎓", "👩‍🎤", "👩‍🎨", "👩‍🏫",
+      "👩‍🏭", "👩‍💻", "👩‍💼", "👩‍🔧", "👩‍🔬", "👩‍🚀", "👩‍🚒",
+      "👩‍🦯", "👩‍🦼", "👩‍🦽", "👩🏻‍⚕", "👩🏻‍⚕️", "👩🏻‍⚖",
+      "👩🏻‍⚖️", "👩🏻‍✈", "👩🏻‍✈️", "👩🏻‍🌾", "👩🏻‍🍳",
+      "👩🏻‍🍼", "👩🏻‍🎓", "👩🏻‍🎤", "👩🏻‍🎨", "👩🏻‍🏫", "👩🏻‍🏭",
+      "👩🏻‍💻", "👩🏻‍💼", "👩🏻‍🔧", "👩🏻‍🔬", "👩🏻‍🚀", "👩🏻‍🚒",
+      "👩🏻‍🦯", "👩🏻‍🦼", "👩🏻‍🦽", "👩🏼‍⚕", "👩🏼‍⚕️", "👩🏼‍⚖",
+      "👩🏼‍⚖️", "👩🏼‍✈", "👩🏼‍✈️", "👩🏼‍🌾", "👩🏼‍🍳",
+      "👩🏼‍🍼", "👩🏼‍🎓", "👩🏼‍🎤", "👩🏼‍🎨", "👩🏼‍🏫", "👩🏼‍🏭",
+      "👩🏼‍💻", "👩🏼‍💼", "👩🏼‍🔧", "👩🏼‍🔬", "👩🏼‍🚀", "👩🏼‍🚒",
+      "👩🏼‍🦯", "👩🏼‍🦼", "👩🏼‍🦽", "👩🏽‍⚕", "👩🏽‍⚕️", "👩🏽‍⚖",
+      "👩🏽‍⚖️", "👩🏽‍✈", "👩🏽‍✈️", "👩🏽‍🌾", "👩🏽‍🍳",
+      "👩🏽‍🍼", "👩🏽‍🎓", "👩🏽‍🎤", "👩🏽‍🎨", "👩🏽‍🏫", "👩🏽‍🏭",
+      "👩🏽‍💻", "👩🏽‍💼", "👩🏽‍🔧", "👩🏽‍🔬", "👩🏽‍🚀", "👩🏽‍🚒",
+      "👩🏽‍🦯", "👩🏽‍🦼", "👩🏽‍🦽", "👩🏾‍⚕", "👩🏾‍⚕️", "👩🏾‍⚖",
+      "👩🏾‍⚖️", "👩🏾‍✈", "👩🏾‍✈️", "👩🏾‍🌾", "👩🏾‍🍳",
+      "👩🏾‍🍼", "👩🏾‍🎓", "👩🏾‍🎤", "👩🏾‍🎨", "👩🏾‍🏫", "👩🏾‍🏭",
+      "👩🏾‍💻", "👩🏾‍💼", "👩🏾‍🔧", "👩🏾‍🔬", "👩🏾‍🚀", "👩🏾‍🚒",
+      "👩🏾‍🦯", "👩🏾‍🦼", "👩🏾‍🦽", "👩🏿‍⚕", "👩🏿‍⚕️", "👩🏿‍⚖",
+      "👩🏿‍⚖️", "👩🏿‍✈", "👩🏿‍✈️", "👩🏿‍🌾", "👩🏿‍🍳",
+      "👩🏿‍🍼", "👩🏿‍🎓", "👩🏿‍🎤", "👩🏿‍🎨", "👩🏿‍🏫", "👩🏿‍🏭",
+      "👩🏿‍💻", "👩🏿‍💼", "👩🏿‍🔧", "👩🏿‍🔬", "👩🏿‍🚀", "👩🏿‍🚒",
+      "👩🏿‍🦯", "👩🏿‍🦼", "👩🏿‍🦽", "🧑‍⚕", "🧑‍⚕️", "🧑‍⚖",
+      "🧑‍⚖️", "🧑‍✈", "🧑‍✈️", "🧑‍🌾", "🧑‍🍳", "🧑‍🍼", "🧑‍🎓",
+      "🧑‍🎤", "🧑‍🎨", "🧑‍🏫", "🧑‍🏭", "🧑‍💻", "🧑‍💼", "🧑‍🔧",
+      "🧑‍🔬", "🧑‍🚀", "🧑‍🚒", "🧑‍🦯", "🧑‍🦼", "🧑‍🦽", "🧑🏻‍⚕",
+      "🧑🏻‍⚕️", "🧑🏻‍⚖", "🧑🏻‍⚖️", "🧑🏻‍✈", "🧑🏻‍✈️",
+      "🧑🏻‍🌾", "🧑🏻‍🍳", "🧑🏻‍🍼", "🧑🏻‍🎓", "🧑🏻‍🎤", "🧑🏻‍🎨",
+      "🧑🏻‍🏫", "🧑🏻‍🏭", "🧑🏻‍💻", "🧑🏻‍💼", "🧑🏻‍🔧", "🧑🏻‍🔬",
+      "🧑🏻‍🚀", "🧑🏻‍🚒", "🧑🏻‍🦯", "🧑🏻‍🦼", "🧑🏻‍🦽", "🧑🏼‍⚕",
+      "🧑🏼‍⚕️", "🧑🏼‍⚖", "🧑🏼‍⚖️", "🧑🏼‍✈", "🧑🏼‍✈️",
+      "🧑🏼‍🌾", "🧑🏼‍🍳", "🧑🏼‍🍼", "🧑🏼‍🎓", "🧑🏼‍🎤", "🧑🏼‍🎨",
+      "🧑🏼‍🏫", "🧑🏼‍🏭", "🧑🏼‍💻", "🧑🏼‍💼", "🧑🏼‍🔧", "🧑🏼‍🔬",
+      "🧑🏼‍🚀", "🧑🏼‍🚒", "🧑🏼‍🦯", "🧑🏼‍🦼", "🧑🏼‍🦽", "🧑🏽‍⚕",
+      "🧑🏽‍⚕️", "🧑🏽‍⚖", "🧑🏽‍⚖️", "🧑🏽‍✈", "🧑🏽‍✈️",
+      "🧑🏽‍🌾", "🧑🏽‍🍳", "🧑🏽‍🍼", "🧑🏽‍🎓", "🧑🏽‍🎤", "🧑🏽‍🎨",
+      "🧑🏽‍🏫", "🧑🏽‍🏭", "🧑🏽‍💻", "🧑🏽‍💼", "🧑🏽‍🔧", "🧑🏽‍🔬",
+      "🧑🏽‍🚀", "🧑🏽‍🚒", "🧑🏽‍🦯", "🧑🏽‍🦼", "🧑🏽‍🦽", "🧑🏾‍⚕",
+      "🧑🏾‍⚕️", "🧑🏾‍⚖", "🧑🏾‍⚖️", "🧑🏾‍✈", "🧑🏾‍✈️",
+      "🧑🏾‍🌾", "🧑🏾‍🍳", "🧑🏾‍🍼", "🧑🏾‍🎓", "🧑🏾‍🎤", "🧑🏾‍🎨",
+      "🧑🏾‍🏫", "🧑🏾‍🏭", "🧑🏾‍💻", "🧑🏾‍💼", "🧑🏾‍🔧", "🧑🏾‍🔬",
+      "🧑🏾‍🚀", "🧑🏾‍🚒", "🧑🏾‍🦯", "🧑🏾‍🦼", "🧑🏾‍🦽", "🧑🏿‍⚕",
+      "🧑🏿‍⚕️", "🧑🏿‍⚖", "🧑🏿‍⚖️", "🧑🏿‍✈", "🧑🏿‍✈️",
+      "🧑🏿‍🌾", "🧑🏿‍🍳", "🧑🏿‍🍼", "🧑🏿‍🎓", "🧑🏿‍🎤", "🧑🏿‍🎨",
+      "🧑🏿‍🏫", "🧑🏿‍🏭", "🧑🏿‍💻", "🧑🏿‍💼", "🧑🏿‍🔧", "🧑🏿‍🔬",
+      "🧑🏿‍🚀", "🧑🏿‍🚒", "🧑🏿‍🦯", "🧑🏿‍🦼", "🧑🏿‍🦽", "⛹🏻‍♀",
+      "⛹🏻‍♀️", "⛹🏻‍♂", "⛹🏻‍♂️", "⛹🏼‍♀", "⛹🏼‍♀️", "⛹🏼‍♂",
+      "⛹🏼‍♂️", "⛹🏽‍♀", "⛹🏽‍♀️", "⛹🏽‍♂", "⛹🏽‍♂️", "⛹🏾‍♀",
+      "⛹🏾‍♀️", "⛹🏾‍♂", "⛹🏾‍♂️", "⛹🏿‍♀", "⛹🏿‍♀️", "⛹🏿‍♂",
+      "⛹🏿‍♂️", "⛹‍♀", "⛹️‍♀️", "⛹‍♂", "⛹️‍♂️", "🏃‍♀", "🏃‍♀️",
+      "🏃‍♂", "🏃‍♂️", "🏃🏻‍♀", "🏃🏻‍♀️", "🏃🏻‍♂", "🏃🏻‍♂️",
+      "🏃🏼‍♀", "🏃🏼‍♀️", "🏃🏼‍♂", "🏃🏼‍♂️", "🏃🏽‍♀",
+      "🏃🏽‍♀️", "🏃🏽‍♂", "🏃🏽‍♂️", "🏃🏾‍♀", "🏃🏾‍♀️",
+      "🏃🏾‍♂", "🏃🏾‍♂️", "🏃🏿‍♀", "🏃🏿‍♀️", "🏃🏿‍♂",
+      "🏃🏿‍♂️", "🏄‍♀", "🏄‍♀️", "🏄‍♂", "🏄‍♂️", "🏄🏻‍♀",
+      "🏄🏻‍♀️", "🏄🏻‍♂", "🏄🏻‍♂️", "🏄🏼‍♀", "🏄🏼‍♀️",
+      "🏄🏼‍♂", "🏄🏼‍♂️", "🏄🏽‍♀", "🏄🏽‍♀️", "🏄🏽‍♂",
+      "🏄🏽‍♂️", "🏄🏾‍♀", "🏄🏾‍♀️", "🏄🏾‍♂", "🏄🏾‍♂️",
+      "🏄🏿‍♀", "🏄🏿‍♀️", "🏄🏿‍♂", "🏄🏿‍♂️", "🏊‍♀", "🏊‍♀️",
+      "🏊‍♂", "🏊‍♂️", "🏊🏻‍♀", "🏊🏻‍♀️", "🏊🏻‍♂", "🏊🏻‍♂️",
+      "🏊🏼‍♀", "🏊🏼‍♀️", "🏊🏼‍♂", "🏊🏼‍♂️", "🏊🏽‍♀",
+      "🏊🏽‍♀️", "🏊🏽‍♂", "🏊🏽‍♂️", "🏊🏾‍♀", "🏊🏾‍♀️",
+      "🏊🏾‍♂", "🏊🏾‍♂️", "🏊🏿‍♀", "🏊🏿‍♀️", "🏊🏿‍♂",
+      "🏊🏿‍♂️", "🏋🏻‍♀", "🏋🏻‍♀️", "🏋🏻‍♂", "🏋🏻‍♂️",
+      "🏋🏼‍♀", "🏋🏼‍♀️", "🏋🏼‍♂", "🏋🏼‍♂️", "🏋🏽‍♀",
+      "🏋🏽‍♀️", "🏋🏽‍♂", "🏋🏽‍♂️", "🏋🏾‍♀", "🏋🏾‍♀️",
+      "🏋🏾‍♂", "🏋🏾‍♂️", "🏋🏿‍♀", "🏋🏿‍♀️", "🏋🏿‍♂",
+      "🏋🏿‍♂️", "🏋‍♀", "🏋️‍♀️", "🏋‍♂", "🏋️‍♂️", "🏌🏻‍♀",
+      "🏌🏻‍♀️", "🏌🏻‍♂", "🏌🏻‍♂️", "🏌🏼‍♀", "🏌🏼‍♀️",
+      "🏌🏼‍♂", "🏌🏼‍♂️", "🏌🏽‍♀", "🏌🏽‍♀️", "🏌🏽‍♂",
+      "🏌🏽‍♂️", "🏌🏾‍♀", "🏌🏾‍♀️", "🏌🏾‍♂", "🏌🏾‍♂️",
+      "🏌🏿‍♀", "🏌🏿‍♀️", "🏌🏿‍♂", "🏌🏿‍♂️", "🏌‍♀", "🏌️‍♀️",
+      "🏌‍♂", "🏌️‍♂️", "👮‍♀", "👮‍♀️", "👮‍♂", "👮‍♂️", "👮🏻‍♀",
+      "👮🏻‍♀️", "👮🏻‍♂", "👮🏻‍♂️", "👮🏼‍♀", "👮🏼‍♀️",
+      "👮🏼‍♂", "👮🏼‍♂️", "👮🏽‍♀", "👮🏽‍♀️", "👮🏽‍♂",
+      "👮🏽‍♂️", "👮🏾‍♀", "👮🏾‍♀️", "👮🏾‍♂", "👮🏾‍♂️",
+      "👮🏿‍♀", "👮🏿‍♀️", "👮🏿‍♂", "👮🏿‍♂️", "👯‍♀", "👯‍♀️",
+      "👯‍♂", "👯‍♂️", "👰‍♀", "👰‍♀️", "👰‍♂", "👰‍♂️", "👰🏻‍♀",
+      "👰🏻‍♀️", "👰🏻‍♂", "👰🏻‍♂️", "👰🏼‍♀", "👰🏼‍♀️",
+      "👰🏼‍♂", "👰🏼‍♂️", "👰🏽‍♀", "👰🏽‍♀️", "👰🏽‍♂",
+      "👰🏽‍♂️", "👰🏾‍♀", "👰🏾‍♀️", "👰🏾‍♂", "👰🏾‍♂️",
+      "👰🏿‍♀", "👰🏿‍♀️", "👰🏿‍♂", "👰🏿‍♂️", "👱‍♀", "👱‍♀️",
+      "👱‍♂", "👱‍♂️", "👱🏻‍♀", "👱🏻‍♀️", "👱🏻‍♂", "👱🏻‍♂️",
+      "👱🏼‍♀", "👱🏼‍♀️", "👱🏼‍♂", "👱🏼‍♂️", "👱🏽‍♀",
+      "👱🏽‍♀️", "👱🏽‍♂", "👱🏽‍♂️", "👱🏾‍♀", "👱🏾‍♀️",
+      "👱🏾‍♂", "👱🏾‍♂️", "👱🏿‍♀", "👱🏿‍♀️", "👱🏿‍♂",
+      "👱🏿‍♂️", "👳‍♀", "👳‍♀️", "👳‍♂", "👳‍♂️", "👳🏻‍♀",
+      "👳🏻‍♀️", "👳🏻‍♂", "👳🏻‍♂️", "👳🏼‍♀", "👳🏼‍♀️",
+      "👳🏼‍♂", "👳🏼‍♂️", "👳🏽‍♀", "👳🏽‍♀️", "👳🏽‍♂",
+      "👳🏽‍♂️", "👳🏾‍♀", "👳🏾‍♀️", "👳🏾‍♂", "👳🏾‍♂️",
+      "👳🏿‍♀", "👳🏿‍♀️", "👳🏿‍♂", "👳🏿‍♂️", "👷‍♀", "👷‍♀️",
+      "👷‍♂", "👷‍♂️", "👷🏻‍♀", "👷🏻‍♀️", "👷🏻‍♂", "👷🏻‍♂️",
+      "👷🏼‍♀", "👷🏼‍♀️", "👷🏼‍♂", "👷🏼‍♂️", "👷🏽‍♀",
+      "👷🏽‍♀️", "👷🏽‍♂", "👷🏽‍♂️", "👷🏾‍♀", "👷🏾‍♀️",
+      "👷🏾‍♂", "👷🏾‍♂️", "👷🏿‍♀", "👷🏿‍♀️", "👷🏿‍♂",
+      "👷🏿‍♂️", "💁‍♀", "💁‍♀️", "💁‍♂", "💁‍♂️", "💁🏻‍♀",
+      "💁🏻‍♀️", "💁🏻‍♂", "💁🏻‍♂️", "💁🏼‍♀", "💁🏼‍♀️",
+      "💁🏼‍♂", "💁🏼‍♂️", "💁🏽‍♀", "💁🏽‍♀️", "💁🏽‍♂",
+      "💁🏽‍♂️", "💁🏾‍♀", "💁🏾‍♀️", "💁🏾‍♂", "💁🏾‍♂️",
+      "💁🏿‍♀", "💁🏿‍♀️", "💁🏿‍♂", "💁🏿‍♂️", "💂‍♀", "💂‍♀️",
+      "💂‍♂", "💂‍♂️", "💂🏻‍♀", "💂🏻‍♀️", "💂🏻‍♂", "💂🏻‍♂️",
+      "💂🏼‍♀", "💂🏼‍♀️", "💂🏼‍♂", "💂🏼‍♂️", "💂🏽‍♀",
+      "💂🏽‍♀️", "💂🏽‍♂", "💂🏽‍♂️", "💂🏾‍♀", "💂🏾‍♀️",
+      "💂🏾‍♂", "💂🏾‍♂️", "💂🏿‍♀", "💂🏿‍♀️", "💂🏿‍♂",
+      "💂🏿‍♂️", "💆‍♀", "💆‍♀️", "💆‍♂", "💆‍♂️", "💆🏻‍♀",
+      "💆🏻‍♀️", "💆🏻‍♂", "💆🏻‍♂️", "💆🏼‍♀", "💆🏼‍♀️",
+      "💆🏼‍♂", "💆🏼‍♂️", "💆🏽‍♀", "💆🏽‍♀️", "💆🏽‍♂",
+      "💆🏽‍♂️", "💆🏾‍♀", "💆🏾‍♀️", "💆🏾‍♂", "💆🏾‍♂️",
+      "💆🏿‍♀", "💆🏿‍♀️", "💆🏿‍♂", "💆🏿‍♂️", "💇‍♀", "💇‍♀️",
+      "💇‍♂", "💇‍♂️", "💇🏻‍♀", "💇🏻‍♀️", "💇🏻‍♂", "💇🏻‍♂️",
+      "💇🏼‍♀", "💇🏼‍♀️", "💇🏼‍♂", "💇🏼‍♂️", "💇🏽‍♀",
+      "💇🏽‍♀️", "💇🏽‍♂", "💇🏽‍♂️", "💇🏾‍♀", "💇🏾‍♀️",
+      "💇🏾‍♂", "💇🏾‍♂️", "💇🏿‍♀", "💇🏿‍♀️", "💇🏿‍♂",
+      "💇🏿‍♂️", "🕵🏻‍♀", "🕵🏻‍♀️", "🕵🏻‍♂", "🕵🏻‍♂️",
+      "🕵🏼‍♀", "🕵🏼‍♀️", "🕵🏼‍♂", "🕵🏼‍♂️", "🕵🏽‍♀",
+      "🕵🏽‍♀️", "🕵🏽‍♂", "🕵🏽‍♂️", "🕵🏾‍♀", "🕵🏾‍♀️",
+      "🕵🏾‍♂", "🕵🏾‍♂️", "🕵🏿‍♀", "🕵🏿‍♀️", "🕵🏿‍♂",
+      "🕵🏿‍♂️", "🕵‍♀", "🕵️‍♀️", "🕵‍♂", "🕵️‍♂️", "🙅‍♀",
+      "🙅‍♀️", "🙅‍♂", "🙅‍♂️", "🙅🏻‍♀", "🙅🏻‍♀️", "🙅🏻‍♂",
+      "🙅🏻‍♂️", "🙅🏼‍♀", "🙅🏼‍♀️", "🙅🏼‍♂", "🙅🏼‍♂️",
+      "🙅🏽‍♀", "🙅🏽‍♀️", "🙅🏽‍♂", "🙅🏽‍♂️", "🙅🏾‍♀",
+      "🙅🏾‍♀️", "🙅🏾‍♂", "🙅🏾‍♂️", "🙅🏿‍♀", "🙅🏿‍♀️",
+      "🙅🏿‍♂", "🙅🏿‍♂️", "🙆‍♀", "🙆‍♀️", "🙆‍♂", "🙆‍♂️",
+      "🙆🏻‍♀", "🙆🏻‍♀️", "🙆🏻‍♂", "🙆🏻‍♂️", "🙆🏼‍♀",
+      "🙆🏼‍♀️", "🙆🏼‍♂", "🙆🏼‍♂️", "🙆🏽‍♀", "🙆🏽‍♀️",
+      "🙆🏽‍♂", "🙆🏽‍♂️", "🙆🏾‍♀", "🙆🏾‍♀️", "🙆🏾‍♂",
+      "🙆🏾‍♂️", "🙆🏿‍♀", "🙆🏿‍♀️", "🙆🏿‍♂", "🙆🏿‍♂️", "🙇‍♀",
+      "🙇‍♀️", "🙇‍♂", "🙇‍♂️", "🙇🏻‍♀", "🙇🏻‍♀️", "🙇🏻‍♂",
+      "🙇🏻‍♂️", "🙇🏼‍♀", "🙇🏼‍♀️", "🙇🏼‍♂", "🙇🏼‍♂️",
+      "🙇🏽‍♀", "🙇🏽‍♀️", "🙇🏽‍♂", "🙇🏽‍♂️", "🙇🏾‍♀",
+      "🙇🏾‍♀️", "🙇🏾‍♂", "🙇🏾‍♂️", "🙇🏿‍♀", "🙇🏿‍♀️",
+      "🙇🏿‍♂", "🙇🏿‍♂️", "🙋‍♀", "🙋‍♀️", "🙋‍♂", "🙋‍♂️",
+      "🙋🏻‍♀", "🙋🏻‍♀️", "🙋🏻‍♂", "🙋🏻‍♂️", "🙋🏼‍♀",
+      "🙋🏼‍♀️", "🙋🏼‍♂", "🙋🏼‍♂️", "🙋🏽‍♀", "🙋🏽‍♀️",
+      "🙋🏽‍♂", "🙋🏽‍♂️", "🙋🏾‍♀", "🙋🏾‍♀️", "🙋🏾‍♂",
+      "🙋🏾‍♂️", "🙋🏿‍♀", "🙋🏿‍♀️", "🙋🏿‍♂", "🙋🏿‍♂️", "🙍‍♀",
+      "🙍‍♀️", "🙍‍♂", "🙍‍♂️", "🙍🏻‍♀", "🙍🏻‍♀️", "🙍🏻‍♂",
+      "🙍🏻‍♂️", "🙍🏼‍♀", "🙍🏼‍♀️", "🙍🏼‍♂", "🙍🏼‍♂️",
+      "🙍🏽‍♀", "🙍🏽‍♀️", "🙍🏽‍♂", "🙍🏽‍♂️", "🙍🏾‍♀",
+      "🙍🏾‍♀️", "🙍🏾‍♂", "🙍🏾‍♂️", "🙍🏿‍♀", "🙍🏿‍♀️",
+      "🙍🏿‍♂", "🙍🏿‍♂️", "🙎‍♀", "🙎‍♀️", "🙎‍♂", "🙎‍♂️",
+      "🙎🏻‍♀", "🙎🏻‍♀️", "🙎🏻‍♂", "🙎🏻‍♂️", "🙎🏼‍♀",
+      "🙎🏼‍♀️", "🙎🏼‍♂", "🙎🏼‍♂️", "🙎🏽‍♀", "🙎🏽‍♀️",
+      "🙎🏽‍♂", "🙎🏽‍♂️", "🙎🏾‍♀", "🙎🏾‍♀️", "🙎🏾‍♂",
+      "🙎🏾‍♂️", "🙎🏿‍♀", "🙎🏿‍♀️", "🙎🏿‍♂", "🙎🏿‍♂️", "🚣‍♀",
+      "🚣‍♀️", "🚣‍♂", "🚣‍♂️", "🚣🏻‍♀", "🚣🏻‍♀️", "🚣🏻‍♂",
+      "🚣🏻‍♂️", "🚣🏼‍♀", "🚣🏼‍♀️", "🚣🏼‍♂", "🚣🏼‍♂️",
+      "🚣🏽‍♀", "🚣🏽‍♀️", "🚣🏽‍♂", "🚣🏽‍♂️", "🚣🏾‍♀",
+      "🚣🏾‍♀️", "🚣🏾‍♂", "🚣🏾‍♂️", "🚣🏿‍♀", "🚣🏿‍♀️",
+      "🚣🏿‍♂", "🚣🏿‍♂️", "🚴‍♀", "🚴‍♀️", "🚴‍♂", "🚴‍♂️",
+      "🚴🏻‍♀", "🚴🏻‍♀️", "🚴🏻‍♂", "🚴🏻‍♂️", "🚴🏼‍♀",
+      "🚴🏼‍♀️", "🚴🏼‍♂", "🚴🏼‍♂️", "🚴🏽‍♀", "🚴🏽‍♀️",
+      "🚴🏽‍♂", "🚴🏽‍♂️", "🚴🏾‍♀", "🚴🏾‍♀️", "🚴🏾‍♂",
+      "🚴🏾‍♂️", "🚴🏿‍♀", "🚴🏿‍♀️", "🚴🏿‍♂", "🚴🏿‍♂️", "🚵‍♀",
+      "🚵‍♀️", "🚵‍♂", "🚵‍♂️", "🚵🏻‍♀", "🚵🏻‍♀️", "🚵🏻‍♂",
+      "🚵🏻‍♂️", "🚵🏼‍♀", "🚵🏼‍♀️", "🚵🏼‍♂", "🚵🏼‍♂️",
+      "🚵🏽‍♀", "🚵🏽‍♀️", "🚵🏽‍♂", "🚵🏽‍♂️", "🚵🏾‍♀",
+      "🚵🏾‍♀️", "🚵🏾‍♂", "🚵🏾‍♂️", "🚵🏿‍♀", "🚵🏿‍♀️",
+      "🚵🏿‍♂", "🚵🏿‍♂️", "🚶‍♀", "🚶‍♀️", "🚶‍♂", "🚶‍♂️",
+      "🚶🏻‍♀", "🚶🏻‍♀️", "🚶🏻‍♂", "🚶🏻‍♂️", "🚶🏼‍♀",
+      "🚶🏼‍♀️", "🚶🏼‍♂", "🚶🏼‍♂️", "🚶🏽‍♀", "🚶🏽‍♀️",
+      "🚶🏽‍♂", "🚶🏽‍♂️", "🚶🏾‍♀", "🚶🏾‍♀️", "🚶🏾‍♂",
+      "🚶🏾‍♂️", "🚶🏿‍♀", "🚶🏿‍♀️", "🚶🏿‍♂", "🚶🏿‍♂️", "🤦‍♀",
+      "🤦‍♀️", "🤦‍♂", "🤦‍♂️", "🤦🏻‍♀", "🤦🏻‍♀️", "🤦🏻‍♂",
+      "🤦🏻‍♂️", "🤦🏼‍♀", "🤦🏼‍♀️", "🤦🏼‍♂", "🤦🏼‍♂️",
+      "🤦🏽‍♀", "🤦🏽‍♀️", "🤦🏽‍♂", "🤦🏽‍♂️", "🤦🏾‍♀",
+      "🤦🏾‍♀️", "🤦🏾‍♂", "🤦🏾‍♂️", "🤦🏿‍♀", "🤦🏿‍♀️",
+      "🤦🏿‍♂", "🤦🏿‍♂️", "🤵‍♀", "🤵‍♀️", "🤵‍♂", "🤵‍♂️",
+      "🤵🏻‍♀", "🤵🏻‍♀️", "🤵🏻‍♂", "🤵🏻‍♂️", "🤵🏼‍♀",
+      "🤵🏼‍♀️", "🤵🏼‍♂", "🤵🏼‍♂️", "🤵🏽‍♀", "🤵🏽‍♀️",
+      "🤵🏽‍♂", "🤵🏽‍♂️", "🤵🏾‍♀", "🤵🏾‍♀️", "🤵🏾‍♂",
+      "🤵🏾‍♂️", "🤵🏿‍♀", "🤵🏿‍♀️", "🤵🏿‍♂", "🤵🏿‍♂️", "🤷‍♀",
+      "🤷‍♀️", "🤷‍♂", "🤷‍♂️", "🤷🏻‍♀", "🤷🏻‍♀️", "🤷🏻‍♂",
+      "🤷🏻‍♂️", "🤷🏼‍♀", "🤷🏼‍♀️", "🤷🏼‍♂", "🤷🏼‍♂️",
+      "🤷🏽‍♀", "🤷🏽‍♀️", "🤷🏽‍♂", "🤷🏽‍♂️", "🤷🏾‍♀",
+      "🤷🏾‍♀️", "🤷🏾‍♂", "🤷🏾‍♂️", "🤷🏿‍♀", "🤷🏿‍♀️",
+      "🤷🏿‍♂", "🤷🏿‍♂️", "🤸‍♀", "🤸‍♀️", "🤸‍♂", "🤸‍♂️",
+      "🤸🏻‍♀", "🤸🏻‍♀️", "🤸🏻‍♂", "🤸🏻‍♂️", "🤸🏼‍♀",
+      "🤸🏼‍♀️", "🤸🏼‍♂", "🤸🏼‍♂️", "🤸🏽‍♀", "🤸🏽‍♀️",
+      "🤸🏽‍♂", "🤸🏽‍♂️", "🤸🏾‍♀", "🤸🏾‍♀️", "🤸🏾‍♂",
+      "🤸🏾‍♂️", "🤸🏿‍♀", "🤸🏿‍♀️", "🤸🏿‍♂", "🤸🏿‍♂️", "🤹‍♀",
+      "🤹‍♀️", "🤹‍♂", "🤹‍♂️", "🤹🏻‍♀", "🤹🏻‍♀️", "🤹🏻‍♂",
+      "🤹🏻‍♂️", "🤹🏼‍♀", "🤹🏼‍♀️", "🤹🏼‍♂", "🤹🏼‍♂️",
+      "🤹🏽‍♀", "🤹🏽‍♀️", "🤹🏽‍♂", "🤹🏽‍♂️", "🤹🏾‍♀",
+      "🤹🏾‍♀️", "🤹🏾‍♂", "🤹🏾‍♂️", "🤹🏿‍♀", "🤹🏿‍♀️",
+      "🤹🏿‍♂", "🤹🏿‍♂️", "🤼‍♀", "🤼‍♀️", "🤼‍♂", "🤼‍♂️", "🤽‍♀",
+      "🤽‍♀️", "🤽‍♂", "🤽‍♂️", "🤽🏻‍♀", "🤽🏻‍♀️", "🤽🏻‍♂",
+      "🤽🏻‍♂️", "🤽🏼‍♀", "🤽🏼‍♀️", "🤽🏼‍♂", "🤽🏼‍♂️",
+      "🤽🏽‍♀", "🤽🏽‍♀️", "🤽🏽‍♂", "🤽🏽‍♂️", "🤽🏾‍♀",
+      "🤽🏾‍♀️", "🤽🏾‍♂", "🤽🏾‍♂️", "🤽🏿‍♀", "🤽🏿‍♀️",
+      "🤽🏿‍♂", "🤽🏿‍♂️", "🤾‍♀", "🤾‍♀️", "🤾‍♂", "🤾‍♂️",
+      "🤾🏻‍♀", "🤾🏻‍♀️", "🤾🏻‍♂", "🤾🏻‍♂️", "🤾🏼‍♀",
+      "🤾🏼‍♀️", "🤾🏼‍♂", "🤾🏼‍♂️", "🤾🏽‍♀", "🤾🏽‍♀️",
+      "🤾🏽‍♂", "🤾🏽‍♂️", "🤾🏾‍♀", "🤾🏾‍♀️", "🤾🏾‍♂",
+      "🤾🏾‍♂️", "🤾🏿‍♀", "🤾🏿‍♀️", "🤾🏿‍♂", "🤾🏿‍♂️", "🦸‍♀",
+      "🦸‍♀️", "🦸‍♂", "🦸‍♂️", "🦸🏻‍♀", "🦸🏻‍♀️", "🦸🏻‍♂",
+      "🦸🏻‍♂️", "🦸🏼‍♀", "🦸🏼‍♀️", "🦸🏼‍♂", "🦸🏼‍♂️",
+      "🦸🏽‍♀", "🦸🏽‍♀️", "🦸🏽‍♂", "🦸🏽‍♂️", "🦸🏾‍♀",
+      "🦸🏾‍♀️", "🦸🏾‍♂", "🦸🏾‍♂️", "🦸🏿‍♀", "🦸🏿‍♀️",
+      "🦸🏿‍♂", "🦸🏿‍♂️", "🦹‍♀", "🦹‍♀️", "🦹‍♂", "🦹‍♂️",
+      "🦹🏻‍♀", "🦹🏻‍♀️", "🦹🏻‍♂", "🦹🏻‍♂️", "🦹🏼‍♀",
+      "🦹🏼‍♀️", "🦹🏼‍♂", "🦹🏼‍♂️", "🦹🏽‍♀", "🦹🏽‍♀️",
+      "🦹🏽‍♂", "🦹🏽‍♂️", "🦹🏾‍♀", "🦹🏾‍♀️", "🦹🏾‍♂",
+      "🦹🏾‍♂️", "🦹🏿‍♀", "🦹🏿‍♀️", "🦹🏿‍♂", "🦹🏿‍♂️", "🧍‍♀",
+      "🧍‍♀️", "🧍‍♂", "🧍‍♂️", "🧍🏻‍♀", "🧍🏻‍♀️", "🧍🏻‍♂",
+      "🧍🏻‍♂️", "🧍🏼‍♀", "🧍🏼‍♀️", "🧍🏼‍♂", "🧍🏼‍♂️",
+      "🧍🏽‍♀", "🧍🏽‍♀️", "🧍🏽‍♂", "🧍🏽‍♂️", "🧍🏾‍♀",
+      "🧍🏾‍♀️", "🧍🏾‍♂", "🧍🏾‍♂️", "🧍🏿‍♀", "🧍🏿‍♀️",
+      "🧍🏿‍♂", "🧍🏿‍♂️", "🧎‍♀", "🧎‍♀️", "🧎‍♂", "🧎‍♂️",
+      "🧎🏻‍♀", "🧎🏻‍♀️", "🧎🏻‍♂", "🧎🏻‍♂️", "🧎🏼‍♀",
+      "🧎🏼‍♀️", "🧎🏼‍♂", "🧎🏼‍♂️", "🧎🏽‍♀", "🧎🏽‍♀️",
+      "🧎🏽‍♂", "🧎🏽‍♂️", "🧎🏾‍♀", "🧎🏾‍♀️", "🧎🏾‍♂",
+      "🧎🏾‍♂️", "🧎🏿‍♀", "🧎🏿‍♀️", "🧎🏿‍♂", "🧎🏿‍♂️", "🧏‍♀",
+      "🧏‍♀️", "🧏‍♂", "🧏‍♂️", "🧏🏻‍♀", "🧏🏻‍♀️", "🧏🏻‍♂",
+      "🧏🏻‍♂️", "🧏🏼‍♀", "🧏🏼‍♀️", "🧏🏼‍♂", "🧏🏼‍♂️",
+      "🧏🏽‍♀", "🧏🏽‍♀️", "🧏🏽‍♂", "🧏🏽‍♂️", "🧏🏾‍♀",
+      "🧏🏾‍♀️", "🧏🏾‍♂", "🧏🏾‍♂️", "🧏🏿‍♀", "🧏🏿‍♀️",
+      "🧏🏿‍♂", "🧏🏿‍♂️", "🧔‍♀", "🧔‍♀️", "🧔‍♂", "🧔‍♂️",
+      "🧔🏻‍♀", "🧔🏻‍♀️", "🧔🏻‍♂", "🧔🏻‍♂️", "🧔🏼‍♀",
+      "🧔🏼‍♀️", "🧔🏼‍♂", "🧔🏼‍♂️", "🧔🏽‍♀", "🧔🏽‍♀️",
+      "🧔🏽‍♂", "🧔🏽‍♂️", "🧔🏾‍♀", "🧔🏾‍♀️", "🧔🏾‍♂",
+      "🧔🏾‍♂️", "🧔🏿‍♀", "🧔🏿‍♀️", "🧔🏿‍♂", "🧔🏿‍♂️", "🧖‍♀",
+      "🧖‍♀️", "🧖‍♂", "🧖‍♂️", "🧖🏻‍♀", "🧖🏻‍♀️", "🧖🏻‍♂",
+      "🧖🏻‍♂️", "🧖🏼‍♀", "🧖🏼‍♀️", "🧖🏼‍♂", "🧖🏼‍♂️",
+      "🧖🏽‍♀", "🧖🏽‍♀️", "🧖🏽‍♂", "🧖🏽‍♂️", "🧖🏾‍♀",
+      "🧖🏾‍♀️", "🧖🏾‍♂", "🧖🏾‍♂️", "🧖🏿‍♀", "🧖🏿‍♀️",
+      "🧖🏿‍♂", "🧖🏿‍♂️", "🧗‍♀", "🧗‍♀️", "🧗‍♂", "🧗‍♂️",
+      "🧗🏻‍♀", "🧗🏻‍♀️", "🧗🏻‍♂", "🧗🏻‍♂️", "🧗🏼‍♀",
+      "🧗🏼‍♀️", "🧗🏼‍♂", "🧗🏼‍♂️", "🧗🏽‍♀", "🧗🏽‍♀️",
+      "🧗🏽‍♂", "🧗🏽‍♂️", "🧗🏾‍♀", "🧗🏾‍♀️", "🧗🏾‍♂",
+      "🧗🏾‍♂️", "🧗🏿‍♀", "🧗🏿‍♀️", "🧗🏿‍♂", "🧗🏿‍♂️", "🧘‍♀",
+      "🧘‍♀️", "🧘‍♂", "🧘‍♂️", "🧘🏻‍♀", "🧘🏻‍♀️", "🧘🏻‍♂",
+      "🧘🏻‍♂️", "🧘🏼‍♀", "🧘🏼‍♀️", "🧘🏼‍♂", "🧘🏼‍♂️",
+      "🧘🏽‍♀", "🧘🏽‍♀️", "🧘🏽‍♂", "🧘🏽‍♂️", "🧘🏾‍♀",
+      "🧘🏾‍♀️", "🧘🏾‍♂", "🧘🏾‍♂️", "🧘🏿‍♀", "🧘🏿‍♀️",
+      "🧘🏿‍♂", "🧘🏿‍♂️", "🧙‍♀", "🧙‍♀️", "🧙‍♂", "🧙‍♂️",
+      "🧙🏻‍♀", "🧙🏻‍♀️", "🧙🏻‍♂", "🧙🏻‍♂️", "🧙🏼‍♀",
+      "🧙🏼‍♀️", "🧙🏼‍♂", "🧙🏼‍♂️", "🧙🏽‍♀", "🧙🏽‍♀️",
+      "🧙🏽‍♂", "🧙🏽‍♂️", "🧙🏾‍♀", "🧙🏾‍♀️", "🧙🏾‍♂",
+      "🧙🏾‍♂️", "🧙🏿‍♀", "🧙🏿‍♀️", "🧙🏿‍♂", "🧙🏿‍♂️", "🧚‍♀",
+      "🧚‍♀️", "🧚‍♂", "🧚‍♂️", "🧚🏻‍♀", "🧚🏻‍♀️", "🧚🏻‍♂",
+      "🧚🏻‍♂️", "🧚🏼‍♀", "🧚🏼‍♀️", "🧚🏼‍♂", "🧚🏼‍♂️",
+      "🧚🏽‍♀", "🧚🏽‍♀️", "🧚🏽‍♂", "🧚🏽‍♂️", "🧚🏾‍♀",
+      "🧚🏾‍♀️", "🧚🏾‍♂", "🧚🏾‍♂️", "🧚🏿‍♀", "🧚🏿‍♀️",
+      "🧚🏿‍♂", "🧚🏿‍♂️", "🧛‍♀", "🧛‍♀️", "🧛‍♂", "🧛‍♂️",
+      "🧛🏻‍♀", "🧛🏻‍♀️", "🧛🏻‍♂", "🧛🏻‍♂️", "🧛🏼‍♀",
+      "🧛🏼‍♀️", "🧛🏼‍♂", "🧛🏼‍♂️", "🧛🏽‍♀", "🧛🏽‍♀️",
+      "🧛🏽‍♂", "🧛🏽‍♂️", "🧛🏾‍♀", "🧛🏾‍♀️", "🧛🏾‍♂",
+      "🧛🏾‍♂️", "🧛🏿‍♀", "🧛🏿‍♀️", "🧛🏿‍♂", "🧛🏿‍♂️", "🧜‍♀",
+      "🧜‍♀️", "🧜‍♂", "🧜‍♂️", "🧜🏻‍♀", "🧜🏻‍♀️", "🧜🏻‍♂",
+      "🧜🏻‍♂️", "🧜🏼‍♀", "🧜🏼‍♀️", "🧜🏼‍♂", "🧜🏼‍♂️",
+      "🧜🏽‍♀", "🧜🏽‍♀️", "🧜🏽‍♂", "🧜🏽‍♂️", "🧜🏾‍♀",
+      "🧜🏾‍♀️", "🧜🏾‍♂", "🧜🏾‍♂️", "🧜🏿‍♀", "🧜🏿‍♀️",
+      "🧜🏿‍♂", "🧜🏿‍♂️", "🧝‍♀", "🧝‍♀️", "🧝‍♂", "🧝‍♂️",
+      "🧝🏻‍♀", "🧝🏻‍♀️", "🧝🏻‍♂", "🧝🏻‍♂️", "🧝🏼‍♀",
+      "🧝🏼‍♀️", "🧝🏼‍♂", "🧝🏼‍♂️", "🧝🏽‍♀", "🧝🏽‍♀️",
+      "🧝🏽‍♂", "🧝🏽‍♂️", "🧝🏾‍♀", "🧝🏾‍♀️", "🧝🏾‍♂",
+      "🧝🏾‍♂️", "🧝🏿‍♀", "🧝🏿‍♀️", "🧝🏿‍♂", "🧝🏿‍♂️", "🧞‍♀",
+      "🧞‍♀️", "🧞‍♂", "🧞‍♂️", "🧟‍♀", "🧟‍♀️", "🧟‍♂", "🧟‍♂️",
+      "👨‍🦰", "👨‍🦱", "👨‍🦲", "👨‍🦳", "👨🏻‍🦰", "👨🏻‍🦱",
+      "👨🏻‍🦲", "👨🏻‍🦳", "👨🏼‍🦰", "👨🏼‍🦱", "👨🏼‍🦲", "👨🏼‍🦳",
+      "👨🏽‍🦰", "👨🏽‍🦱", "👨🏽‍🦲", "👨🏽‍🦳", "👨🏾‍🦰", "👨🏾‍🦱",
+      "👨🏾‍🦲", "👨🏾‍🦳", "👨🏿‍🦰", "👨🏿‍🦱", "👨🏿‍🦲", "👨🏿‍🦳",
+      "👩‍🦰", "👩‍🦱", "👩‍🦲", "👩‍🦳", "👩🏻‍🦰", "👩🏻‍🦱",
+      "👩🏻‍🦲", "👩🏻‍🦳", "👩🏼‍🦰", "👩🏼‍🦱", "👩🏼‍🦲", "👩🏼‍🦳",
+      "👩🏽‍🦰", "👩🏽‍🦱", "👩🏽‍🦲", "👩🏽‍🦳", "👩🏾‍🦰", "👩🏾‍🦱",
+      "👩🏾‍🦲", "👩🏾‍🦳", "👩🏿‍🦰", "👩🏿‍🦱", "👩🏿‍🦲", "👩🏿‍🦳",
+      "🧑‍🦰", "🧑‍🦱", "🧑‍🦲", "🧑‍🦳", "🧑🏻‍🦰", "🧑🏻‍🦱",
+      "🧑🏻‍🦲", "🧑🏻‍🦳", "🧑🏼‍🦰", "🧑🏼‍🦱", "🧑🏼‍🦲", "🧑🏼‍🦳",
+      "🧑🏽‍🦰", "🧑🏽‍🦱", "🧑🏽‍🦲", "🧑🏽‍🦳", "🧑🏾‍🦰", "🧑🏾‍🦱",
+      "🧑🏾‍🦲", "🧑🏾‍🦳", "🧑🏿‍🦰", "🧑🏿‍🦱", "🧑🏿‍🦲", "🧑🏿‍🦳",
       "❤‍🔥", "❤️‍🔥", "❤‍🩹", "❤️‍🩹", "🏳‍⚧", "🏳️‍⚧️", "🏳‍🌈",
-      "🏳️‍🌈", "🏴‍☠", "🏴‍☠️", "🐈‍⬛", "🐈‍⬛", "🐕‍🦺", "🐕‍🦺",
-      "🐻‍❄", "🐻‍❄️", "👁‍🗨", "👁️‍🗨️", "😮‍💨", "😮‍💨", "😵‍💫",
-      "😵‍💫", "😶‍🌫", "😶‍🌫️", "🧑‍🎄",
+      "🏳️‍🌈", "🏴‍☠", "🏴‍☠️", "🐈‍⬛", "🐕‍🦺", "🐻‍❄", "🐻‍❄️",
+      "👁‍🗨", "👁️‍🗨️", "😮‍💨", "😵‍💫", "😶‍🌫", "😶‍🌫️",
       // comment for clang-format
       "🧑‍🎄"};
   if (str.size() >= 40) {
diff --git a/tdutils/test/misc.cpp b/tdutils/test/misc.cpp
index d822f7244..b5c878ca1 100644
--- a/tdutils/test/misc.cpp
+++ b/tdutils/test/misc.cpp
@@ -1232,4 +1232,6 @@ TEST(Misc, is_emoji) {
   ASSERT_TRUE(!td::is_emoji(" "));
   ASSERT_TRUE(!td::is_emoji(""));
   ASSERT_TRUE(!td::is_emoji("1234567890123456789012345678901234567890123456789012345678901234567890"));
+  ASSERT_TRUE(td::is_emoji("❤️"));
+  ASSERT_TRUE(td::is_emoji("❤"));
 }

From 32713560b8bc63fd530955838fdd43a9fef916fc Mon Sep 17 00:00:00 2001
From: levlam <levlam@telegram.org>
Date: Thu, 18 Nov 2021 15:42:07 +0300
Subject: [PATCH 09/28] Move StackAllocator implementation to cpp.

---
 tdutils/td/utils/StackAllocator.cpp | 57 ++++++++++++++++++++---
 tdutils/td/utils/StackAllocator.h   | 70 ++++++++++-------------------
 2 files changed, 75 insertions(+), 52 deletions(-)

diff --git a/tdutils/td/utils/StackAllocator.cpp b/tdutils/td/utils/StackAllocator.cpp
index d26150820..37a406ba8 100644
--- a/tdutils/td/utils/StackAllocator.cpp
+++ b/tdutils/td/utils/StackAllocator.cpp
@@ -8,12 +8,59 @@
 
 #include "td/utils/port/thread_local.h"
 
-namespace td {
+#include <array>
+#include <cstdlib>
 
-StackAllocator::Impl &StackAllocator::impl() {
-  static TD_THREAD_LOCAL StackAllocator::Impl *impl;  // static zero-initialized
-  init_thread_local<Impl>(impl);
-  return *impl;
+namespace td {
+namespace {
+class ArrayAllocator final : public StackAllocator::AllocatorImpl {
+  static const size_t MEM_SIZE = 1024 * 1024;
+  std::array<char, MEM_SIZE> mem;
+  size_t pos{0};
+
+  MutableSlice allocate(size_t size) final {
+    if (size == 0) {
+      size = 8;
+    } else {
+      if (size > MEM_SIZE) {
+        std::abort();  // too much memory requested
+      }
+      size = (size + 7) & -8;
+    }
+    char *res = mem.data() + pos;
+    pos += size;
+    if (pos > MEM_SIZE) {
+      std::abort();  // memory is over
+    }
+    return {res, size};
+  }
+
+  void free_ptr(char *ptr, size_t size) final {
+    if (size > pos || ptr != mem.data() + (pos - size)) {
+      std::abort();  // shouldn't happen
+    }
+    pos -= size;
+  }
+
+ public:
+  ~ArrayAllocator() final {
+    if (pos != 0) {
+      std::abort();  // shouldn't happen
+    }
+  }
+};
+}  // namespace
+
+StackAllocator::Ptr::~Ptr() {
+  if (!slice_.empty()) {
+    allocator_->free_ptr(slice_.data(), slice_.size());
+  }
+}
+
+StackAllocator::AllocatorImpl *StackAllocator::impl() {
+  static TD_THREAD_LOCAL ArrayAllocator *array_allocator;  // static zero-initialized
+  init_thread_local<ArrayAllocator>(array_allocator);
+  return array_allocator;
 }
 
 }  // namespace td
diff --git a/tdutils/td/utils/StackAllocator.h b/tdutils/td/utils/StackAllocator.h
index 849d90421..dcd6eba20 100644
--- a/tdutils/td/utils/StackAllocator.h
+++ b/tdutils/td/utils/StackAllocator.h
@@ -9,76 +9,52 @@
 #include "td/utils/common.h"
 #include "td/utils/Slice.h"
 
-#include <array>
-#include <cstdlib>
-
 namespace td {
 
 class StackAllocator {
-  // TODO: alloc memory with mmap and unload unused pages
-  // memory still can be corrupted, but it is better than explicit free function
+ public:
+  class AllocatorImpl {
+   public:
+    AllocatorImpl() = default;
+    AllocatorImpl(const AllocatorImpl &) = delete;
+    AllocatorImpl &operator=(const AllocatorImpl &) = delete;
+    AllocatorImpl(AllocatorImpl &&) = delete;
+    AllocatorImpl &operator=(AllocatorImpl &&) = delete;
+    virtual ~AllocatorImpl() = default;
+
+    virtual MutableSlice allocate(size_t size) = 0;
+
+    virtual void free_ptr(char *ptr, size_t size) = 0;
+  };
+
+ private:
   class Ptr {
    public:
-    Ptr(char *ptr, size_t size) : slice_(ptr, size) {
+    Ptr(AllocatorImpl *allocator, size_t size) : allocator_(allocator), slice_(allocator_->allocate(size)) {
     }
     Ptr(const Ptr &other) = delete;
     Ptr &operator=(const Ptr &other) = delete;
-    Ptr(Ptr &&other) noexcept : slice_(other.slice_) {
+    Ptr(Ptr &&other) noexcept : allocator_(other.allocator_), slice_(other.slice_) {
+      other.allocator_ = nullptr;
       other.slice_ = MutableSlice();
     }
     Ptr &operator=(Ptr &&other) = delete;
-    ~Ptr() {
-      if (!slice_.empty()) {
-        free_ptr(slice_.data(), slice_.size());
-      }
-    }
+    ~Ptr();
 
     MutableSlice as_slice() const {
       return slice_;
     }
 
    private:
+    AllocatorImpl *allocator_;
     MutableSlice slice_;
   };
 
-  struct Impl {
-    static const size_t MEM_SIZE = 1024 * 1024;
-    std::array<char, MEM_SIZE> mem;
-
-    size_t pos{0};
-    Ptr alloc(size_t size) {
-      if (size == 0) {
-        size = 8;
-      } else {
-        if (size > MEM_SIZE) {
-          std::abort();  // too much memory requested
-        }
-        size = (size + 7) & -8;
-      }
-      char *res = mem.data() + pos;
-      pos += size;
-      if (pos > MEM_SIZE) {
-        std::abort();  // memory is over
-      }
-      return Ptr(res, size);
-    }
-    void free_ptr(char *ptr, size_t size) {
-      if (size > pos || ptr != mem.data() + (pos - size)) {
-        std::abort();  // shouldn't happen
-      }
-      pos -= size;
-    }
-  };
-
-  static Impl &impl();
-
-  static void free_ptr(char *ptr, size_t size) {
-    impl().free_ptr(ptr, size);
-  }
+  static AllocatorImpl *impl();
 
  public:
   static Ptr alloc(size_t size) {
-    return impl().alloc(size);
+    return Ptr(impl(), size);
   }
 };
 

From 6f3dc2afb13960d2298c779223685540793ea821 Mon Sep 17 00:00:00 2001
From: levlam <levlam@telegram.org>
Date: Thu, 18 Nov 2021 16:22:54 +0300
Subject: [PATCH 10/28] Use new/delete instead of ArrayAllocator on external
 threads.

---
 tdutils/td/utils/StackAllocator.cpp | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/tdutils/td/utils/StackAllocator.cpp b/tdutils/td/utils/StackAllocator.cpp
index 37a406ba8..7a6d655d2 100644
--- a/tdutils/td/utils/StackAllocator.cpp
+++ b/tdutils/td/utils/StackAllocator.cpp
@@ -49,6 +49,19 @@ class ArrayAllocator final : public StackAllocator::AllocatorImpl {
     }
   }
 };
+
+class NewAllocator final : public StackAllocator::AllocatorImpl {
+  MutableSlice allocate(size_t size) final {
+    return {new char[size], size};
+  }
+
+  void free_ptr(char *ptr, size_t size) final {
+    delete[] ptr;
+  }
+
+ public:
+  ~NewAllocator() final = default;
+};
 }  // namespace
 
 StackAllocator::Ptr::~Ptr() {
@@ -58,9 +71,14 @@ StackAllocator::Ptr::~Ptr() {
 }
 
 StackAllocator::AllocatorImpl *StackAllocator::impl() {
-  static TD_THREAD_LOCAL ArrayAllocator *array_allocator;  // static zero-initialized
-  init_thread_local<ArrayAllocator>(array_allocator);
-  return array_allocator;
+  if (get_thread_id() != 0) {
+    static TD_THREAD_LOCAL ArrayAllocator *array_allocator;  // static zero-initialized
+    init_thread_local<ArrayAllocator>(array_allocator);
+    return array_allocator;
+  } else {
+    static NewAllocator new_allocator;
+    return &new_allocator;
+  }
 }
 
 }  // namespace td

From 2b9b9f0c31f3ae5000d90ec53aece079725f4405 Mon Sep 17 00:00:00 2001
From: levlam <levlam@telegram.org>
Date: Thu, 18 Nov 2021 16:25:37 +0300
Subject: [PATCH 11/28] Add ThreadIdGuard to tests and tg_cli.

---
 td/telegram/cli.cpp | 2 ++
 test/crypto.cpp     | 2 ++
 test/main.cpp       | 2 ++
 3 files changed, 6 insertions(+)

diff --git a/td/telegram/cli.cpp b/td/telegram/cli.cpp
index 74574165b..571b1f229 100644
--- a/td/telegram/cli.cpp
+++ b/td/telegram/cli.cpp
@@ -31,6 +31,7 @@
 #include "td/utils/misc.h"
 #include "td/utils/NullLog.h"
 #include "td/utils/OptionParser.h"
+#include "td/utils/port/detail/ThreadIdGuard.h"
 #include "td/utils/port/FileFd.h"
 #include "td/utils/port/PollFlags.h"
 #include "td/utils/port/signals.h"
@@ -4593,6 +4594,7 @@ static void on_log_message(int verbosity_level, const char *message) {
 
 void main(int argc, char **argv) {
   ExitGuard exit_guard;
+  detail::ThreadIdGuard thread_id_guard;
   ignore_signal(SignalType::HangUp).ensure();
   ignore_signal(SignalType::Pipe).ensure();
   set_signal_handler(SignalType::Error, fail_signal).ensure();
diff --git a/test/crypto.cpp b/test/crypto.cpp
index e497cfb18..93eb536d6 100644
--- a/test/crypto.cpp
+++ b/test/crypto.cpp
@@ -11,6 +11,7 @@
 #include "td/utils/common.h"
 #include "td/utils/crypto.h"
 #include "td/utils/logging.h"
+#include "td/utils/port/detail/ThreadIdGuard.h"
 #include "td/utils/ScopeGuard.h"
 #include "td/utils/SharedSlice.h"
 #include "td/utils/Slice.h"
@@ -274,6 +275,7 @@ static HandshakeTest pregenerated_test() {
 }
 
 int main() {
+  td::detail::ThreadIdGuard thread_id_guard;
   auto test = gen_test();
   run_test(test);
   run_test(pregenerated_test());
diff --git a/test/main.cpp b/test/main.cpp
index c6ca5ff80..0bf1e8182 100644
--- a/test/main.cpp
+++ b/test/main.cpp
@@ -8,6 +8,7 @@
 #include "td/utils/crypto.h"
 #include "td/utils/logging.h"
 #include "td/utils/OptionParser.h"
+#include "td/utils/port/detail/ThreadIdGuard.h"
 #include "td/utils/Slice.h"
 #include "td/utils/tests.h"
 
@@ -16,6 +17,7 @@
 #endif
 
 int main(int argc, char **argv) {
+  td::detail::ThreadIdGuard thread_id_guard;
   td::init_openssl_threads();
 
   td::TestsRunner &runner = td::TestsRunner::get_default();

From 42ca2dcef5b17ae15b63b316950673c9abdf94dd Mon Sep 17 00:00:00 2001
From: levlam <levlam@telegram.org>
Date: Thu, 18 Nov 2021 16:32:12 +0300
Subject: [PATCH 12/28] Add serialize test.

---
 tdutils/test/misc.cpp | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/tdutils/test/misc.cpp b/tdutils/test/misc.cpp
index b5c878ca1..5d4084561 100644
--- a/tdutils/test/misc.cpp
+++ b/tdutils/test/misc.cpp
@@ -35,6 +35,7 @@
 #include "td/utils/StringBuilder.h"
 #include "td/utils/tests.h"
 #include "td/utils/Time.h"
+#include "td/utils/tl_helpers.h"
 #include "td/utils/translit.h"
 #include "td/utils/uint128.h"
 #include "td/utils/unicode.h"
@@ -1235,3 +1236,10 @@ TEST(Misc, is_emoji) {
   ASSERT_TRUE(td::is_emoji("❤️"));
   ASSERT_TRUE(td::is_emoji("❤"));
 }
+
+TEST(Misc, serialize) {
+  td::int32 x = 1;
+  ASSERT_EQ(td::base64_encode(td::serialize(x)), td::base64_encode(td::string("\x01\x00\x00\x00", 4)));
+  td::int64 y = -2;
+  ASSERT_EQ(td::base64_encode(td::serialize(y)), td::base64_encode(td::string("\xfe\xff\xff\xff\xff\xff\xff\xff", 8)));
+}

From 67aa9cad667fde122edb4faf5ac5bc96c4b01bce Mon Sep 17 00:00:00 2001
From: levlam <levlam@telegram.org>
Date: Thu, 18 Nov 2021 16:42:01 +0300
Subject: [PATCH 13/28] Allocate exactly specified size in ArrayAllocator.

---
 tdutils/td/utils/StackAllocator.cpp | 12 ++++--------
 1 file changed, 4 insertions(+), 8 deletions(-)

diff --git a/tdutils/td/utils/StackAllocator.cpp b/tdutils/td/utils/StackAllocator.cpp
index 7a6d655d2..68e7c5d70 100644
--- a/tdutils/td/utils/StackAllocator.cpp
+++ b/tdutils/td/utils/StackAllocator.cpp
@@ -19,16 +19,11 @@ class ArrayAllocator final : public StackAllocator::AllocatorImpl {
   size_t pos{0};
 
   MutableSlice allocate(size_t size) final {
-    if (size == 0) {
-      size = 8;
-    } else {
-      if (size > MEM_SIZE) {
-        std::abort();  // too much memory requested
-      }
-      size = (size + 7) & -8;
+    if (size > MEM_SIZE) {
+      std::abort();  // too much memory requested
     }
     char *res = mem.data() + pos;
-    pos += size;
+    pos += (size + 7) & -8;
     if (pos > MEM_SIZE) {
       std::abort();  // memory is over
     }
@@ -36,6 +31,7 @@ class ArrayAllocator final : public StackAllocator::AllocatorImpl {
   }
 
   void free_ptr(char *ptr, size_t size) final {
+    size = (size + 7) & -8;
     if (size > pos || ptr != mem.data() + (pos - size)) {
       std::abort();  // shouldn't happen
     }

From bd733c1c6e620b99c32dd2cf7dbf34fbeaee3374 Mon Sep 17 00:00:00 2001
From: levlam <levlam@telegram.org>
Date: Thu, 18 Nov 2021 17:01:05 +0300
Subject: [PATCH 14/28] Fix CheckExitGuard test.

---
 tdutils/test/misc.cpp | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/tdutils/test/misc.cpp b/tdutils/test/misc.cpp
index 5d4084561..3cfd9885d 100644
--- a/tdutils/test/misc.cpp
+++ b/tdutils/test/misc.cpp
@@ -69,7 +69,6 @@ struct CheckExitGuard {
 
 static CheckExitGuard check_exit_guard_true{true};
 static td::ExitGuard exit_guard;
-static CheckExitGuard check_exit_guard_false{false};
 
 #if TD_LINUX || TD_DARWIN
 TEST(Misc, update_atime_saves_mtime) {
@@ -1243,3 +1242,7 @@ TEST(Misc, serialize) {
   td::int64 y = -2;
   ASSERT_EQ(td::base64_encode(td::serialize(y)), td::base64_encode(td::string("\xfe\xff\xff\xff\xff\xff\xff\xff", 8)));
 }
+
+TEST(Misc, check_reset_guard) {
+  CheckExitGuard check_exit_guard{false};
+}

From 505fed00bd1577bb50faa639b3feaee4c59327a2 Mon Sep 17 00:00:00 2001
From: Sebastian <sebix@sebix.at>
Date: Thu, 18 Nov 2021 12:39:02 +0100
Subject: [PATCH 15/28] Update python example: Use sys.exit for quitting

automatically sends the message to `stderr` and sets the exit-code to 1
`quit` is only for exiting the interpreter, use the recommended `sys.exit`
---
 example/python/tdjson_example.py | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

diff --git a/example/python/tdjson_example.py b/example/python/tdjson_example.py
index 62aaed502..7c8f350e2 100644
--- a/example/python/tdjson_example.py
+++ b/example/python/tdjson_example.py
@@ -13,8 +13,7 @@ import sys
 # load shared library
 tdjson_path = find_library('tdjson') or 'tdjson.dll'
 if tdjson_path is None:
-    print('can\'t find tdjson library')
-    quit()
+    sys.exit("Can't find 'tdjson' library")
 tdjson = CDLL(tdjson_path)
 
 # load TDLib functions from shared library
@@ -43,8 +42,7 @@ _td_set_log_message_callback.argtypes = [c_int, log_message_callback_type]
 # initialize TDLib log with desired parameters
 def on_log_message_callback(verbosity_level, message):
     if verbosity_level == 0:
-        print('TDLib fatal error: ', message)
-        sys.stdout.flush()
+        sys.exit('TDLib fatal error: %r' % message)
 
 def td_execute(query):
     query = json.dumps(query).encode('utf-8')

From 655896ad4aeccbec56daba677428a31ba9b6515c Mon Sep 17 00:00:00 2001
From: levlam <levlam@telegram.org>
Date: Fri, 19 Nov 2021 16:03:23 +0300
Subject: [PATCH 16/28] Update default value of chat_read_mark_size_threshold.

---
 td/telegram/MessagesManager.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/td/telegram/MessagesManager.cpp b/td/telegram/MessagesManager.cpp
index ae1af1bfa..e83c91ecb 100644
--- a/td/telegram/MessagesManager.cpp
+++ b/td/telegram/MessagesManager.cpp
@@ -17316,7 +17316,7 @@ Status MessagesManager::can_get_message_viewers(DialogId dialog_id, const Messag
   if (participant_count == 0) {
     return Status::Error(400, "Chat is empty or have unknown number of members");
   }
-  if (participant_count > G()->shared_config().get_option_integer("chat_read_mark_size_threshold", 50)) {
+  if (participant_count > G()->shared_config().get_option_integer("chat_read_mark_size_threshold", 100)) {
     return Status::Error(400, "Chat is too big");
   }
 

From bb0f7e012dd95780a4874ff0e39c332c4e1315bf Mon Sep 17 00:00:00 2001
From: levlam <levlam@telegram.org>
Date: Fri, 19 Nov 2021 16:15:37 +0300
Subject: [PATCH 17/28] Fix can_get_message_viewers for anonymous polls.

---
 td/telegram/MessageContent.cpp  | 9 +++++++++
 td/telegram/MessageContent.h    | 2 ++
 td/telegram/MessagesManager.cpp | 5 +++++
 3 files changed, 16 insertions(+)

diff --git a/td/telegram/MessageContent.cpp b/td/telegram/MessageContent.cpp
index bf02834b7..f529b0707 100644
--- a/td/telegram/MessageContent.cpp
+++ b/td/telegram/MessageContent.cpp
@@ -2849,6 +2849,15 @@ int32 get_message_content_live_location_period(const MessageContent *content) {
   }
 }
 
+bool get_message_content_poll_is_anonymous(const Td *td, const MessageContent *content) {
+  switch (content->get_type()) {
+    case MessageContentType::Poll:
+      return td->poll_manager_->get_poll_is_anonymous(static_cast<const MessagePoll *>(content)->poll_id);
+    default:
+      return false;
+  }
+}
+
 bool get_message_content_poll_is_closed(const Td *td, const MessageContent *content) {
   switch (content->get_type()) {
     case MessageContentType::Poll:
diff --git a/td/telegram/MessageContent.h b/td/telegram/MessageContent.h
index c911cefbd..411c92527 100644
--- a/td/telegram/MessageContent.h
+++ b/td/telegram/MessageContent.h
@@ -147,6 +147,8 @@ UserId get_message_content_deleted_user_id(const MessageContent *content);
 
 int32 get_message_content_live_location_period(const MessageContent *content);
 
+bool get_message_content_poll_is_anonymous(const Td *td, const MessageContent *content);
+
 bool get_message_content_poll_is_closed(const Td *td, const MessageContent *content);
 
 bool has_message_content_web_page(const MessageContent *content);
diff --git a/td/telegram/MessagesManager.cpp b/td/telegram/MessagesManager.cpp
index e83c91ecb..7008ea894 100644
--- a/td/telegram/MessagesManager.cpp
+++ b/td/telegram/MessagesManager.cpp
@@ -17280,6 +17280,7 @@ Status MessagesManager::can_get_message_viewers(DialogId dialog_id, const Messag
   if (td_->auth_manager_->is_bot()) {
     return Status::Error(400, "User is bot");
   }
+  CHECK(m != nullptr);
   if (!m->is_outgoing) {
     return Status::Error(400, "Can't get viewers of incoming messages");
   }
@@ -17331,6 +17332,10 @@ Status MessagesManager::can_get_message_viewers(DialogId dialog_id, const Messag
   }
   CHECK(m->message_id.is_server());
 
+  if (m->content->get_type() == MessageContentType::Poll &&
+      get_message_content_poll_is_anonymous(td_, m->content.get())) {
+  }
+
   return Status::OK();
 }
 

From a58b4dc302b1f5cb0005082bb2a35987bedba205 Mon Sep 17 00:00:00 2001
From: levlam <levlam@telegram.org>
Date: Fri, 19 Nov 2021 17:56:51 +0300
Subject: [PATCH 18/28] Fix misprint in documentation.

---
 td/generate/scheme/td_api.tl | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/td/generate/scheme/td_api.tl b/td/generate/scheme/td_api.tl
index 240ef0ad2..4809a09d5 100644
--- a/td/generate/scheme/td_api.tl
+++ b/td/generate/scheme/td_api.tl
@@ -586,7 +586,7 @@ chatInviteLinks total_count:int32 invite_links:vector<chatInviteLink> = ChatInvi
 //@revoked_invite_link_count Number of revoked invite links
 chatInviteLinkCount user_id:int53 invite_link_count:int32 revoked_invite_link_count:int32 = ChatInviteLinkCount;
 
-//@description Contains a list of chat invite link counts @invite_link_counts List of invite linkcounts
+//@description Contains a list of chat invite link counts @invite_link_counts List of invite link counts
 chatInviteLinkCounts invite_link_counts:vector<chatInviteLinkCount> = ChatInviteLinkCounts;
 
 //@description Describes a chat member joined a chat by an invite link @user_id User identifier @joined_chat_date Point in time (Unix timestamp) when the user joined the chat @approver_user_id User identifier of the chat administrator, approved user join request

From 3272888be1b8b9a01c3d895df1483f8dea1ce993 Mon Sep 17 00:00:00 2001
From: Mammad <67197540+Mammad900@users.noreply.github.com>
Date: Sat, 20 Nov 2021 18:44:08 +0330
Subject: [PATCH 19/28] Improve appearance of build instructions generator
 (#1689)

---
 build.html | 241 +++++++++++++++++++++++++++++++++++++++++++++++++----
 1 file changed, 227 insertions(+), 14 deletions(-)

diff --git a/build.html b/build.html
index cd2770703..546b32c3c 100644
--- a/build.html
+++ b/build.html
@@ -2,18 +2,208 @@
 <html>
 
 <head>
-<title>TDLib build instructions</title>
-<style>
-.hide { display: none; }
-div.main { max-width:1200px; margin: auto; font-size: x-large; }
-select.large { font-size: large; }
-</style>
+    <title>TDLib build instructions</title>
+    <style>
+        :root {
+            --background: #fafafa;
+            --color: black;
+            --color-primary: #0088ff;
+            --color-code-block: #ebf9ff;
+            --color-select-border: rgb(211, 211, 211);
+            --color-checkbox-background: rgb(211, 211, 211);
+            --color-checkbox-tick: #ffffff;
+            --color-copy-success-background: #c1ffc6;
+            --color-copy-success-border: rgb(0, 255, 0);
+            --color-copy-fail-background: #ffcbcb;
+            --color-copy-fail-border: rgb(255, 0, 0);
+            --color-copy-warning: orange;
+
+            color: var(--color);
+            background: var(--background);
+        }
+        @media (prefers-color-scheme: dark) {
+            :root {
+                --background: #0e0e0e;
+                --color: rgb(190, 190, 190);
+                --color-primary: #0088ff;
+                --color-code-block: #101315;
+                --color-select-border: rgb(54, 54, 54);
+                --color-checkbox-background: rgb(51, 51, 51);
+                --color-checkbox-tick: #ffffff;
+                --color-copy-success-background: #001f00;
+                --color-copy-success-border: rgb(0, 255, 0);
+                --color-copy-fail-background: #1f0000;
+                --color-copy-fail-border: rgb(255, 0, 0);
+            }
+        }
+        body {
+            font-family: 'Segoe UI', Arial, Helvetica, sans-serif;
+        }
+        :focus {
+            outline: none;
+        }
+        .hide { 
+            display: none; 
+        }
+        div.main { 
+            max-width: 1250px; 
+            padding: 25px;
+            margin: auto; 
+            font-size: 16px; 
+        }
+
+        p {
+            margin: 0;
+        }
+        .main > div {
+            margin-bottom: 20px;
+        }
+
+        #buildCommands {
+            font-family: Consolas, monospace;
+            margin-left: 40px;
+            background: var(--color-code-block);
+            padding: 5px;
+            margin-bottom: 0;
+            display: block;
+        }
+        #buildCommands ul {
+          list-style: none;
+        }
+        #buildCommands ul li::before {
+          content: "$"; 
+          color: var(--color-copy-warning);
+          font-weight: bold;
+          display: inline-block;
+          width: 1em;
+          margin-left: -1em;
+            opacity: .4;
+        }
+
+        a {
+            color: var(--color-primary);
+            text-decoration-color: transparent;
+            transition: text-decoration-color 200ms;
+        }
+        a:hover {
+            text-decoration: underline;
+        }
+        select, button {
+            border: 1px solid var(--color-select-border);
+            background-color: var(--background);
+            color: var(--color);
+            padding: 5px;
+            margin-top: 5px;
+            transition: border 200ms, padding 200ms;
+            border-radius: 999em;
+            font-size: 16px; 
+            cursor: pointer;
+        }
+
+        select:focus, button:focus {
+            border-color: var(--color-primary);
+            border-width: 2px;
+            padding: 4px;
+        }
+
+        label * {
+            vertical-align: middle;
+        }
+
+        input[type=checkbox] {
+            margin-right: 5px;
+            appearance: none;
+            -webkit-appearance: none;
+            -moz-appearance: none;
+            background-color: var(--color-checkbox-background);
+            height: 20px;
+            width: 20px;
+            border-radius: 3px;
+            position: relative;
+            transition: background-color 200ms;
+        }
+        input[type=checkbox]::after {
+            content: "";
+            transition: border-color 200ms;
+            position: absolute;
+            left: 6px;
+            top: 2px;
+            width: 5px;
+            height: 10px;
+            border: solid transparent;
+            border-width: 0 3px 3px 0;
+            -webkit-transform: rotate(45deg);
+            -ms-transform: rotate(45deg);
+            transform: rotate(45deg);
+        }
+        input[type=checkbox]:checked {
+            background-color: var(--color-primary);
+        }
+        input[type=checkbox]:checked::after {
+            border-color: var(--color-checkbox-tick);
+        }
+
+        input[type=radio] {
+            margin-right: 5px;
+            appearance: none;
+            -webkit-appearance: none;
+            -moz-appearance: none;
+            background-color: var(--color-checkbox-background);
+            height: 20px;
+            width: 20px;
+            border-radius: 100%;
+            position: relative;
+            transition: background-color 200ms;
+        }
+        input[type=radio]::after {
+            content: "";
+            transition: border-color 200ms;
+            position: absolute;
+            left: 10px;
+            top: 10px;
+            width: 0;
+            height: 0;
+            border-radius: 100%;
+            background-color: transparent;
+            transition: width 200ms, height 200ms, left 200ms, top 200ms, background-color 100ms;
+        }
+        input[type=radio]:checked::after {
+            background-color: var(--color-primary);
+            left: 2px;
+            top: 2px;
+            width: 16px;
+            height: 16px;
+        }
+
+        #copyBuildCommandsButton {
+          margin-left: 40px;
+        }
+        #copyBuildCommandsButton.success {
+          background: var(--color-copy-success-background);
+          border-color: var(--color-copy-success-border);
+        }
+        #copyBuildCommandsButton.fail {
+          background: var(--color-copy-fail-background);
+          border-color: var(--color-copy-fail-border);
+        }
+        #copyBuildCommandsButton .notice {
+          font-size: 14px;
+          font-weight: bold;
+          margin-left: 5px;
+          color: var(--color-copy-warning);
+          display: none;
+        }
+        #copyBuildCommandsButton:hover .notice,
+        #copyBuildCommandsButton:focus .notice {
+          display: inline;
+        }
+    </style>
 </head>
 
 <body onload="onLoad(true)" onpopstate="onLoad(false)">
 
 <div class="main">
-  <div id="languageSelectDiv" style="text-align:center;">
+  <div id="languageSelectDiv">
     <p>Choose a programming language, from which you want to use TDLib:</p>
     <select id="languageSelect" onchange="onLanguageChanged(false)" autofocus class="large">
       <option>Choose a programming language:</option>
@@ -44,7 +234,7 @@ select.large { font-size: large; }
     </select>
   </div>
 
-  <div id="osSelectDiv" class="hide" style="text-align:center;">
+  <div id="osSelectDiv" class="hide">
     <p>Choose an operating system, on which you want to use TDLib:</p>
     <select id="osSelect" onchange="onOsChanged()" class="large">
       <option>Choose an operating system:</option>
@@ -52,7 +242,7 @@ select.large { font-size: large; }
     <p></p>
   </div>
 
-  <div id="linuxSelectDiv" class="hide" style="text-align:center;">
+  <div id="linuxSelectDiv" class="hide">
     <p>Choose a Linux distro, on which you want to use TDLib:</p>
     <select id="linuxSelect" onchange="onOsChanged()" class="large">
       <option>Choose a Linux distro:</option>
@@ -71,7 +261,7 @@ select.large { font-size: large; }
     <p></p>
   </div>
 
-  <div id="buildOptionsDiv" class="hide" style="text-align:center;">
+  <div id="buildOptionsDiv" class="hide">
     <div id="buildLtoDiv" class="hide">
       <label><input type="checkbox" id="buildLtoCheckbox" onchange="onOptionsChanged()"/>Enable Link Time Optimization (requires CMake >= 3.9.0). It can significantly reduce binary size and increase performance, but sometimes it can lead to build failures.</label>
     </div>
@@ -133,14 +323,18 @@ select.large { font-size: large; }
     <p></p>
   </div>
 
-  <div id="buildTextDiv" class="hide" style="text-align:center;">
+  <div id="buildTextDiv" class="hide">
     <p id="buildText">Hidden text</p>
   </div>
 
-  <div id="buildCommandsDiv" class="hide" style="text-align:left;">
-    <p id="buildCommandsHeader" style="text-align:center;">Here is complete instruction for TDLib binaries building:</p>
+  <div id="buildCommandsDiv" class="hide">
+    <p id="buildCommandsHeader">Here is complete instruction for TDLib binaries building:</p>
     <p id="buildPre">Hidden text</p>
     <code id="buildCommands">Empty commands</code>
+    <button id="copyBuildCommandsButton" onclick="copyBuildInstructions()">
+        <span id="copyBuildCommandsText">Copy</span>
+        <span class="notice">Notice: Not all build instructions can be just copied and pasted</span>
+    </button>
   </div>
 </div>
 
@@ -902,7 +1096,26 @@ function onOptionsChanged() {
     }
     commands.push((use_powershell ? 'dir ' : 'ls -l ') + install_dir);
   }
-  document.getElementById('buildCommands').innerHTML = '<ul><li>' + commands.join('</li><li>') + '</li></ul>';
+  document.getElementById('buildCommands').innerHTML = '<ul><li>' + commands.join('</li><li>') + '</li></ul>'
+}
+
+function copyBuildInstructions() {
+  var text= document.getElementById('buildCommands').innerText;
+
+  function resetButtonState (state) {
+    document.getElementById('copyBuildCommandsButton').classList.remove(state);
+    document.getElementById('copyBuildCommandsText').innerText= "Copy"
+  }
+  
+  navigator.clipboard.writeText(text).then(result => {
+    document.getElementById('copyBuildCommandsButton').classList.add('success');
+    document.getElementById('copyBuildCommandsText').innerText= "Copied!"
+    setTimeout(()=> resetButtonState('success'), 5000);
+  }, error => {
+    document.getElementById('copyBuildCommandsButton').classList.add('fail');
+    document.getElementById('copyBuildCommandsText').innerText= "Couldn't copy :("
+    setTimeout(()=> resetButtonState('fail'), 5000);
+  })
 }
 
 </script>

From ece3a9bbcdabc42fb1d77420ddba5813fc858e11 Mon Sep 17 00:00:00 2001
From: levlam <levlam@telegram.org>
Date: Sat, 20 Nov 2021 18:16:28 +0300
Subject: [PATCH 20/28] Remove trailing spaces and use consictent indent size
 in build.html.

---
 build.html | 390 ++++++++++++++++++++++++++---------------------------
 1 file changed, 195 insertions(+), 195 deletions(-)

diff --git a/build.html b/build.html
index 546b32c3c..ce1b9e64d 100644
--- a/build.html
+++ b/build.html
@@ -2,202 +2,202 @@
 <html>
 
 <head>
-    <title>TDLib build instructions</title>
-    <style>
-        :root {
-            --background: #fafafa;
-            --color: black;
-            --color-primary: #0088ff;
-            --color-code-block: #ebf9ff;
-            --color-select-border: rgb(211, 211, 211);
-            --color-checkbox-background: rgb(211, 211, 211);
-            --color-checkbox-tick: #ffffff;
-            --color-copy-success-background: #c1ffc6;
-            --color-copy-success-border: rgb(0, 255, 0);
-            --color-copy-fail-background: #ffcbcb;
-            --color-copy-fail-border: rgb(255, 0, 0);
-            --color-copy-warning: orange;
+  <title>TDLib build instructions</title>
+  <style>
+    :root {
+      --background: #fafafa;
+      --color: black;
+      --color-primary: #0088ff;
+      --color-code-block: #ebf9ff;
+      --color-select-border: rgb(211, 211, 211);
+      --color-checkbox-background: rgb(211, 211, 211);
+      --color-checkbox-tick: #ffffff;
+      --color-copy-success-background: #c1ffc6;
+      --color-copy-success-border: rgb(0, 255, 0);
+      --color-copy-fail-background: #ffcbcb;
+      --color-copy-fail-border: rgb(255, 0, 0);
+      --color-copy-warning: orange;
 
-            color: var(--color);
-            background: var(--background);
-        }
-        @media (prefers-color-scheme: dark) {
-            :root {
-                --background: #0e0e0e;
-                --color: rgb(190, 190, 190);
-                --color-primary: #0088ff;
-                --color-code-block: #101315;
-                --color-select-border: rgb(54, 54, 54);
-                --color-checkbox-background: rgb(51, 51, 51);
-                --color-checkbox-tick: #ffffff;
-                --color-copy-success-background: #001f00;
-                --color-copy-success-border: rgb(0, 255, 0);
-                --color-copy-fail-background: #1f0000;
-                --color-copy-fail-border: rgb(255, 0, 0);
-            }
-        }
-        body {
-            font-family: 'Segoe UI', Arial, Helvetica, sans-serif;
-        }
-        :focus {
-            outline: none;
-        }
-        .hide { 
-            display: none; 
-        }
-        div.main { 
-            max-width: 1250px; 
-            padding: 25px;
-            margin: auto; 
-            font-size: 16px; 
-        }
+      color: var(--color);
+      background: var(--background);
+    }
+    @media (prefers-color-scheme: dark) {
+      :root {
+        --background: #0e0e0e;
+        --color: rgb(190, 190, 190);
+        --color-primary: #0088ff;
+        --color-code-block: #101315;
+        --color-select-border: rgb(54, 54, 54);
+        --color-checkbox-background: rgb(51, 51, 51);
+        --color-checkbox-tick: #ffffff;
+        --color-copy-success-background: #001f00;
+        --color-copy-success-border: rgb(0, 255, 0);
+        --color-copy-fail-background: #1f0000;
+        --color-copy-fail-border: rgb(255, 0, 0);
+      }
+    }
+    body {
+      font-family: 'Segoe UI', Arial, Helvetica, sans-serif;
+    }
+    :focus {
+      outline: none;
+    }
+    .hide {
+      display: none;
+    }
+    div.main {
+      max-width: 1250px;
+      padding: 25px;
+      margin: auto;
+      font-size: 16px;
+    }
 
-        p {
-            margin: 0;
-        }
-        .main > div {
-            margin-bottom: 20px;
-        }
+    p {
+      margin: 0;
+    }
+    .main > div {
+      margin-bottom: 20px;
+    }
 
-        #buildCommands {
-            font-family: Consolas, monospace;
-            margin-left: 40px;
-            background: var(--color-code-block);
-            padding: 5px;
-            margin-bottom: 0;
-            display: block;
-        }
-        #buildCommands ul {
-          list-style: none;
-        }
-        #buildCommands ul li::before {
-          content: "$"; 
-          color: var(--color-copy-warning);
-          font-weight: bold;
-          display: inline-block;
-          width: 1em;
-          margin-left: -1em;
-            opacity: .4;
-        }
+    #buildCommands {
+      font-family: Consolas, monospace;
+      margin-left: 40px;
+      background: var(--color-code-block);
+      padding: 5px;
+      margin-bottom: 0;
+      display: block;
+    }
+    #buildCommands ul {
+      list-style: none;
+    }
+    #buildCommands ul li::before {
+      content: "$";
+      color: var(--color-copy-warning);
+      font-weight: bold;
+      display: inline-block;
+      width: 1em;
+      margin-left: -1em;
+      opacity: .4;
+    }
 
-        a {
-            color: var(--color-primary);
-            text-decoration-color: transparent;
-            transition: text-decoration-color 200ms;
-        }
-        a:hover {
-            text-decoration: underline;
-        }
-        select, button {
-            border: 1px solid var(--color-select-border);
-            background-color: var(--background);
-            color: var(--color);
-            padding: 5px;
-            margin-top: 5px;
-            transition: border 200ms, padding 200ms;
-            border-radius: 999em;
-            font-size: 16px; 
-            cursor: pointer;
-        }
+    a {
+      color: var(--color-primary);
+      text-decoration-color: transparent;
+      transition: text-decoration-color 200ms;
+    }
+    a:hover {
+      text-decoration: underline;
+    }
+    select, button {
+      border: 1px solid var(--color-select-border);
+      background-color: var(--background);
+      color: var(--color);
+      padding: 5px;
+      margin-top: 5px;
+      transition: border 200ms, padding 200ms;
+      border-radius: 999em;
+      font-size: 16px;
+      cursor: pointer;
+    }
 
-        select:focus, button:focus {
-            border-color: var(--color-primary);
-            border-width: 2px;
-            padding: 4px;
-        }
+    select:focus, button:focus {
+      border-color: var(--color-primary);
+      border-width: 2px;
+      padding: 4px;
+    }
 
-        label * {
-            vertical-align: middle;
-        }
+    label * {
+      vertical-align: middle;
+    }
 
-        input[type=checkbox] {
-            margin-right: 5px;
-            appearance: none;
-            -webkit-appearance: none;
-            -moz-appearance: none;
-            background-color: var(--color-checkbox-background);
-            height: 20px;
-            width: 20px;
-            border-radius: 3px;
-            position: relative;
-            transition: background-color 200ms;
-        }
-        input[type=checkbox]::after {
-            content: "";
-            transition: border-color 200ms;
-            position: absolute;
-            left: 6px;
-            top: 2px;
-            width: 5px;
-            height: 10px;
-            border: solid transparent;
-            border-width: 0 3px 3px 0;
-            -webkit-transform: rotate(45deg);
-            -ms-transform: rotate(45deg);
-            transform: rotate(45deg);
-        }
-        input[type=checkbox]:checked {
-            background-color: var(--color-primary);
-        }
-        input[type=checkbox]:checked::after {
-            border-color: var(--color-checkbox-tick);
-        }
+    input[type=checkbox] {
+      margin-right: 5px;
+      appearance: none;
+      -webkit-appearance: none;
+      -moz-appearance: none;
+      background-color: var(--color-checkbox-background);
+      height: 20px;
+      width: 20px;
+      border-radius: 3px;
+      position: relative;
+      transition: background-color 200ms;
+    }
+    input[type=checkbox]::after {
+      content: "";
+      transition: border-color 200ms;
+      position: absolute;
+      left: 6px;
+      top: 2px;
+      width: 5px;
+      height: 10px;
+      border: solid transparent;
+      border-width: 0 3px 3px 0;
+      -webkit-transform: rotate(45deg);
+      -ms-transform: rotate(45deg);
+      transform: rotate(45deg);
+    }
+    input[type=checkbox]:checked {
+      background-color: var(--color-primary);
+    }
+    input[type=checkbox]:checked::after {
+      border-color: var(--color-checkbox-tick);
+    }
 
-        input[type=radio] {
-            margin-right: 5px;
-            appearance: none;
-            -webkit-appearance: none;
-            -moz-appearance: none;
-            background-color: var(--color-checkbox-background);
-            height: 20px;
-            width: 20px;
-            border-radius: 100%;
-            position: relative;
-            transition: background-color 200ms;
-        }
-        input[type=radio]::after {
-            content: "";
-            transition: border-color 200ms;
-            position: absolute;
-            left: 10px;
-            top: 10px;
-            width: 0;
-            height: 0;
-            border-radius: 100%;
-            background-color: transparent;
-            transition: width 200ms, height 200ms, left 200ms, top 200ms, background-color 100ms;
-        }
-        input[type=radio]:checked::after {
-            background-color: var(--color-primary);
-            left: 2px;
-            top: 2px;
-            width: 16px;
-            height: 16px;
-        }
+    input[type=radio] {
+      margin-right: 5px;
+      appearance: none;
+      -webkit-appearance: none;
+      -moz-appearance: none;
+      background-color: var(--color-checkbox-background);
+      height: 20px;
+      width: 20px;
+      border-radius: 100%;
+      position: relative;
+      transition: background-color 200ms;
+    }
+    input[type=radio]::after {
+      content: "";
+      transition: border-color 200ms;
+      position: absolute;
+      left: 10px;
+      top: 10px;
+      width: 0;
+      height: 0;
+      border-radius: 100%;
+      background-color: transparent;
+      transition: width 200ms, height 200ms, left 200ms, top 200ms, background-color 100ms;
+    }
+    input[type=radio]:checked::after {
+      background-color: var(--color-primary);
+      left: 2px;
+      top: 2px;
+      width: 16px;
+      height: 16px;
+    }
 
-        #copyBuildCommandsButton {
-          margin-left: 40px;
-        }
-        #copyBuildCommandsButton.success {
-          background: var(--color-copy-success-background);
-          border-color: var(--color-copy-success-border);
-        }
-        #copyBuildCommandsButton.fail {
-          background: var(--color-copy-fail-background);
-          border-color: var(--color-copy-fail-border);
-        }
-        #copyBuildCommandsButton .notice {
-          font-size: 14px;
-          font-weight: bold;
-          margin-left: 5px;
-          color: var(--color-copy-warning);
-          display: none;
-        }
-        #copyBuildCommandsButton:hover .notice,
-        #copyBuildCommandsButton:focus .notice {
-          display: inline;
-        }
-    </style>
+    #copyBuildCommandsButton {
+      margin-left: 40px;
+    }
+    #copyBuildCommandsButton.success {
+      background: var(--color-copy-success-background);
+      border-color: var(--color-copy-success-border);
+    }
+    #copyBuildCommandsButton.fail {
+      background: var(--color-copy-fail-background);
+      border-color: var(--color-copy-fail-border);
+    }
+    #copyBuildCommandsButton .notice {
+      font-size: 14px;
+      font-weight: bold;
+      margin-left: 5px;
+      color: var(--color-copy-warning);
+      display: none;
+    }
+    #copyBuildCommandsButton:hover .notice,
+    #copyBuildCommandsButton:focus .notice {
+      display: inline;
+    }
+  </style>
 </head>
 
 <body onload="onLoad(true)" onpopstate="onLoad(false)">
@@ -1096,25 +1096,25 @@ function onOptionsChanged() {
     }
     commands.push((use_powershell ? 'dir ' : 'ls -l ') + install_dir);
   }
-  document.getElementById('buildCommands').innerHTML = '<ul><li>' + commands.join('</li><li>') + '</li></ul>'
+  document.getElementById('buildCommands').innerHTML = '<ul><li>' + commands.join('</li><li>') + '</li></ul>';
 }
 
 function copyBuildInstructions() {
-  var text= document.getElementById('buildCommands').innerText;
+  var text = document.getElementById('buildCommands').innerText;
 
   function resetButtonState (state) {
     document.getElementById('copyBuildCommandsButton').classList.remove(state);
-    document.getElementById('copyBuildCommandsText').innerText= "Copy"
+    document.getElementById('copyBuildCommandsText').innerText = "Copy";
   }
-  
+
   navigator.clipboard.writeText(text).then(result => {
     document.getElementById('copyBuildCommandsButton').classList.add('success');
-    document.getElementById('copyBuildCommandsText').innerText= "Copied!"
-    setTimeout(()=> resetButtonState('success'), 5000);
+    document.getElementById('copyBuildCommandsText').innerText = "Copied!";
+    setTimeout(() => resetButtonState('success'), 5000);
   }, error => {
     document.getElementById('copyBuildCommandsButton').classList.add('fail');
-    document.getElementById('copyBuildCommandsText').innerText= "Couldn't copy :("
-    setTimeout(()=> resetButtonState('fail'), 5000);
+    document.getElementById('copyBuildCommandsText').innerText = "Couldn't copy :(";
+    setTimeout(() => resetButtonState('fail'), 5000);
   })
 }
 

From 6832b86947e657b5efbd4be8c4757e3829a7bcbb Mon Sep 17 00:00:00 2001
From: levlam <levlam@telegram.org>
Date: Sat, 20 Nov 2021 18:28:17 +0300
Subject: [PATCH 21/28] Use black $ for list style and return back outline on
 focus for mouseless setups.

---
 build.html | 15 ++-------------
 1 file changed, 2 insertions(+), 13 deletions(-)

diff --git a/build.html b/build.html
index ce1b9e64d..6b89c869b 100644
--- a/build.html
+++ b/build.html
@@ -39,9 +39,6 @@
     body {
       font-family: 'Segoe UI', Arial, Helvetica, sans-serif;
     }
-    :focus {
-      outline: none;
-    }
     .hide {
       display: none;
     }
@@ -68,16 +65,7 @@
       display: block;
     }
     #buildCommands ul {
-      list-style: none;
-    }
-    #buildCommands ul li::before {
-      content: "$";
-      color: var(--color-copy-warning);
-      font-weight: bold;
-      display: inline-block;
-      width: 1em;
-      margin-left: -1em;
-      opacity: .4;
+      list-style: '$ ';
     }
 
     a {
@@ -101,6 +89,7 @@
     }
 
     select:focus, button:focus {
+      outline: none;
       border-color: var(--color-primary);
       border-width: 2px;
       padding: 4px;

From 743a30d470d4c36de6864094542e8e21d4fb3979 Mon Sep 17 00:00:00 2001
From: levlam <levlam@telegram.org>
Date: Sat, 20 Nov 2021 18:43:52 +0300
Subject: [PATCH 22/28] Show "Copy" button only if copying of all build
 instructions is possible.

---
 build.html | 14 +-------------
 1 file changed, 1 insertion(+), 13 deletions(-)

diff --git a/build.html b/build.html
index 6b89c869b..3cf8802d6 100644
--- a/build.html
+++ b/build.html
@@ -16,7 +16,6 @@
       --color-copy-success-border: rgb(0, 255, 0);
       --color-copy-fail-background: #ffcbcb;
       --color-copy-fail-border: rgb(255, 0, 0);
-      --color-copy-warning: orange;
 
       color: var(--color);
       background: var(--background);
@@ -175,17 +174,6 @@
       background: var(--color-copy-fail-background);
       border-color: var(--color-copy-fail-border);
     }
-    #copyBuildCommandsButton .notice {
-      font-size: 14px;
-      font-weight: bold;
-      margin-left: 5px;
-      color: var(--color-copy-warning);
-      display: none;
-    }
-    #copyBuildCommandsButton:hover .notice,
-    #copyBuildCommandsButton:focus .notice {
-      display: inline;
-    }
   </style>
 </head>
 
@@ -322,7 +310,6 @@
     <code id="buildCommands">Empty commands</code>
     <button id="copyBuildCommandsButton" onclick="copyBuildInstructions()">
         <span id="copyBuildCommandsText">Copy</span>
-        <span class="notice">Notice: Not all build instructions can be just copied and pasted</span>
     </button>
   </div>
 </div>
@@ -1086,6 +1073,7 @@ function onOptionsChanged() {
     commands.push((use_powershell ? 'dir ' : 'ls -l ') + install_dir);
   }
   document.getElementById('buildCommands').innerHTML = '<ul><li>' + commands.join('</li><li>') + '</li></ul>';
+  document.getElementById('copyBuildCommandsButton').style.display = commands.includes('exit') ? 'none' : 'block';
 }
 
 function copyBuildInstructions() {

From 5e34f0764118332b297626bcad216828a10a3683 Mon Sep 17 00:00:00 2001
From: levlam <levlam@telegram.org>
Date: Sun, 21 Nov 2021 21:29:43 +0300
Subject: [PATCH 23/28] Output original name in telegram_api::to_string.

---
 td/generate/tl_writer_cpp.cpp | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/td/generate/tl_writer_cpp.cpp b/td/generate/tl_writer_cpp.cpp
index 9853d5130..adb9b7e8e 100644
--- a/td/generate/tl_writer_cpp.cpp
+++ b/td/generate/tl_writer_cpp.cpp
@@ -301,6 +301,13 @@ std::string TD_TL_writer_cpp::get_pretty_field_name(std::string field_name) cons
 }
 
 std::string TD_TL_writer_cpp::get_pretty_class_name(std::string class_name) const {
+  if (tl_name != "mtproto_api") {
+    for (std::size_t i = 0; i < class_name.size(); i++) {
+      if (class_name[i] == '_') {
+        class_name[i] = '.';
+      }
+    }
+  }
   return class_name;
 }
 

From a28b5f2fbb70ab35f22cc3d14c03d62d3cd8bccc Mon Sep 17 00:00:00 2001
From: levlam <levlam@telegram.org>
Date: Sun, 21 Nov 2021 21:41:11 +0300
Subject: [PATCH 24/28] Remove explicit verbosity level changes in tests.

---
 tdactor/test/actors_bugs.cpp | 1 -
 tdutils/test/misc.cpp        | 2 --
 test/db.cpp                  | 2 --
 test/http.cpp                | 1 -
 test/mtproto.cpp             | 2 --
 test/secret.cpp              | 1 -
 test/tdclient.cpp            | 5 ++---
 7 files changed, 2 insertions(+), 12 deletions(-)

diff --git a/tdactor/test/actors_bugs.cpp b/tdactor/test/actors_bugs.cpp
index aaa1252ad..8d6f3c468 100644
--- a/tdactor/test/actors_bugs.cpp
+++ b/tdactor/test/actors_bugs.cpp
@@ -91,7 +91,6 @@ class TimeoutManager final : public td::Actor {
 td::int32 TimeoutManager::count;
 
 TEST(MultiTimeout, Destroy) {
-  SET_VERBOSITY_LEVEL(VERBOSITY_NAME(ERROR));
   td::ConcurrentScheduler sched;
   int threads_n = 0;
   sched.init(threads_n);
diff --git a/tdutils/test/misc.cpp b/tdutils/test/misc.cpp
index 3cfd9885d..5a67f3939 100644
--- a/tdutils/test/misc.cpp
+++ b/tdutils/test/misc.cpp
@@ -72,7 +72,6 @@ static td::ExitGuard exit_guard;
 
 #if TD_LINUX || TD_DARWIN
 TEST(Misc, update_atime_saves_mtime) {
-  SET_VERBOSITY_LEVEL(VERBOSITY_NAME(ERROR));
   td::string name = "test_file";
   td::unlink(name).ignore();
   auto r_file = td::FileFd::open(name, td::FileFd::Read | td::FileFd::Flags::Create | td::FileFd::Flags::Truncate);
@@ -102,7 +101,6 @@ TEST(Misc, update_atime_saves_mtime) {
 }
 
 TEST(Misc, update_atime_change_atime) {
-  SET_VERBOSITY_LEVEL(VERBOSITY_NAME(ERROR));
   td::string name = "test_file";
   td::unlink(name).ignore();
   auto r_file = td::FileFd::open(name, td::FileFd::Read | td::FileFd::Flags::Create | td::FileFd::Flags::Truncate);
diff --git a/test/db.cpp b/test/db.cpp
index b48903950..0d19db8ed 100644
--- a/test/db.cpp
+++ b/test/db.cpp
@@ -340,7 +340,6 @@ class BaselineKV {
 };
 
 TEST(DB, key_value) {
-  SET_VERBOSITY_LEVEL(VERBOSITY_NAME(ERROR));
   std::vector<std::string> keys;
   std::vector<std::string> values;
 
@@ -517,7 +516,6 @@ TEST(DB, persistent_key_value) {
   using KeyValue = BinlogKeyValue<ConcurrentBinlog>;
   // using KeyValue = PersistentKeyValue;
   // using KeyValue = SqliteKV;
-  SET_VERBOSITY_LEVEL(VERBOSITY_NAME(ERROR));
   std::vector<std::string> keys;
   std::vector<std::string> values;
   CSlice path = "test_pmc";
diff --git a/test/http.cpp b/test/http.cpp
index 3696ea2cb..a9be5dffa 100644
--- a/test/http.cpp
+++ b/test/http.cpp
@@ -140,7 +140,6 @@ TEST(Http, reader) {
   return;
 #endif
   clear_thread_locals();
-  SET_VERBOSITY_LEVEL(VERBOSITY_NAME(ERROR));
   auto start_mem = BufferAllocator::get_buffer_mem();
   auto start_size = BufferAllocator::get_buffer_slice_size();
   {
diff --git a/test/mtproto.cpp b/test/mtproto.cpp
index a9a0cb09c..c886f5f60 100644
--- a/test/mtproto.cpp
+++ b/test/mtproto.cpp
@@ -49,7 +49,6 @@
 using namespace td;
 
 TEST(Mtproto, GetHostByNameActor) {
-  SET_VERBOSITY_LEVEL(VERBOSITY_NAME(ERROR));
   ConcurrentScheduler sched;
   int threads_n = 1;
   sched.init(threads_n);
@@ -667,7 +666,6 @@ TEST(Mtproto, Grease) {
 }
 
 TEST(Mtproto, TlsTransport) {
-  SET_VERBOSITY_LEVEL(VERBOSITY_NAME(ERROR));
   ConcurrentScheduler sched;
   int threads_n = 1;
   sched.init(threads_n);
diff --git a/test/secret.cpp b/test/secret.cpp
index 5dd40afb3..4b34d65f2 100644
--- a/test/secret.cpp
+++ b/test/secret.cpp
@@ -1001,7 +1001,6 @@ void FakeSecretChatContext::on_read_message(int64, Promise<> promise) {
 
 TEST(Secret, go) {
   return;
-  SET_VERBOSITY_LEVEL(VERBOSITY_NAME(ERROR));
   ConcurrentScheduler sched;
   int threads_n = 0;
   sched.init(threads_n);
diff --git a/test/tdclient.cpp b/test/tdclient.cpp
index c351e7358..a914c254f 100644
--- a/test/tdclient.cpp
+++ b/test/tdclient.cpp
@@ -828,7 +828,6 @@ class Tdclient_login final : public td::Test {
   using Test::Test;
   bool step() final {
     if (!is_inited_) {
-      SET_VERBOSITY_LEVEL(VERBOSITY_NAME(DEBUG) + 2);
       sched_.init(4);
       sched_.create_actor_unsafe<LoginTestActor>(0, "LoginTestActor", &result_).release();
       sched_.start();
@@ -936,7 +935,7 @@ TEST(Client, Multi) {
 TEST(Client, Manager) {
   td::vector<td::thread> threads;
   td::ClientManager client;
-#if !TD_EVENTFD_UNSUPPORTED // Client must be used from a single thread if there is no EventFd
+#if !TD_EVENTFD_UNSUPPORTED  // Client must be used from a single thread if there is no EventFd
   int threads_n = 4;
 #else
   int threads_n = 1;
@@ -973,7 +972,7 @@ TEST(Client, Manager) {
   }
 }
 
-#if !TD_EVENTFD_UNSUPPORTED // Client must be used from a single thread if there is no EventFd
+#if !TD_EVENTFD_UNSUPPORTED  // Client must be used from a single thread if there is no EventFd
 TEST(Client, Close) {
   std::atomic<bool> stop_send{false};
   std::atomic<bool> can_stop_receive{false};

From cee41e080695d82388e0124f38dec0e186434b3f Mon Sep 17 00:00:00 2001
From: levlam <levlam@telegram.org>
Date: Sun, 21 Nov 2021 21:51:46 +0300
Subject: [PATCH 25/28] Allow to change tests verbosity level.

---
 test/main.cpp | 20 +++++++++++++++++---
 1 file changed, 17 insertions(+), 3 deletions(-)

diff --git a/test/main.cpp b/test/main.cpp
index 0bf1e8182..68c24dc31 100644
--- a/test/main.cpp
+++ b/test/main.cpp
@@ -6,9 +6,11 @@
 //
 #include "td/utils/common.h"
 #include "td/utils/crypto.h"
+#include "td/utils/ExitGuard.h"
 #include "td/utils/logging.h"
 #include "td/utils/OptionParser.h"
 #include "td/utils/port/detail/ThreadIdGuard.h"
+#include "td/utils/port/stacktrace.h"
 #include "td/utils/Slice.h"
 #include "td/utils/tests.h"
 
@@ -17,22 +19,34 @@
 #endif
 
 int main(int argc, char **argv) {
+  SET_VERBOSITY_LEVEL(VERBOSITY_NAME(FATAL));
+  td::ExitGuard exit_guard;
   td::detail::ThreadIdGuard thread_id_guard;
+  td::Stacktrace::init();
   td::init_openssl_threads();
 
   td::TestsRunner &runner = td::TestsRunner::get_default();
-  SET_VERBOSITY_LEVEL(VERBOSITY_NAME(ERROR));
 
+  int default_verbosity_level = 1;
   td::OptionParser options;
-  options.add_option('f', "filter", "Run only specified tests",
+  options.add_option('f', "filter", "run only specified tests",
                      [&](td::Slice filter) { runner.add_substr_filter(filter.str()); });
-  options.add_option('s', "stress", "Run tests infinitely", [&] { runner.set_stress_flag(true); });
+  options.add_option('s', "stress", "run tests infinitely", [&] { runner.set_stress_flag(true); });
+  options.add_checked_option('v', "verbosity", "log verbosity level",
+                             td::OptionParser::parse_integer(default_verbosity_level));
+  options.add_check([&] {
+    if (default_verbosity_level < 0) {
+      return td::Status::Error("Wrong verbosity level specified");
+    }
+    return td::Status::OK();
+  });
   auto r_non_options = options.run(argc, argv, 0);
   if (r_non_options.is_error()) {
     LOG(PLAIN) << argv[0] << ": " << r_non_options.error().message();
     LOG(PLAIN) << options;
     return 1;
   }
+  SET_VERBOSITY_LEVEL(default_verbosity_level);
 
 #if TD_EMSCRIPTEN
   emscripten_set_main_loop(

From f818d0d5e79450d3670669f6f711e45be7553906 Mon Sep 17 00:00:00 2001
From: levlam <levlam@telegram.org>
Date: Mon, 22 Nov 2021 11:32:36 +0300
Subject: [PATCH 26/28] Simplify close checks in RequestActor.

---
 td/telegram/RequestActor.h | 7 ++-----
 1 file changed, 2 insertions(+), 5 deletions(-)

diff --git a/td/telegram/RequestActor.h b/td/telegram/RequestActor.h
index 6dedd0db4..125fca5c6 100644
--- a/td/telegram/RequestActor.h
+++ b/td/telegram/RequestActor.h
@@ -6,7 +6,6 @@
 //
 #pragma once
 
-#include "td/telegram/AuthManager.h"
 #include "td/telegram/Global.h"
 #include "td/telegram/Td.h"
 #include "td/telegram/td_api.h"
@@ -68,14 +67,12 @@ class RequestActor : public Actor {
     if (future_.is_error()) {
       auto error = future_.move_as_error();
       if (error == Status::Error<FutureActor<T>::HANGUP_ERROR_CODE>()) {
-        // dropping query due to lost authorization or lost promise
+        // dropping query due to closing or lost promise
         if (G()->close_flag()) {
           do_send_error(Global::request_aborted_error());
-        } else if (!td_->auth_manager_->is_authorized()) {
+        } else {
           LOG(ERROR) << "Promise was lost";
           do_send_error(Status::Error(500, "Query can't be answered due to a bug in TDLib"));
-        } else {
-          do_send_error(Status::Error(401, "Unauthorized"));
         }
         return stop();
       }

From 21a7d147f5aceae3b02fbd325ebcbe2ec6637d00 Mon Sep 17 00:00:00 2001
From: levlam <levlam@telegram.org>
Date: Mon, 22 Nov 2021 11:52:09 +0300
Subject: [PATCH 27/28] Ignore 401 from non-main sessions.

---
 td/telegram/net/Session.cpp | 67 +++++++++++++++++++++++++------------
 td/telegram/net/Session.h   | 10 +++---
 2 files changed, 51 insertions(+), 26 deletions(-)

diff --git a/td/telegram/net/Session.cpp b/td/telegram/net/Session.cpp
index 979d39468..901c8ffd7 100644
--- a/td/telegram/net/Session.cpp
+++ b/td/telegram/net/Session.cpp
@@ -143,10 +143,9 @@ bool Session::PriorityQueue::empty() const {
 Session::Session(unique_ptr<Callback> callback, std::shared_ptr<AuthDataShared> shared_auth_data, int32 raw_dc_id,
                  int32 dc_id, bool is_main, bool use_pfs, bool is_cdn, bool need_destroy,
                  const mtproto::AuthKey &tmp_auth_key, const vector<mtproto::ServerSalt> &server_salts)
-    : raw_dc_id_(raw_dc_id), dc_id_(dc_id), is_main_(is_main), is_cdn_(is_cdn) {
-  VLOG(dc) << "Start connection " << tag("need_destroy", need_destroy);
-  need_destroy_ = need_destroy;
-  if (need_destroy) {
+    : raw_dc_id_(raw_dc_id), dc_id_(dc_id), is_main_(is_main), is_cdn_(is_cdn), need_destroy_(need_destroy) {
+  VLOG(dc) << "Start connection " << tag("need_destroy", need_destroy_);
+  if (need_destroy_) {
     use_pfs = false;
     CHECK(!is_cdn);
   }
@@ -790,21 +789,38 @@ void Session::on_message_result_error(uint64 id, int error_code, string message)
 
   // UNAUTHORIZED
   if (error_code == 401 && message != "SESSION_PASSWORD_NEEDED") {
-    if (auth_data_.use_pfs() && message == CSlice("AUTH_KEY_PERM_EMPTY")) {
-      LOG(INFO) << "Receive AUTH_KEY_PERM_EMPTY in session " << auth_data_.get_session_id() << " for auth key "
+    if (auth_data_.use_pfs() && (message == CSlice("AUTH_KEY_PERM_EMPTY") || !is_main_)) {
+      LOG(INFO) << "Receive 401, " << message << " in session " << auth_data_.get_session_id() << " for auth key "
                 << auth_data_.get_tmp_auth_key().id();
+      // temporary key can be dropped any time
       auth_data_.drop_tmp_auth_key();
       on_tmp_auth_key_updated();
       error_code = 500;
     } else {
-      if (message == "USER_DEACTIVATED_BAN") {
-        LOG(PLAIN) << "Your account was suspended for suspicious activity. If you think that this is a mistake, please "
-                      "write to recover@telegram.org your phone number and other details to recover the account.";
+      bool can_drop_main_auth_key_without_logging_out = is_cdn_;
+      if (!is_main_) {
+        CHECK(!auth_data_.use_pfs());
+        if (G()->net_query_dispatcher().get_main_dc_id().get_raw_id() != raw_dc_id_) {
+          can_drop_main_auth_key_without_logging_out = true;
+        }
+      }
+      if (can_drop_main_auth_key_without_logging_out) {
+        LOG(INFO) << "Receive 401, " << message << " in session " << auth_data_.get_session_id() << " for auth key "
+                  << auth_data_.get_auth_key().id();
+        auth_data_.drop_main_auth_key();
+        on_auth_key_updated();
+        error_code = 500;
+      } else {
+        if (message == "USER_DEACTIVATED_BAN") {
+          LOG(PLAIN)
+              << "Your account was suspended for suspicious activity. If you think that this is a mistake, please "
+                 "write to recover@telegram.org your phone number and other details to recover the account.";
+        }
+        auth_data_.set_auth_flag(false);
+        G()->shared_config().set_option_string("auth", message);
+        shared_auth_data_->set_auth_key(auth_data_.get_main_auth_key());
+        on_session_failed(Status::OK());
       }
-      auth_data_.set_auth_flag(false);
-      G()->shared_config().set_option_string("auth", message);
-      shared_auth_data_->set_auth_key(auth_data_.get_main_auth_key());
-      on_session_failed(Status::OK());
     }
   }
 
@@ -975,17 +991,23 @@ void Session::connection_send_query(ConnectionInfo *info, NetQueryPtr &&net_quer
     }
   }
 
-  // net_query->debug("Session: send to mtproto::connection");
-  auto r_message_id =
-      info->connection->send_query(net_query->query().clone(), net_query->gzip_flag() == NetQuery::GzipFlag::On,
-                                   message_id, invoke_after_id, static_cast<bool>(net_query->quick_ack_promise_));
+  bool immediately_fail_query = false;
+  if (!immediately_fail_query) {
+    auto r_message_id =
+        info->connection->send_query(net_query->query().clone(), net_query->gzip_flag() == NetQuery::GzipFlag::On,
+                                     message_id, invoke_after_id, static_cast<bool>(net_query->quick_ack_promise_));
 
-  net_query->on_net_write(net_query->query().size());
+    net_query->on_net_write(net_query->query().size());
 
-  if (r_message_id.is_error()) {
-    LOG(FATAL) << "Failed to send query: " << r_message_id.error();
+    if (r_message_id.is_error()) {
+      LOG(FATAL) << "Failed to send query: " << r_message_id.error();
+    }
+    message_id = r_message_id.ok();
+  } else {
+    if (message_id == 0) {
+      message_id = auth_data_.next_message_id(Time::now_cached());
+    }
   }
-  message_id = r_message_id.ok();
   VLOG(net_query) << "Send query to connection " << net_query << " [msg_id:" << format::as_hex(message_id) << "]"
                   << tag("invoke_after", format::as_hex(invoke_after_id));
   net_query->set_message_id(message_id);
@@ -1006,6 +1028,9 @@ void Session::connection_send_query(ConnectionInfo *info, NetQueryPtr &&net_quer
   if (!status.second) {
     LOG(FATAL) << "Duplicate message_id [message_id = " << message_id << "]";
   }
+  if (immediately_fail_query) {
+    on_message_result_error(message_id, 401, "TEST_ERROR");
+  }
 }
 
 void Session::connection_open(ConnectionInfo *info, bool ask_info) {
diff --git a/td/telegram/net/Session.h b/td/telegram/net/Session.h
index c5ff10f10..93ff84e08 100644
--- a/td/telegram/net/Session.h
+++ b/td/telegram/net/Session.h
@@ -102,17 +102,17 @@ class Session final
   // Just re-ask answer_id each time we get information about it.
   // Though mtproto::Connection must ensure delivery of such query.
 
-  int32 raw_dc_id_;
-  int32 dc_id_;
+  int32 raw_dc_id_;  // numerical datacenter ID, i.e. 2
+  int32 dc_id_;      // unique datacenter ID, i.e. -10002
   enum class Mode : int8 { Tcp, Http } mode_ = Mode::Tcp;
-  bool is_main_;
+  bool is_main_;  // true only for the primary Session(s) to the main DC
   bool is_cdn_;
   bool need_destroy_;
   bool was_on_network_ = false;
   bool network_flag_ = false;
-  uint32 network_generation_ = 0;
   bool online_flag_ = false;
   bool connection_online_flag_ = false;
+  uint32 network_generation_ = 0;
   uint64 being_binded_tmp_auth_key_id_ = 0;
   uint64 being_checked_main_auth_key_id_ = 0;
   uint64 last_bind_query_id_ = 0;
@@ -145,7 +145,7 @@ class Session final
     enum class State : int8 { Empty, Connecting, Ready } state = State::Empty;
     CancellationTokenSource cancellation_token_source_;
     unique_ptr<mtproto::SessionConnection> connection;
-    bool ask_info;
+    bool ask_info = false;
     double wakeup_at = 0;
     double created_at = 0;
   };

From 0c554fbe0446339411b9b111e024a83f786558e0 Mon Sep 17 00:00:00 2001
From: levlam <levlam@telegram.org>
Date: Mon, 22 Nov 2021 14:36:59 +0300
Subject: [PATCH 28/28] Unify Session::ConnectionInfo field name style.

---
 td/telegram/net/Session.cpp | 128 ++++++++++++++++++------------------
 td/telegram/net/Session.h   |  14 ++--
 2 files changed, 71 insertions(+), 71 deletions(-)

diff --git a/td/telegram/net/Session.cpp b/td/telegram/net/Session.cpp
index 901c8ffd7..ba0d1e573 100644
--- a/td/telegram/net/Session.cpp
+++ b/td/telegram/net/Session.cpp
@@ -172,8 +172,8 @@ Session::Session(unique_ptr<Callback> callback, std::shared_ptr<AuthDataShared>
 
   callback_ = std::shared_ptr<Callback>(callback.release());
 
-  main_connection_.connection_id = 0;
-  long_poll_connection_.connection_id = 1;
+  main_connection_.connection_id_ = 0;
+  long_poll_connection_.connection_id_ = 1;
 
   if (is_cdn) {
     auth_data_.set_header(G()->mtproto_header().get_anonymous_header().str());
@@ -243,11 +243,11 @@ void Session::connection_online_update(bool force) {
   }
   connection_online_flag_ = new_connection_online_flag;
   VLOG(dc) << "Set connection_online " << connection_online_flag_;
-  if (main_connection_.connection) {
-    main_connection_.connection->set_online(connection_online_flag_, is_main_);
+  if (main_connection_.connection_) {
+    main_connection_.connection_->set_online(connection_online_flag_, is_main_);
   }
-  if (long_poll_connection_.connection) {
-    long_poll_connection_.connection->set_online(connection_online_flag_, is_main_);
+  if (long_poll_connection_.connection_) {
+    long_poll_connection_.connection_->set_online(connection_online_flag_, is_main_);
   }
 }
 
@@ -422,8 +422,8 @@ void Session::raw_event(const Event::Raw &event) {
   return_query(std::move(query));
 
   LOG(DEBUG) << "Drop answer " << tag("message_id", format::as_hex(message_id));
-  if (main_connection_.state == ConnectionInfo::State::Ready) {
-    main_connection_.connection->cancel_answer(message_id);
+  if (main_connection_.state_ == ConnectionInfo::State::Ready) {
+    main_connection_.connection_->cancel_answer(message_id);
   } else {
     to_cancel_.push_back(message_id);
   }
@@ -442,11 +442,11 @@ Status Session::on_pong() {
   constexpr int MAX_QUERY_TIMEOUT = 60;
   constexpr int MIN_CONNECTION_ACTIVE = 60;
   if (current_info_ == &main_connection_ &&
-      Timestamp::at(current_info_->created_at + MIN_CONNECTION_ACTIVE).is_in_past()) {
+      Timestamp::at(current_info_->created_at_ + MIN_CONNECTION_ACTIVE).is_in_past()) {
     Status status;
     if (!unknown_queries_.empty()) {
       status = Status::Error(PSLICE() << "No state info for " << unknown_queries_.size() << " queries for "
-                                      << format::as_time(Time::now_cached() - current_info_->created_at));
+                                      << format::as_time(Time::now_cached() - current_info_->created_at_));
     }
     if (!sent_queries_list_.empty()) {
       for (auto it = sent_queries_list_.prev; it != &sent_queries_list_; it = it->prev) {
@@ -493,16 +493,16 @@ void Session::on_closed(Status status) {
   if (!close_flag_ && is_main_) {
     connection_token_.reset();
   }
-  auto raw_connection = current_info_->connection->move_as_raw_connection();
+  auto raw_connection = current_info_->connection_->move_as_raw_connection();
   Scheduler::unsubscribe_before_close(raw_connection->get_poll_info().get_pollable_fd_ref());
   raw_connection->close();
 
   if (status.is_error()) {
     LOG(WARNING) << "Session with " << sent_queries_.size() << " pending requests was closed: " << status << " "
-                 << current_info_->connection->get_name();
+                 << current_info_->connection_->get_name();
   } else {
     LOG(INFO) << "Session with " << sent_queries_.size() << " pending requests was closed: " << status << " "
-              << current_info_->connection->get_name();
+              << current_info_->connection_->get_name();
   }
 
   if (status.is_error() && status.code() == -404) {
@@ -535,7 +535,7 @@ void Session::on_closed(Status status) {
 
   // resend all queries without ack
   for (auto it = sent_queries_.begin(); it != sent_queries_.end();) {
-    if (!it->second.ack && it->second.connection_id == current_info_->connection_id) {
+    if (!it->second.ack && it->second.connection_id == current_info_->connection_id_) {
       // container vector leak otherwise
       cleanup_container(it->first, &it->second);
 
@@ -549,7 +549,7 @@ void Session::on_closed(Status status) {
         query->set_message_id(0);
         query->cancel_slot_.clear_event();
         query->set_error(Status::Error(500, PSLICE() << "Session failed: " << status.message()),
-                         current_info_->connection->get_name().str());
+                         current_info_->connection_->get_name().str());
         return_query(std::move(query));
         it = sent_queries_.erase(it);
       } else {
@@ -561,8 +561,8 @@ void Session::on_closed(Status status) {
     }
   }
 
-  current_info_->connection.reset();
-  current_info_->state = ConnectionInfo::State::Empty;
+  current_info_->connection_.reset();
+  current_info_->state_ = ConnectionInfo::State::Empty;
 }
 
 void Session::on_session_created(uint64 unique_id, uint64 first_id) {
@@ -846,7 +846,7 @@ void Session::on_message_result_error(uint64 id, int error_code, string message)
 
   cleanup_container(id, query_ptr);
   mark_as_known(id, query_ptr);
-  query_ptr->query->set_error(Status::Error(error_code, message), current_info_->connection->get_name().str());
+  query_ptr->query->set_error(Status::Error(error_code, message), current_info_->connection_->get_name().str());
   query_ptr->query->set_message_id(0);
   query_ptr->query->cancel_slot_.clear_event();
   return_query(std::move(query_ptr->query));
@@ -938,7 +938,7 @@ void Session::on_message_info(uint64 id, int32 state, uint64 answer_id, int32 an
                                   << tag("answer_size", answer_size) << it->second.query;
       it->second.query->debug("Session: resend answer");
     }
-    current_info_->connection->resend_answer(answer_id);
+    current_info_->connection_->resend_answer(answer_id);
   }
 }
 
@@ -970,7 +970,7 @@ void Session::add_query(NetQueryPtr &&net_query) {
 
 void Session::connection_send_query(ConnectionInfo *info, NetQueryPtr &&net_query, uint64 message_id) {
   net_query->debug("Session: trying to send to mtproto::connection");
-  CHECK(info->state == ConnectionInfo::State::Ready);
+  CHECK(info->state_ == ConnectionInfo::State::Ready);
   current_info_ = info;
 
   if (net_query->update_is_ready()) {
@@ -994,8 +994,8 @@ void Session::connection_send_query(ConnectionInfo *info, NetQueryPtr &&net_quer
   bool immediately_fail_query = false;
   if (!immediately_fail_query) {
     auto r_message_id =
-        info->connection->send_query(net_query->query().clone(), net_query->gzip_flag() == NetQuery::GzipFlag::On,
-                                     message_id, invoke_after_id, static_cast<bool>(net_query->quick_ack_promise_));
+        info->connection_->send_query(net_query->query().clone(), net_query->gzip_flag() == NetQuery::GzipFlag::On,
+                                      message_id, invoke_after_id, static_cast<bool>(net_query->quick_ack_promise_));
 
     net_query->on_net_write(net_query->query().size());
 
@@ -1023,7 +1023,7 @@ void Session::connection_send_query(ConnectionInfo *info, NetQueryPtr &&net_quer
     net_query->cancel_slot_.set_event(EventCreator::raw(actor_id(), message_id));
   }
   auto status = sent_queries_.emplace(
-      message_id, Query{message_id, std::move(net_query), main_connection_.connection_id, Time::now_cached()});
+      message_id, Query{message_id, std::move(net_query), main_connection_.connection_id_, Time::now_cached()});
   sent_queries_list_.put(status.first->second.get_list_node());
   if (!status.second) {
     LOG(FATAL) << "Duplicate message_id [message_id = " << message_id << "]";
@@ -1034,16 +1034,16 @@ void Session::connection_send_query(ConnectionInfo *info, NetQueryPtr &&net_quer
 }
 
 void Session::connection_open(ConnectionInfo *info, bool ask_info) {
-  CHECK(info->state == ConnectionInfo::State::Empty);
+  CHECK(info->state_ == ConnectionInfo::State::Empty);
   if (!network_flag_) {
     return;
   }
   if (!auth_data_.has_auth_key(Time::now_cached())) {
     return;
   }
-  info->ask_info = ask_info;
+  info->ask_info_ = ask_info;
 
-  info->state = ConnectionInfo::State::Connecting;
+  info->state_ = ConnectionInfo::State::Connecting;
   info->cancellation_token_source_ = CancellationTokenSource{};
   // NB: rely on constant location of info
   auto promise = PromiseCreator::cancellable_lambda(
@@ -1064,7 +1064,7 @@ void Session::connection_open(ConnectionInfo *info, bool ask_info) {
     callback_->request_raw_connection(std::move(auth_data), std::move(promise));
   }
 
-  info->wakeup_at = Time::now_cached() + 1000;
+  info->wakeup_at_ = Time::now_cached() + 1000;
 }
 
 void Session::connection_add(unique_ptr<mtproto::RawConnection> raw_connection) {
@@ -1074,10 +1074,10 @@ void Session::connection_add(unique_ptr<mtproto::RawConnection> raw_connection)
 }
 
 void Session::connection_check_mode(ConnectionInfo *info) {
-  if (close_flag_ || info->state != ConnectionInfo::State::Ready) {
+  if (close_flag_ || info->state_ != ConnectionInfo::State::Ready) {
     return;
   }
-  if (info->mode != mode_) {
+  if (info->mode_ != mode_) {
     LOG(WARNING) << "Close connection because of outdated mode_";
     connection_close(info);
   }
@@ -1085,14 +1085,14 @@ void Session::connection_check_mode(ConnectionInfo *info) {
 
 void Session::connection_open_finish(ConnectionInfo *info,
                                      Result<unique_ptr<mtproto::RawConnection>> r_raw_connection) {
-  if (close_flag_ || info->state != ConnectionInfo::State::Connecting) {
+  if (close_flag_ || info->state_ != ConnectionInfo::State::Connecting) {
     VLOG(dc) << "Ignore raw connection while closing";
     return;
   }
   current_info_ = info;
   if (r_raw_connection.is_error()) {
     LOG(WARNING) << "Failed to open socket: " << r_raw_connection.error();
-    info->state = ConnectionInfo::State::Empty;
+    info->state_ = ConnectionInfo::State::Empty;
     yield();
     return;
   }
@@ -1101,7 +1101,7 @@ void Session::connection_open_finish(ConnectionInfo *info,
   VLOG(dc) << "Receive raw connection " << raw_connection.get();
   if (raw_connection->extra().extra != network_generation_) {
     LOG(WARNING) << "Got RawConnection with old network_generation";
-    info->state = ConnectionInfo::State::Empty;
+    info->state_ = ConnectionInfo::State::Empty;
     yield();
     return;
   }
@@ -1111,10 +1111,10 @@ void Session::connection_open_finish(ConnectionInfo *info,
   if (mode_ != expected_mode) {
     VLOG(dc) << "Change mode " << mode_ << "--->" << expected_mode;
     mode_ = expected_mode;
-    if (info->connection_id == 1 && mode_ != Mode::Http) {
+    if (info->connection_id_ == 1 && mode_ != Mode::Http) {
       LOG(WARNING) << "Got tcp connection for long poll connection";
       connection_add(std::move(raw_connection));
-      info->state = ConnectionInfo::State::Empty;
+      info->state_ = ConnectionInfo::State::Empty;
       yield();
       return;
     }
@@ -1126,7 +1126,7 @@ void Session::connection_open_finish(ConnectionInfo *info,
     mode = mtproto::SessionConnection::Mode::Tcp;
     mode_name = Slice("Tcp");
   } else {
-    if (info->connection_id == 0) {
+    if (info->connection_id_ == 0) {
       mode = mtproto::SessionConnection::Mode::Http;
       mode_name = Slice("Http");
     } else {
@@ -1136,28 +1136,28 @@ void Session::connection_open_finish(ConnectionInfo *info,
   }
   auto name = PSTRING() << get_name() << "::Connect::" << mode_name << "::" << raw_connection->extra().debug_str;
   LOG(INFO) << "Finished to open connection " << name;
-  info->connection = make_unique<mtproto::SessionConnection>(mode, std::move(raw_connection), &auth_data_);
+  info->connection_ = make_unique<mtproto::SessionConnection>(mode, std::move(raw_connection), &auth_data_);
   if (can_destroy_auth_key()) {
-    info->connection->destroy_key();
+    info->connection_->destroy_key();
   }
-  info->connection->set_online(connection_online_flag_, is_main_);
-  info->connection->set_name(name);
-  Scheduler::subscribe(info->connection->get_poll_info().extract_pollable_fd(this));
-  info->mode = mode_;
-  info->state = ConnectionInfo::State::Ready;
-  info->created_at = Time::now_cached();
-  info->wakeup_at = Time::now_cached() + 10;
+  info->connection_->set_online(connection_online_flag_, is_main_);
+  info->connection_->set_name(name);
+  Scheduler::subscribe(info->connection_->get_poll_info().extract_pollable_fd(this));
+  info->mode_ = mode_;
+  info->state_ = ConnectionInfo::State::Ready;
+  info->created_at_ = Time::now_cached();
+  info->wakeup_at_ = Time::now_cached() + 10;
   if (unknown_queries_.size() > MAX_INFLIGHT_QUERIES) {
     LOG(ERROR) << "With current limits `Too much queries with unknown state` error must be impossible";
     on_session_failed(Status::Error("Too much queries with unknown state"));
     return;
   }
-  if (info->ask_info) {
+  if (info->ask_info_) {
     for (auto &id : unknown_queries_) {
-      info->connection->get_state_info(id);
+      info->connection_->get_state_info(id);
     }
     for (auto &id : to_cancel_) {
-      info->connection->cancel_answer(id);
+      info->connection_->cancel_answer(id);
     }
     to_cancel_.clear();
   }
@@ -1165,18 +1165,18 @@ void Session::connection_open_finish(ConnectionInfo *info,
 }
 
 void Session::connection_flush(ConnectionInfo *info) {
-  CHECK(info->state == ConnectionInfo::State::Ready);
+  CHECK(info->state_ == ConnectionInfo::State::Ready);
   current_info_ = info;
-  info->wakeup_at = info->connection->flush(static_cast<mtproto::SessionConnection::Callback *>(this));
+  info->wakeup_at_ = info->connection_->flush(static_cast<mtproto::SessionConnection::Callback *>(this));
 }
 
 void Session::connection_close(ConnectionInfo *info) {
   current_info_ = info;
-  if (info->state != ConnectionInfo::State::Ready) {
+  if (info->state_ != ConnectionInfo::State::Ready) {
     return;
   }
-  info->connection->force_close(static_cast<mtproto::SessionConnection::Callback *>(this));
-  CHECK(info->state == ConnectionInfo::State::Empty);
+  info->connection_->force_close(static_cast<mtproto::SessionConnection::Callback *>(this));
+  CHECK(info->state_ == ConnectionInfo::State::Empty);
 }
 
 bool Session::need_send_check_main_key() const {
@@ -1191,7 +1191,7 @@ bool Session::connection_send_check_main_key(ConnectionInfo *info) {
   if (key_id == being_checked_main_auth_key_id_) {
     return false;
   }
-  CHECK(info->state != ConnectionInfo::State::Empty);
+  CHECK(info->state_ != ConnectionInfo::State::Empty);
   LOG(INFO) << "Check main key";
   being_checked_main_auth_key_id_ = key_id;
   last_check_query_id_ = UniqueId::next(UniqueId::BindKey);
@@ -1215,7 +1215,7 @@ bool Session::need_send_query() const {
 }
 
 bool Session::connection_send_bind_key(ConnectionInfo *info) {
-  CHECK(info->state != ConnectionInfo::State::Empty);
+  CHECK(info->state_ != ConnectionInfo::State::Empty);
   uint64 key_id = auth_data_.get_tmp_auth_key().id();
   if (key_id == being_binded_tmp_auth_key_id_) {
     return false;
@@ -1228,7 +1228,7 @@ bool Session::connection_send_bind_key(ConnectionInfo *info) {
   auto expires_at = static_cast<int32>(auth_data_.get_server_time(auth_data_.get_tmp_auth_key().expires_at()));
   int64 message_id;
   BufferSlice encrypted;
-  std::tie(message_id, encrypted) = info->connection->encrypted_bind(perm_auth_key_id, nonce, expires_at);
+  std::tie(message_id, encrypted) = info->connection_->encrypted_bind(perm_auth_key_id, nonce, expires_at);
 
   LOG(INFO) << "Bind key: " << tag("tmp", key_id) << tag("perm", static_cast<uint64>(perm_auth_key_id));
   NetQueryPtr query = G()->net_query_creator().create(
@@ -1367,8 +1367,8 @@ void Session::loop() {
   connection_online_update();
 
   double wakeup_at = 0;
-  main_connection_.wakeup_at = 0;
-  long_poll_connection_.wakeup_at = 0;
+  main_connection_.wakeup_at_ = 0;
+  long_poll_connection_.wakeup_at_ = 0;
 
   // NB: order is crucial. First long_poll_connection, then main_connection
   // Otherwise queries could be sent with big delay
@@ -1376,20 +1376,20 @@ void Session::loop() {
   connection_check_mode(&main_connection_);
   connection_check_mode(&long_poll_connection_);
   if (mode_ == Mode::Http) {
-    if (long_poll_connection_.state == ConnectionInfo::State::Ready) {
+    if (long_poll_connection_.state_ == ConnectionInfo::State::Ready) {
       connection_flush(&long_poll_connection_);
     }
-    if (!close_flag_ && long_poll_connection_.state == ConnectionInfo::State::Empty) {
+    if (!close_flag_ && long_poll_connection_.state_ == ConnectionInfo::State::Empty) {
       connection_open(&long_poll_connection_);
     }
-    relax_timeout_at(&wakeup_at, long_poll_connection_.wakeup_at);
+    relax_timeout_at(&wakeup_at, long_poll_connection_.wakeup_at_);
   }
 
-  if (main_connection_.state == ConnectionInfo::State::Ready) {
+  if (main_connection_.state_ == ConnectionInfo::State::Ready) {
     // do not send queries before we have key and e.t.c
     // do not send queries before tmp_key is bound
     bool need_flush = true;
-    while (main_connection_.state == ConnectionInfo::State::Ready) {
+    while (main_connection_.state_ == ConnectionInfo::State::Ready) {
       if (auth_data_.is_ready(Time::now_cached())) {
         if (need_send_query()) {
           while (!pending_queries_.empty() && sent_queries_.size() < MAX_INFLIGHT_QUERIES) {
@@ -1416,11 +1416,11 @@ void Session::loop() {
       }
     }
   }
-  if (!close_flag_ && main_connection_.state == ConnectionInfo::State::Empty) {
+  if (!close_flag_ && main_connection_.state_ == ConnectionInfo::State::Empty) {
     connection_open(&main_connection_, true /*send ask_info*/);
   }
 
-  relax_timeout_at(&wakeup_at, main_connection_.wakeup_at);
+  relax_timeout_at(&wakeup_at, main_connection_.wakeup_at_);
 
   double wakeup_in = 0;
   if (wakeup_at != 0) {
diff --git a/td/telegram/net/Session.h b/td/telegram/net/Session.h
index 93ff84e08..1ad277449 100644
--- a/td/telegram/net/Session.h
+++ b/td/telegram/net/Session.h
@@ -140,14 +140,14 @@ class Session final
   ListNode sent_queries_list_;
 
   struct ConnectionInfo {
-    int8 connection_id = 0;
-    Mode mode = Mode::Tcp;
-    enum class State : int8 { Empty, Connecting, Ready } state = State::Empty;
+    int8 connection_id_ = 0;
+    Mode mode_ = Mode::Tcp;
+    enum class State : int8 { Empty, Connecting, Ready } state_ = State::Empty;
     CancellationTokenSource cancellation_token_source_;
-    unique_ptr<mtproto::SessionConnection> connection;
-    bool ask_info = false;
-    double wakeup_at = 0;
-    double created_at = 0;
+    unique_ptr<mtproto::SessionConnection> connection_;
+    bool ask_info_ = false;
+    double wakeup_at_ = 0;
+    double created_at_ = 0;
   };
 
   ConnectionInfo *current_info_;