From 77164e026381b96612c2fd48caba66e60a8c714e Mon Sep 17 00:00:00 2001 From: Mark Mennell Date: Wed, 2 Sep 2026 14:29:10 +0800 Subject: [PATCH] Implement FMSG-005 reactions and the terminal flag Requires fmsgd's msg.is_terminal column (markmnl/fmsgd#43). - Message objects gain `terminal` (settable on create/update), `reaction` (the emoji a message carries when it is a reaction, "" for a clearing one, null otherwise) and `reactions` (effective reactions on the message: each participant's latest by time, ties by message hash, grouped by emoji). - A reaction is recognised by its FMSG-005 shape: a reply with no_reply and terminal set, not important, no add-to, type text/plain;charset=UTF-8, no attachments, body a single emoji or empty. - POST /fmsg/:id/react sets or clears the caller's reaction by sending a reaction message to every other participant in one step; idempotent when the reaction is unchanged; same reply-domain check as send. - Replies to a terminal message and add-to on one are refused with 409 before the database trigger would. - WebSocket: an arriving reaction is pushed as a `reaction` event carrying the refreshed subject, never as new_msg; no Web Push. - New internal/emoji package: RGI_Emoji set and emoji property tables generated from Unicode 17.0 data (go run ./internal/emoji/gen), with IsRGI, IsPossible (UTS #51 possible_emoji, emoji presentation required) and IsSingle. - README documents the route, fields and event. Verified: go test ./... passes; the new SQL was executed against fmsgd's v0.6.0 schema in a scratch PostgreSQL, including the trigger refusing a reply to a reaction. Co-Authored-By: Claude Fable 5.1 Claude-Session: https://claude.ai/code/session_01MW4FXDGacoWXeKPU5cQTHS --- README.md | 69 +- cmd/fmsg-webapi/main.go | 1 + internal/emoji/emoji.go | 124 + internal/emoji/emoji_test.go | 78 + internal/emoji/gen/main.go | 211 ++ internal/emoji/tables.go | 4278 +++++++++++++++++++++++++++ internal/handlers/hub.go | 20 +- internal/handlers/messages.go | 103 +- internal/handlers/push.go | 3 + internal/handlers/reactions.go | 434 +++ internal/handlers/reactions_test.go | 190 ++ internal/handlers/thread.go | 9 +- internal/models/models.go | 10 + 13 files changed, 5494 insertions(+), 36 deletions(-) create mode 100644 internal/emoji/emoji.go create mode 100644 internal/emoji/emoji_test.go create mode 100644 internal/emoji/gen/main.go create mode 100644 internal/emoji/tables.go create mode 100644 internal/handlers/reactions.go create mode 100644 internal/handlers/reactions_test.go diff --git a/README.md b/README.md index c369651..355ef3b 100644 --- a/README.md +++ b/README.md @@ -276,6 +276,7 @@ the application. | `POST` | `/fmsg/:id/send` | Send a message | | `POST` | `/fmsg/:id/read` | Mark a message as read | | `POST` | `/fmsg/:id/add-to` | Add recipients | +| `POST` | `/fmsg/:id/react` | Set or clear an emoji reaction (FMSG-005) | | `GET` | `/fmsg/:id/data` | Download message data | | `GET` | `/fmsg/:id/thread` | Render direct ancestry as plain text | | `GET` | `/fmsg/:id/thread/messages` | Load direct ancestry as structured JSON | @@ -424,7 +425,10 @@ event types can be added without breaking clients: | `type` | `data` | Sent when | | ---------- | ------ | --------- | -| `new_msg` | A message object, same shape as an item in the `GET /fmsg` list response (includes `id`). | A new message arrives for the authenticated user. | +| `new_msg` | A message object, same shape as an item in the `GET /fmsg` list response (includes `id`). | A new message arrives for the authenticated user. Not sent for reactions. | +| `delivered` | The refreshed message object. | A recipient's delivery state changed on a message the user sent. | +| `recipients_added` | The refreshed message object. | An add-to batch was recorded on a message the user participates in. | +| `reaction` | The refreshed **subject** message object, with its `reactions` up to date. | A reaction (FMSG-005) on a message the user participates in arrives. The reaction message itself is not pushed as `new_msg` and triggers no Web Push. | A client only ever receives events for messages it is a participant on. The server sends periodic WebSocket pings; clients should respond with pongs (most @@ -493,6 +497,7 @@ Add-to recipients are not part of this body โ€” they are added later via `POST / | `size` | `int` | yes | Data size in bytes | | `important` | `bool` | no | Mark message as important | | `no_reply` | `bool` | no | Indicate replies will be discarded | +| `terminal` | `bool` | no | Mark the message terminal: a leaf nobody can reply to or add recipients to (fmsg Specification v0.6.0 flag bit 6, enforced by every host) | | `data` | `string` | no | Message body content | **Response:** `201 Created` with `{"id": }`. @@ -501,8 +506,9 @@ Add-to recipients are not part of this body โ€” they are added later via `POST / | Status | Condition | | ------ | --------- | -| `400` | Missing/invalid fields, empty `to`, or `topic` set together with `pid` | +| `400` | Missing/invalid fields, empty `to`, `topic` set together with `pid`, or `pid` not found | | `403` | `from` does not match authenticated user | +| `409` | `pid` references a terminal message, which cannot be replied to | ### GET `/fmsg/:id` @@ -519,6 +525,7 @@ Retrieves a single message by ID. The authenticated identity must be a participa "important": false, "no_reply": false, "deflate": false, + "terminal": false, "pid": null, "from": "@alice@example.com", "to": ["@bob@example.com"], @@ -544,10 +551,28 @@ Retrieves a single message by ID. The authenticated identity must be a participa "short_text": "hello world", "read": false, "time_read": null, - "attachments": [] + "attachments": [], + "reaction": null, + "reactions": [ + { "emoji": "๐Ÿ‘", "from": ["@bob@example.com", "@carol@example.com"] } + ] } ``` +`terminal` is the fmsg _terminal_ flag: the message is a leaf of its thread +and no host will accept a reply to it or an add-to on it. + +`reaction` and `reactions` implement +[FMSG-005 Reactions](https://github.com/markmnl/fmsg/blob/main/standards/fmsg-005-reactions.md). +A reaction is an ordinary message recognised by its shape โ€” a reply with +`no_reply` and `terminal` set, type `text/plain;charset=UTF-8`, no attachments, +and a body that is a single emoji (or empty to clear). `reaction` is the emoji +such a message carries (`""` for a clearing reaction) and `null` for every +other message, so clients can hide reaction messages from message lists. +`reactions` lists the effective reactions on this message: each participant's +latest reaction, grouped by emoji in order of first reaction, with the +reactors of each. It is `[]` when there are none. + `add_to` is an array of add-to batches, one per `POST /fmsg/:id/add-to` call. Each batch has a stable `batch_id` (unique within the database and referenced with the message ID), records who added the recipients (`add_to_from`), the @@ -590,9 +615,10 @@ Updates a draft message. Only the owner (`from`) may update, and the message mus | Status | Condition | | ------ | --------- | -| `400` | Invalid fields, or `topic` set together with `pid` | +| `400` | Invalid fields, `topic` set together with `pid`, or `pid` not found | | `403` | Not the owner, or message already sent | | `404` | Message not found | +| `409` | `pid` references a terminal message, which cannot be replied to | ### DELETE `/fmsg/:id` @@ -673,6 +699,41 @@ New addresses must be distinct among themselves (case-insensitive). | `400` | Empty `add_to` or duplicate addresses | | `403` | Authenticated user is not an existing participant (sender or `to` recipient) | | `404` | Message not found | +| `409` | Message is terminal; recipients cannot be added to it | + +### POST `/fmsg/:id/react` + +Sets or clears the authenticated identity's reaction on a message, per +[FMSG-005 Reactions](https://github.com/markmnl/fmsg/blob/main/standards/fmsg-005-reactions.md). +The identity must be a participant of the message โ€” the sender or a recipient +in `to` or `add_to` โ€” and the message must be sent and not terminal. + +The reaction is sent immediately as a reaction message: a reply to `:id` with +`no_reply` and `terminal` set, type `text/plain;charset=UTF-8`, body the emoji, +addressed to every other participant of the message. Delivery then proceeds +exactly as for any sent message. A reaction message cannot be replied to, +reacted to, or have recipients added. + +**Request body (JSON):** + +| Field | Type | Required | Description | +| ------- | -------- | -------- | ----------- | +| `emoji` | `string` | no | A single emoji (a Unicode `RGI_Emoji` sequence, or any single well-formed emoji sequence). `""` or `null` clears the caller's reaction. | + +Setting the same reaction the caller already has is idempotent: nothing is +sent and the existing reaction message is returned with `200 OK`. Clearing when +the caller has no reaction returns `200 OK` with `null` values. + +**Response:** `201 Created` with the reaction message's `{"id": , "time": }`. + +**Errors:** + +| Status | Condition | +| ------ | --------- | +| `400` | `emoji` is not a single emoji | +| `403` | Authenticated identity is not a participant | +| `404` | Message not found | +| `409` | Message is a draft, is terminal, has no other participants, or a remote recipient host cannot accept the reaction because it does not hold the message | ### GET `/fmsg/:id/data` diff --git a/cmd/fmsg-webapi/main.go b/cmd/fmsg-webapi/main.go index a614c18..48512ca 100644 --- a/cmd/fmsg-webapi/main.go +++ b/cmd/fmsg-webapi/main.go @@ -192,6 +192,7 @@ func main() { fmsg.POST("/:id/send", msgHandler.Send) fmsg.POST("/:id/read", msgHandler.MarkRead) fmsg.POST("/:id/add-to", msgHandler.AddRecipients) + fmsg.POST("/:id/react", msgHandler.React) fmsg.GET("/:id/data", msgHandler.DownloadData) fmsg.GET("/:id/thread", msgHandler.ThreadText) fmsg.GET("/:id/thread/messages", msgHandler.ThreadMessages) diff --git a/internal/emoji/emoji.go b/internal/emoji/emoji.go new file mode 100644 index 0000000..78110cf --- /dev/null +++ b/internal/emoji/emoji.go @@ -0,0 +1,124 @@ +// Package emoji recognises single emoji for FMSG-005 reactions. +// +// A reaction's data must be exactly one emoji. [IsRGI] tests membership of the +// Unicode RGI_Emoji set (UTS #51), the set senders are required to use. +// [IsPossible] accepts the wider UTS #51 possible_emoji grammar, restricted to +// sequences that present as emoji, so a reaction using a sequence newer than +// the compiled tables, or a minimally-qualified one, is still recognised as a +// reaction rather than demoted to an ordinary message. +// +// Run `go run ./internal/emoji/gen` from the repository root to refresh the +// tables from unicode.org. +package emoji + +import ( + "unicode" + "unicode/utf8" +) + +const ( + zwj = 0x200D + vs16 = 0xFE0F + keycap = 0x20E3 + tagBegin = 0xE0020 + tagEnd = 0xE007E + tagTerm = 0xE007F + riFirst = 0x1F1E6 + riLast = 0x1F1FF + blackFlag = 0x1F3F4 + maxReaction = 64 // bytes; FMSG-005 size bound + maxSequenceR = 24 // runes; generous bound for ZWJ sequences +) + +// IsRGI reports whether s is exactly one fully-qualified RGI emoji sequence. +func IsRGI(s string) bool { + _, ok := rgi[s] + return ok +} + +// IsPossible reports whether s is exactly one emoji under the UTS #51 +// possible_emoji grammar, requiring emoji presentation: a text-default +// character such as a digit counts only with U+FE0F, a keycap or a modifier. +// +// possible_emoji := flag_sequence | zwj_element (ZWJ zwj_element)* +// flag_sequence := RI RI +// zwj_element := Emoji emoji_modification? +// emoji_modification := Emoji_Modifier | FE0F 20E3? | tag_modifier +// tag_modifier := [E0020-E007E]+ E007F +func IsPossible(s string) bool { + if s == "" || len(s) > maxReaction || !utf8.ValidString(s) { + return false + } + runes := []rune(s) + if len(runes) > maxSequenceR { + return false + } + if len(runes) == 2 && isRI(runes[0]) && isRI(runes[1]) { + return true + } + i := 0 + for { + n, ok := zwjElement(runes[i:]) + if !ok { + return false + } + i += n + if i == len(runes) { + return true + } + if runes[i] != zwj { + return false + } + i++ + if i == len(runes) { + return false + } + } +} + +// IsSingle reports whether s is one emoji by either test. +func IsSingle(s string) bool { + return IsRGI(s) || IsPossible(s) +} + +func isRI(r rune) bool { return r >= riFirst && r <= riLast } + +// zwjElement consumes one zwj_element from the front of runes, returning its +// length. The element must present as emoji. +func zwjElement(runes []rune) (int, bool) { + if len(runes) == 0 || !unicode.Is(propEmoji, runes[0]) || isRI(runes[0]) { + return 0, false + } + base := runes[0] + presents := unicode.Is(propEmojiPresentation, base) + i := 1 + if i < len(runes) { + switch r := runes[i]; { + case unicode.Is(propEmojiModifier, r): + if !unicode.Is(propEmojiModifierBase, base) { + return 0, false + } + i++ + presents = true + case r == vs16: + i++ + presents = true + if i < len(runes) && runes[i] == keycap { + i++ + } + case r >= tagBegin && r <= tagEnd: + if base != blackFlag { + return 0, false + } + for i < len(runes) && runes[i] >= tagBegin && runes[i] <= tagEnd { + i++ + } + if i >= len(runes) || runes[i] != tagTerm { + return 0, false + } + i++ + presents = true + } + } + return i, presents +} diff --git a/internal/emoji/emoji_test.go b/internal/emoji/emoji_test.go new file mode 100644 index 0000000..e4b8950 --- /dev/null +++ b/internal/emoji/emoji_test.go @@ -0,0 +1,78 @@ +package emoji + +import "testing" + +func TestIsRGI(t *testing.T) { + for _, s := range []string{ + "๐Ÿ‘", + "โค๏ธ", + "๐Ÿ‘๐Ÿฝ", + "๐Ÿ‡ณ๐Ÿ‡ฟ", + "๐Ÿ‘จโ€๐Ÿ‘ฉโ€๐Ÿ‘ง", + "#๏ธโƒฃ", + "๐Ÿด๓ ง๓ ข๓ ณ๓ ฃ๓ ด๓ ฟ", + } { + if !IsRGI(s) { + t.Errorf("IsRGI(%q) = false, want true", s) + } + } + for _, s := range []string{ + "", + "a", + "๐Ÿ‘๐Ÿ‘", + "๐Ÿ‘ ", + "โค", // unqualified: U+2764 without VS16 + "1", + } { + if IsRGI(s) { + t.Errorf("IsRGI(%q) = true, want false", s) + } + } +} + +func TestIsPossible(t *testing.T) { + for _, s := range []string{ + "๐Ÿ‘", + "โค๏ธ", + "๐Ÿ‘๐Ÿฝ", + "๐Ÿ‡ณ๐Ÿ‡ฟ", + "๐Ÿ‘จโ€๐Ÿ‘ฉโ€๐Ÿ‘ง", + "#๏ธโƒฃ", + "๐Ÿด๓ ง๓ ข๓ ณ๓ ฃ๓ ด๓ ฟ", + "๐Ÿง‘โ€๐Ÿฆฏ", // any well-formed ZWJ sequence + } { + if !IsPossible(s) { + t.Errorf("IsPossible(%q) = false, want true", s) + } + } + for _, s := range []string{ + "", + "a", + "1", // text-default without VS16 + "โค", // text-default without VS16 + "๐Ÿ‘๐Ÿ‘", // two emoji + "๐Ÿ‘ ", // trailing space + "๐Ÿ‘โ€", // dangling ZWJ + "โ€๐Ÿ‘", // leading ZWJ + "๐Ÿ‡ณ", // lone regional indicator + "๐Ÿ‡ณ๐Ÿ‡ฟ๐Ÿ‡ณ", // three regional indicators + "a๐Ÿฝ", // modifier on a non-emoji + "๐Ÿ‘๐Ÿฝ๐Ÿฝ", // double modifier + "๐Ÿณ\U000E007F", // tag on a non-black-flag base + "\xff", // invalid UTF-8 + } { + if IsPossible(s) { + t.Errorf("IsPossible(%q) = true, want false", s) + } + } +} + +func TestIsSingleRejectsOversize(t *testing.T) { + s := "" + for len(s) <= maxReaction { + s += "โ€๐Ÿ‘" + } + if IsSingle(s) { + t.Errorf("IsSingle accepted %d-byte sequence", len(s)) + } +} diff --git a/internal/emoji/gen/main.go b/internal/emoji/gen/main.go new file mode 100644 index 0000000..dfd3494 --- /dev/null +++ b/internal/emoji/gen/main.go @@ -0,0 +1,211 @@ +// Command gen regenerates tables.go for package emoji from the Unicode emoji +// data files. Run from the repository root: +// +// go run ./internal/emoji/gen [emoji-test.txt emoji-data.txt] +// +// Without arguments the latest files are downloaded from unicode.org. +package main + +import ( + "bufio" + "bytes" + "fmt" + "go/format" + "io" + "net/http" + "os" + "sort" + "strconv" + "strings" +) + +const ( + testURL = "https://www.unicode.org/Public/emoji/latest/emoji-test.txt" + dataURL = "https://www.unicode.org/Public/UCD/latest/ucd/emoji/emoji-data.txt" +) + +func open(arg, url string) (io.ReadCloser, error) { + if arg != "" { + return os.Open(arg) + } + resp, err := http.Get(url) + if err != nil { + return nil, err + } + if resp.StatusCode != http.StatusOK { + resp.Body.Close() + return nil, fmt.Errorf("GET %s: %s", url, resp.Status) + } + return resp.Body, nil +} + +type span struct{ lo, hi rune } + +func main() { + var testArg, dataArg string + if len(os.Args) == 3 { + testArg, dataArg = os.Args[1], os.Args[2] + } else if len(os.Args) != 1 { + fmt.Fprintln(os.Stderr, "usage: gen [emoji-test.txt emoji-data.txt]") + os.Exit(2) + } + + test, err := open(testArg, testURL) + if err != nil { + fmt.Fprintln(os.Stderr, err) + os.Exit(1) + } + defer test.Close() + rgi, version := parseTest(test) + + data, err := open(dataArg, dataURL) + if err != nil { + fmt.Fprintln(os.Stderr, err) + os.Exit(1) + } + defer data.Close() + props := parseData(data) + + var buf bytes.Buffer + w := &buf + + fmt.Fprintf(w, "// Code generated by internal/emoji/gen from Unicode Emoji %s; DO NOT EDIT.\n\n", version) + fmt.Fprintln(w, "package emoji") + fmt.Fprintln(w) + fmt.Fprintln(w, `import "unicode"`) + fmt.Fprintln(w) + fmt.Fprintf(w, "// Version is the Unicode Emoji version the tables were generated from.\nconst Version = %q\n\n", version) + fmt.Fprintf(w, "// rgi is the RGI_Emoji set (UTS #51): every fully-qualified emoji sequence.\nvar rgi = map[string]struct{}{\n") + for _, s := range rgi { + fmt.Fprintf(w, "\t%q: {},\n", s) + } + fmt.Fprintln(w, "}") + for _, name := range []string{"Emoji", "Emoji_Presentation", "Emoji_Modifier", "Emoji_Modifier_Base", "Emoji_Component"} { + writeTable(w, name, props[name]) + } + + src, err := format.Source(buf.Bytes()) + if err != nil { + fmt.Fprintln(os.Stderr, "format generated source:", err) + os.Exit(1) + } + if err := os.WriteFile("internal/emoji/tables.go", src, 0o644); err != nil { + fmt.Fprintln(os.Stderr, err) + os.Exit(1) + } +} + +// parseTest returns the fully-qualified sequences and the file's version. +func parseTest(r io.Reader) ([]string, string) { + var seqs []string + version := "unknown" + sc := bufio.NewScanner(r) + for sc.Scan() { + line := sc.Text() + if strings.HasPrefix(line, "# Version:") { + version = strings.TrimSpace(strings.TrimPrefix(line, "# Version:")) + continue + } + if line == "" || strings.HasPrefix(line, "#") { + continue + } + // ; # E + semi := strings.IndexByte(line, ';') + hash := strings.IndexByte(line, '#') + if semi < 0 || hash < 0 { + continue + } + status := strings.TrimSpace(line[semi+1 : hash]) + if status != "fully-qualified" { + continue + } + var b strings.Builder + for _, cp := range strings.Fields(line[:semi]) { + n, err := strconv.ParseUint(cp, 16, 32) + if err != nil { + fmt.Fprintf(os.Stderr, "bad code point %q\n", cp) + os.Exit(1) + } + b.WriteRune(rune(n)) + } + seqs = append(seqs, b.String()) + } + sort.Strings(seqs) + return seqs, version +} + +// parseData returns the code point spans of each emoji property. +func parseData(r io.Reader) map[string][]span { + props := make(map[string][]span) + sc := bufio.NewScanner(r) + for sc.Scan() { + line := sc.Text() + if hash := strings.IndexByte(line, '#'); hash >= 0 { + line = line[:hash] + } + line = strings.TrimSpace(line) + if line == "" { + continue + } + parts := strings.Split(line, ";") + if len(parts) != 2 { + continue + } + rng, prop := strings.TrimSpace(parts[0]), strings.TrimSpace(parts[1]) + lo, hi := rng, rng + if dots := strings.Index(rng, ".."); dots >= 0 { + lo, hi = rng[:dots], rng[dots+2:] + } + l, err1 := strconv.ParseUint(lo, 16, 32) + h, err2 := strconv.ParseUint(hi, 16, 32) + if err1 != nil || err2 != nil { + fmt.Fprintf(os.Stderr, "bad range %q\n", rng) + os.Exit(1) + } + props[prop] = append(props[prop], span{rune(l), rune(h)}) + } + for name := range props { + s := props[name] + sort.Slice(s, func(i, j int) bool { return s[i].lo < s[j].lo }) + // merge adjacent spans + merged := s[:0] + for _, sp := range s { + if n := len(merged); n > 0 && merged[n-1].hi+1 >= sp.lo { + if sp.hi > merged[n-1].hi { + merged[n-1].hi = sp.hi + } + continue + } + merged = append(merged, sp) + } + props[name] = merged + } + return props +} + +func writeTable(w io.Writer, name string, spans []span) { + goName := "prop" + strings.ReplaceAll(name, "_", "") + fmt.Fprintf(w, "\n// %s is the %s property.\nvar %s = &unicode.RangeTable{\n", goName, name, goName) + var r16, r32 []span + for _, sp := range spans { + if sp.hi < 0x10000 { + r16 = append(r16, sp) + } else if sp.lo >= 0x10000 { + r32 = append(r32, sp) + } else { + r16 = append(r16, span{sp.lo, 0xFFFF}) + r32 = append(r32, span{0x10000, sp.hi}) + } + } + fmt.Fprintln(w, "\tR16: []unicode.Range16{") + for _, sp := range r16 { + fmt.Fprintf(w, "\t\t{0x%04X, 0x%04X, 1},\n", sp.lo, sp.hi) + } + fmt.Fprintln(w, "\t},") + fmt.Fprintln(w, "\tR32: []unicode.Range32{") + for _, sp := range r32 { + fmt.Fprintf(w, "\t\t{0x%X, 0x%X, 1},\n", sp.lo, sp.hi) + } + fmt.Fprintln(w, "\t},") + fmt.Fprintln(w, "}") +} diff --git a/internal/emoji/tables.go b/internal/emoji/tables.go new file mode 100644 index 0000000..3371088 --- /dev/null +++ b/internal/emoji/tables.go @@ -0,0 +1,4278 @@ +// Code generated by internal/emoji/gen from Unicode Emoji 17.0; DO NOT EDIT. + +package emoji + +import "unicode" + +// Version is the Unicode Emoji version the tables were generated from. +const Version = "17.0" + +// rgi is the RGI_Emoji set (UTS #51): every fully-qualified emoji sequence. +var rgi = map[string]struct{}{ + "#๏ธโƒฃ": {}, + "*๏ธโƒฃ": {}, + "0๏ธโƒฃ": {}, + "1๏ธโƒฃ": {}, + "2๏ธโƒฃ": {}, + "3๏ธโƒฃ": {}, + "4๏ธโƒฃ": {}, + "5๏ธโƒฃ": {}, + "6๏ธโƒฃ": {}, + "7๏ธโƒฃ": {}, + "8๏ธโƒฃ": {}, + "9๏ธโƒฃ": {}, + "ยฉ๏ธ": {}, + "ยฎ๏ธ": {}, + "โ€ผ๏ธ": {}, + "โ‰๏ธ": {}, + "โ„ข๏ธ": {}, + "โ„น๏ธ": {}, + "โ†”๏ธ": {}, + "โ†•๏ธ": {}, + "โ†–๏ธ": {}, + "โ†—๏ธ": {}, + "โ†˜๏ธ": {}, + "โ†™๏ธ": {}, + "โ†ฉ๏ธ": {}, + "โ†ช๏ธ": {}, + "โŒš": {}, + "โŒ›": {}, + "โŒจ๏ธ": {}, + "โ๏ธ": {}, + "โฉ": {}, + "โช": {}, + "โซ": {}, + "โฌ": {}, + "โญ๏ธ": {}, + "โฎ๏ธ": {}, + "โฏ๏ธ": {}, + "โฐ": {}, + "โฑ๏ธ": {}, + "โฒ๏ธ": {}, + "โณ": {}, + "โธ๏ธ": {}, + "โน๏ธ": {}, + "โบ๏ธ": {}, + "โ“‚๏ธ": {}, + "โ–ช๏ธ": {}, + "โ–ซ๏ธ": {}, + "โ–ถ๏ธ": {}, + "โ—€๏ธ": {}, + "โ—ป๏ธ": {}, + "โ—ผ๏ธ": {}, + "โ—ฝ": {}, + "โ—พ": {}, + "โ˜€๏ธ": {}, + "โ˜๏ธ": {}, + "โ˜‚๏ธ": {}, + "โ˜ƒ๏ธ": {}, + "โ˜„๏ธ": {}, + "โ˜Ž๏ธ": {}, + "โ˜‘๏ธ": {}, + "โ˜”": {}, + "โ˜•": {}, + "โ˜˜๏ธ": {}, + "โ˜๏ธ": {}, + "โ˜๐Ÿป": {}, + "โ˜๐Ÿผ": {}, + "โ˜๐Ÿฝ": {}, + "โ˜๐Ÿพ": {}, + "โ˜๐Ÿฟ": {}, + "โ˜ ๏ธ": {}, + "โ˜ข๏ธ": {}, + "โ˜ฃ๏ธ": {}, + "โ˜ฆ๏ธ": {}, + "โ˜ช๏ธ": {}, + "โ˜ฎ๏ธ": {}, + "โ˜ฏ๏ธ": {}, + "โ˜ธ๏ธ": {}, + "โ˜น๏ธ": {}, + "โ˜บ๏ธ": {}, + "โ™€๏ธ": {}, + "โ™‚๏ธ": {}, + "โ™ˆ": {}, + "โ™‰": {}, + "โ™Š": {}, + "โ™‹": {}, + "โ™Œ": {}, + "โ™": {}, + "โ™Ž": {}, + "โ™": {}, + "โ™": {}, + "โ™‘": {}, + "โ™’": {}, + "โ™“": {}, + "โ™Ÿ๏ธ": {}, + "โ™ ๏ธ": {}, + "โ™ฃ๏ธ": {}, + "โ™ฅ๏ธ": {}, + "โ™ฆ๏ธ": {}, + "โ™จ๏ธ": {}, + "โ™ป๏ธ": {}, + "โ™พ๏ธ": {}, + "โ™ฟ": {}, + "โš’๏ธ": {}, + "โš“": {}, + "โš”๏ธ": {}, + "โš•๏ธ": {}, + "โš–๏ธ": {}, + "โš—๏ธ": {}, + "โš™๏ธ": {}, + "โš›๏ธ": {}, + "โšœ๏ธ": {}, + "โš ๏ธ": {}, + "โšก": {}, + "โšง๏ธ": {}, + "โšช": {}, + "โšซ": {}, + "โšฐ๏ธ": {}, + "โšฑ๏ธ": {}, + "โšฝ": {}, + "โšพ": {}, + "โ›„": {}, + "โ›…": {}, + "โ›ˆ๏ธ": {}, + "โ›Ž": {}, + "โ›๏ธ": {}, + "โ›‘๏ธ": {}, + "โ›“๏ธ": {}, + "โ›“๏ธ\u200d๐Ÿ’ฅ": {}, + "โ›”": {}, + "โ›ฉ๏ธ": {}, + "โ›ช": {}, + "โ›ฐ๏ธ": {}, + "โ›ฑ๏ธ": {}, + "โ›ฒ": {}, + "โ›ณ": {}, + "โ›ด๏ธ": {}, + "โ›ต": {}, + "โ›ท๏ธ": {}, + "โ›ธ๏ธ": {}, + "โ›น๏ธ": {}, + "โ›น๏ธ\u200dโ™€๏ธ": {}, + "โ›น๏ธ\u200dโ™‚๏ธ": {}, + "โ›น๐Ÿป": {}, + "โ›น๐Ÿป\u200dโ™€๏ธ": {}, + "โ›น๐Ÿป\u200dโ™‚๏ธ": {}, + "โ›น๐Ÿผ": {}, + "โ›น๐Ÿผ\u200dโ™€๏ธ": {}, + "โ›น๐Ÿผ\u200dโ™‚๏ธ": {}, + "โ›น๐Ÿฝ": {}, + "โ›น๐Ÿฝ\u200dโ™€๏ธ": {}, + "โ›น๐Ÿฝ\u200dโ™‚๏ธ": {}, + "โ›น๐Ÿพ": {}, + "โ›น๐Ÿพ\u200dโ™€๏ธ": {}, + "โ›น๐Ÿพ\u200dโ™‚๏ธ": {}, + "โ›น๐Ÿฟ": {}, + "โ›น๐Ÿฟ\u200dโ™€๏ธ": {}, + "โ›น๐Ÿฟ\u200dโ™‚๏ธ": {}, + "โ›บ": {}, + "โ›ฝ": {}, + "โœ‚๏ธ": {}, + "โœ…": {}, + "โœˆ๏ธ": {}, + "โœ‰๏ธ": {}, + "โœŠ": {}, + "โœŠ๐Ÿป": {}, + "โœŠ๐Ÿผ": {}, + "โœŠ๐Ÿฝ": {}, + "โœŠ๐Ÿพ": {}, + "โœŠ๐Ÿฟ": {}, + "โœ‹": {}, + "โœ‹๐Ÿป": {}, + "โœ‹๐Ÿผ": {}, + "โœ‹๐Ÿฝ": {}, + "โœ‹๐Ÿพ": {}, + "โœ‹๐Ÿฟ": {}, + "โœŒ๏ธ": {}, + "โœŒ๐Ÿป": {}, + "โœŒ๐Ÿผ": {}, + "โœŒ๐Ÿฝ": {}, + "โœŒ๐Ÿพ": {}, + "โœŒ๐Ÿฟ": {}, + "โœ๏ธ": {}, + "โœ๐Ÿป": {}, + "โœ๐Ÿผ": {}, + "โœ๐Ÿฝ": {}, + "โœ๐Ÿพ": {}, + "โœ๐Ÿฟ": {}, + "โœ๏ธ": {}, + "โœ’๏ธ": {}, + "โœ”๏ธ": {}, + "โœ–๏ธ": {}, + "โœ๏ธ": {}, + "โœก๏ธ": {}, + "โœจ": {}, + "โœณ๏ธ": {}, + "โœด๏ธ": {}, + "โ„๏ธ": {}, + "โ‡๏ธ": {}, + "โŒ": {}, + "โŽ": {}, + "โ“": {}, + "โ”": {}, + "โ•": {}, + "โ—": {}, + "โฃ๏ธ": {}, + "โค๏ธ": {}, + "โค๏ธ\u200d๐Ÿ”ฅ": {}, + "โค๏ธ\u200d๐Ÿฉน": {}, + "โž•": {}, + "โž–": {}, + "โž—": {}, + "โžก๏ธ": {}, + "โžฐ": {}, + "โžฟ": {}, + "โคด๏ธ": {}, + "โคต๏ธ": {}, + "โฌ…๏ธ": {}, + "โฌ†๏ธ": {}, + "โฌ‡๏ธ": {}, + "โฌ›": {}, + "โฌœ": {}, + "โญ": {}, + "โญ•": {}, + "ใ€ฐ๏ธ": {}, + "ใ€ฝ๏ธ": {}, + "ใŠ—๏ธ": {}, + "ใŠ™๏ธ": {}, + "๐Ÿ€„": {}, + "๐Ÿƒ": {}, + "๐Ÿ…ฐ๏ธ": {}, + "๐Ÿ…ฑ๏ธ": {}, + "๐Ÿ…พ๏ธ": {}, + "๐Ÿ…ฟ๏ธ": {}, + "๐Ÿ†Ž": {}, + "๐Ÿ†‘": {}, + "๐Ÿ†’": {}, + "๐Ÿ†“": {}, + "๐Ÿ†”": {}, + "๐Ÿ†•": {}, + "๐Ÿ†–": {}, + "๐Ÿ†—": {}, + "๐Ÿ†˜": {}, + "๐Ÿ†™": {}, + "๐Ÿ†š": {}, + "๐Ÿ‡ฆ๐Ÿ‡จ": {}, + "๐Ÿ‡ฆ๐Ÿ‡ฉ": {}, + "๐Ÿ‡ฆ๐Ÿ‡ช": {}, + "๐Ÿ‡ฆ๐Ÿ‡ซ": {}, + "๐Ÿ‡ฆ๐Ÿ‡ฌ": {}, + "๐Ÿ‡ฆ๐Ÿ‡ฎ": {}, + "๐Ÿ‡ฆ๐Ÿ‡ฑ": {}, + "๐Ÿ‡ฆ๐Ÿ‡ฒ": {}, + "๐Ÿ‡ฆ๐Ÿ‡ด": {}, + "๐Ÿ‡ฆ๐Ÿ‡ถ": {}, + "๐Ÿ‡ฆ๐Ÿ‡ท": {}, + "๐Ÿ‡ฆ๐Ÿ‡ธ": {}, + "๐Ÿ‡ฆ๐Ÿ‡น": {}, + "๐Ÿ‡ฆ๐Ÿ‡บ": {}, + "๐Ÿ‡ฆ๐Ÿ‡ผ": {}, + "๐Ÿ‡ฆ๐Ÿ‡ฝ": {}, + "๐Ÿ‡ฆ๐Ÿ‡ฟ": {}, + "๐Ÿ‡ง๐Ÿ‡ฆ": {}, + "๐Ÿ‡ง๐Ÿ‡ง": {}, + "๐Ÿ‡ง๐Ÿ‡ฉ": {}, + "๐Ÿ‡ง๐Ÿ‡ช": {}, + "๐Ÿ‡ง๐Ÿ‡ซ": {}, + "๐Ÿ‡ง๐Ÿ‡ฌ": {}, + "๐Ÿ‡ง๐Ÿ‡ญ": {}, + "๐Ÿ‡ง๐Ÿ‡ฎ": {}, + "๐Ÿ‡ง๐Ÿ‡ฏ": {}, + "๐Ÿ‡ง๐Ÿ‡ฑ": {}, + "๐Ÿ‡ง๐Ÿ‡ฒ": {}, + "๐Ÿ‡ง๐Ÿ‡ณ": {}, + "๐Ÿ‡ง๐Ÿ‡ด": {}, + "๐Ÿ‡ง๐Ÿ‡ถ": {}, + "๐Ÿ‡ง๐Ÿ‡ท": {}, + "๐Ÿ‡ง๐Ÿ‡ธ": {}, + "๐Ÿ‡ง๐Ÿ‡น": {}, + "๐Ÿ‡ง๐Ÿ‡ป": {}, + "๐Ÿ‡ง๐Ÿ‡ผ": {}, + "๐Ÿ‡ง๐Ÿ‡พ": {}, + "๐Ÿ‡ง๐Ÿ‡ฟ": {}, + "๐Ÿ‡จ๐Ÿ‡ฆ": {}, + "๐Ÿ‡จ๐Ÿ‡จ": {}, + "๐Ÿ‡จ๐Ÿ‡ฉ": {}, + "๐Ÿ‡จ๐Ÿ‡ซ": {}, + "๐Ÿ‡จ๐Ÿ‡ฌ": {}, + "๐Ÿ‡จ๐Ÿ‡ญ": {}, + "๐Ÿ‡จ๐Ÿ‡ฎ": {}, + "๐Ÿ‡จ๐Ÿ‡ฐ": {}, + "๐Ÿ‡จ๐Ÿ‡ฑ": {}, + "๐Ÿ‡จ๐Ÿ‡ฒ": {}, + "๐Ÿ‡จ๐Ÿ‡ณ": {}, + "๐Ÿ‡จ๐Ÿ‡ด": {}, + "๐Ÿ‡จ๐Ÿ‡ต": {}, + "๐Ÿ‡จ๐Ÿ‡ถ": {}, + "๐Ÿ‡จ๐Ÿ‡ท": {}, + "๐Ÿ‡จ๐Ÿ‡บ": {}, + "๐Ÿ‡จ๐Ÿ‡ป": {}, + "๐Ÿ‡จ๐Ÿ‡ผ": {}, + "๐Ÿ‡จ๐Ÿ‡ฝ": {}, + "๐Ÿ‡จ๐Ÿ‡พ": {}, + "๐Ÿ‡จ๐Ÿ‡ฟ": {}, + "๐Ÿ‡ฉ๐Ÿ‡ช": {}, + "๐Ÿ‡ฉ๐Ÿ‡ฌ": {}, + "๐Ÿ‡ฉ๐Ÿ‡ฏ": {}, + "๐Ÿ‡ฉ๐Ÿ‡ฐ": {}, + "๐Ÿ‡ฉ๐Ÿ‡ฒ": {}, + "๐Ÿ‡ฉ๐Ÿ‡ด": {}, + "๐Ÿ‡ฉ๐Ÿ‡ฟ": {}, + "๐Ÿ‡ช๐Ÿ‡ฆ": {}, + "๐Ÿ‡ช๐Ÿ‡จ": {}, + "๐Ÿ‡ช๐Ÿ‡ช": {}, + "๐Ÿ‡ช๐Ÿ‡ฌ": {}, + "๐Ÿ‡ช๐Ÿ‡ญ": {}, + "๐Ÿ‡ช๐Ÿ‡ท": {}, + "๐Ÿ‡ช๐Ÿ‡ธ": {}, + "๐Ÿ‡ช๐Ÿ‡น": {}, + "๐Ÿ‡ช๐Ÿ‡บ": {}, + "๐Ÿ‡ซ๐Ÿ‡ฎ": {}, + "๐Ÿ‡ซ๐Ÿ‡ฏ": {}, + "๐Ÿ‡ซ๐Ÿ‡ฐ": {}, + "๐Ÿ‡ซ๐Ÿ‡ฒ": {}, + "๐Ÿ‡ซ๐Ÿ‡ด": {}, + "๐Ÿ‡ซ๐Ÿ‡ท": {}, + "๐Ÿ‡ฌ๐Ÿ‡ฆ": {}, + "๐Ÿ‡ฌ๐Ÿ‡ง": {}, + "๐Ÿ‡ฌ๐Ÿ‡ฉ": {}, + "๐Ÿ‡ฌ๐Ÿ‡ช": {}, + "๐Ÿ‡ฌ๐Ÿ‡ซ": {}, + "๐Ÿ‡ฌ๐Ÿ‡ฌ": {}, + "๐Ÿ‡ฌ๐Ÿ‡ญ": {}, + "๐Ÿ‡ฌ๐Ÿ‡ฎ": {}, + "๐Ÿ‡ฌ๐Ÿ‡ฑ": {}, + "๐Ÿ‡ฌ๐Ÿ‡ฒ": {}, + "๐Ÿ‡ฌ๐Ÿ‡ณ": {}, + "๐Ÿ‡ฌ๐Ÿ‡ต": {}, + "๐Ÿ‡ฌ๐Ÿ‡ถ": {}, + "๐Ÿ‡ฌ๐Ÿ‡ท": {}, + "๐Ÿ‡ฌ๐Ÿ‡ธ": {}, + "๐Ÿ‡ฌ๐Ÿ‡น": {}, + "๐Ÿ‡ฌ๐Ÿ‡บ": {}, + "๐Ÿ‡ฌ๐Ÿ‡ผ": {}, + "๐Ÿ‡ฌ๐Ÿ‡พ": {}, + "๐Ÿ‡ญ๐Ÿ‡ฐ": {}, + "๐Ÿ‡ญ๐Ÿ‡ฒ": {}, + "๐Ÿ‡ญ๐Ÿ‡ณ": {}, + "๐Ÿ‡ญ๐Ÿ‡ท": {}, + "๐Ÿ‡ญ๐Ÿ‡น": {}, + "๐Ÿ‡ญ๐Ÿ‡บ": {}, + "๐Ÿ‡ฎ๐Ÿ‡จ": {}, + "๐Ÿ‡ฎ๐Ÿ‡ฉ": {}, + "๐Ÿ‡ฎ๐Ÿ‡ช": {}, + "๐Ÿ‡ฎ๐Ÿ‡ฑ": {}, + "๐Ÿ‡ฎ๐Ÿ‡ฒ": {}, + "๐Ÿ‡ฎ๐Ÿ‡ณ": {}, + "๐Ÿ‡ฎ๐Ÿ‡ด": {}, + "๐Ÿ‡ฎ๐Ÿ‡ถ": {}, + "๐Ÿ‡ฎ๐Ÿ‡ท": {}, + "๐Ÿ‡ฎ๐Ÿ‡ธ": {}, + "๐Ÿ‡ฎ๐Ÿ‡น": {}, + "๐Ÿ‡ฏ๐Ÿ‡ช": {}, + "๐Ÿ‡ฏ๐Ÿ‡ฒ": {}, + "๐Ÿ‡ฏ๐Ÿ‡ด": {}, + "๐Ÿ‡ฏ๐Ÿ‡ต": {}, + "๐Ÿ‡ฐ๐Ÿ‡ช": {}, + "๐Ÿ‡ฐ๐Ÿ‡ฌ": {}, + "๐Ÿ‡ฐ๐Ÿ‡ญ": {}, + "๐Ÿ‡ฐ๐Ÿ‡ฎ": {}, + "๐Ÿ‡ฐ๐Ÿ‡ฒ": {}, + "๐Ÿ‡ฐ๐Ÿ‡ณ": {}, + "๐Ÿ‡ฐ๐Ÿ‡ต": {}, + "๐Ÿ‡ฐ๐Ÿ‡ท": {}, + "๐Ÿ‡ฐ๐Ÿ‡ผ": {}, + "๐Ÿ‡ฐ๐Ÿ‡พ": {}, + "๐Ÿ‡ฐ๐Ÿ‡ฟ": {}, + "๐Ÿ‡ฑ๐Ÿ‡ฆ": {}, + "๐Ÿ‡ฑ๐Ÿ‡ง": {}, + "๐Ÿ‡ฑ๐Ÿ‡จ": {}, + "๐Ÿ‡ฑ๐Ÿ‡ฎ": {}, + "๐Ÿ‡ฑ๐Ÿ‡ฐ": {}, + "๐Ÿ‡ฑ๐Ÿ‡ท": {}, + "๐Ÿ‡ฑ๐Ÿ‡ธ": {}, + "๐Ÿ‡ฑ๐Ÿ‡น": {}, + "๐Ÿ‡ฑ๐Ÿ‡บ": {}, + "๐Ÿ‡ฑ๐Ÿ‡ป": {}, + "๐Ÿ‡ฑ๐Ÿ‡พ": {}, + "๐Ÿ‡ฒ๐Ÿ‡ฆ": {}, + "๐Ÿ‡ฒ๐Ÿ‡จ": {}, + "๐Ÿ‡ฒ๐Ÿ‡ฉ": {}, + "๐Ÿ‡ฒ๐Ÿ‡ช": {}, + "๐Ÿ‡ฒ๐Ÿ‡ซ": {}, + "๐Ÿ‡ฒ๐Ÿ‡ฌ": {}, + "๐Ÿ‡ฒ๐Ÿ‡ญ": {}, + "๐Ÿ‡ฒ๐Ÿ‡ฐ": {}, + "๐Ÿ‡ฒ๐Ÿ‡ฑ": {}, + "๐Ÿ‡ฒ๐Ÿ‡ฒ": {}, + "๐Ÿ‡ฒ๐Ÿ‡ณ": {}, + "๐Ÿ‡ฒ๐Ÿ‡ด": {}, + "๐Ÿ‡ฒ๐Ÿ‡ต": {}, + "๐Ÿ‡ฒ๐Ÿ‡ถ": {}, + "๐Ÿ‡ฒ๐Ÿ‡ท": {}, + "๐Ÿ‡ฒ๐Ÿ‡ธ": {}, + "๐Ÿ‡ฒ๐Ÿ‡น": {}, + "๐Ÿ‡ฒ๐Ÿ‡บ": {}, + "๐Ÿ‡ฒ๐Ÿ‡ป": {}, + "๐Ÿ‡ฒ๐Ÿ‡ผ": {}, + "๐Ÿ‡ฒ๐Ÿ‡ฝ": {}, + "๐Ÿ‡ฒ๐Ÿ‡พ": {}, + "๐Ÿ‡ฒ๐Ÿ‡ฟ": {}, + "๐Ÿ‡ณ๐Ÿ‡ฆ": {}, + "๐Ÿ‡ณ๐Ÿ‡จ": {}, + "๐Ÿ‡ณ๐Ÿ‡ช": {}, + "๐Ÿ‡ณ๐Ÿ‡ซ": {}, + "๐Ÿ‡ณ๐Ÿ‡ฌ": {}, + "๐Ÿ‡ณ๐Ÿ‡ฎ": {}, + "๐Ÿ‡ณ๐Ÿ‡ฑ": {}, + "๐Ÿ‡ณ๐Ÿ‡ด": {}, + "๐Ÿ‡ณ๐Ÿ‡ต": {}, + "๐Ÿ‡ณ๐Ÿ‡ท": {}, + "๐Ÿ‡ณ๐Ÿ‡บ": {}, + "๐Ÿ‡ณ๐Ÿ‡ฟ": {}, + "๐Ÿ‡ด๐Ÿ‡ฒ": {}, + "๐Ÿ‡ต๐Ÿ‡ฆ": {}, + "๐Ÿ‡ต๐Ÿ‡ช": {}, + "๐Ÿ‡ต๐Ÿ‡ซ": {}, + "๐Ÿ‡ต๐Ÿ‡ฌ": {}, + "๐Ÿ‡ต๐Ÿ‡ญ": {}, + "๐Ÿ‡ต๐Ÿ‡ฐ": {}, + "๐Ÿ‡ต๐Ÿ‡ฑ": {}, + "๐Ÿ‡ต๐Ÿ‡ฒ": {}, + "๐Ÿ‡ต๐Ÿ‡ณ": {}, + "๐Ÿ‡ต๐Ÿ‡ท": {}, + "๐Ÿ‡ต๐Ÿ‡ธ": {}, + "๐Ÿ‡ต๐Ÿ‡น": {}, + "๐Ÿ‡ต๐Ÿ‡ผ": {}, + "๐Ÿ‡ต๐Ÿ‡พ": {}, + "๐Ÿ‡ถ๐Ÿ‡ฆ": {}, + "๐Ÿ‡ท๐Ÿ‡ช": {}, + "๐Ÿ‡ท๐Ÿ‡ด": {}, + "๐Ÿ‡ท๐Ÿ‡ธ": {}, + "๐Ÿ‡ท๐Ÿ‡บ": {}, + "๐Ÿ‡ท๐Ÿ‡ผ": {}, + "๐Ÿ‡ธ๐Ÿ‡ฆ": {}, + "๐Ÿ‡ธ๐Ÿ‡ง": {}, + "๐Ÿ‡ธ๐Ÿ‡จ": {}, + "๐Ÿ‡ธ๐Ÿ‡ฉ": {}, + "๐Ÿ‡ธ๐Ÿ‡ช": {}, + "๐Ÿ‡ธ๐Ÿ‡ฌ": {}, + "๐Ÿ‡ธ๐Ÿ‡ญ": {}, + "๐Ÿ‡ธ๐Ÿ‡ฎ": {}, + "๐Ÿ‡ธ๐Ÿ‡ฏ": {}, + "๐Ÿ‡ธ๐Ÿ‡ฐ": {}, + "๐Ÿ‡ธ๐Ÿ‡ฑ": {}, + "๐Ÿ‡ธ๐Ÿ‡ฒ": {}, + "๐Ÿ‡ธ๐Ÿ‡ณ": {}, + "๐Ÿ‡ธ๐Ÿ‡ด": {}, + "๐Ÿ‡ธ๐Ÿ‡ท": {}, + "๐Ÿ‡ธ๐Ÿ‡ธ": {}, + "๐Ÿ‡ธ๐Ÿ‡น": {}, + "๐Ÿ‡ธ๐Ÿ‡ป": {}, + "๐Ÿ‡ธ๐Ÿ‡ฝ": {}, + "๐Ÿ‡ธ๐Ÿ‡พ": {}, + "๐Ÿ‡ธ๐Ÿ‡ฟ": {}, + "๐Ÿ‡น๐Ÿ‡ฆ": {}, + "๐Ÿ‡น๐Ÿ‡จ": {}, + "๐Ÿ‡น๐Ÿ‡ฉ": {}, + "๐Ÿ‡น๐Ÿ‡ซ": {}, + "๐Ÿ‡น๐Ÿ‡ฌ": {}, + "๐Ÿ‡น๐Ÿ‡ญ": {}, + "๐Ÿ‡น๐Ÿ‡ฏ": {}, + "๐Ÿ‡น๐Ÿ‡ฐ": {}, + "๐Ÿ‡น๐Ÿ‡ฑ": {}, + "๐Ÿ‡น๐Ÿ‡ฒ": {}, + "๐Ÿ‡น๐Ÿ‡ณ": {}, + "๐Ÿ‡น๐Ÿ‡ด": {}, + "๐Ÿ‡น๐Ÿ‡ท": {}, + "๐Ÿ‡น๐Ÿ‡น": {}, + "๐Ÿ‡น๐Ÿ‡ป": {}, + "๐Ÿ‡น๐Ÿ‡ผ": {}, + "๐Ÿ‡น๐Ÿ‡ฟ": {}, + "๐Ÿ‡บ๐Ÿ‡ฆ": {}, + "๐Ÿ‡บ๐Ÿ‡ฌ": {}, + "๐Ÿ‡บ๐Ÿ‡ฒ": {}, + "๐Ÿ‡บ๐Ÿ‡ณ": {}, + "๐Ÿ‡บ๐Ÿ‡ธ": {}, + "๐Ÿ‡บ๐Ÿ‡พ": {}, + "๐Ÿ‡บ๐Ÿ‡ฟ": {}, + "๐Ÿ‡ป๐Ÿ‡ฆ": {}, + "๐Ÿ‡ป๐Ÿ‡จ": {}, + "๐Ÿ‡ป๐Ÿ‡ช": {}, + "๐Ÿ‡ป๐Ÿ‡ฌ": {}, + "๐Ÿ‡ป๐Ÿ‡ฎ": {}, + "๐Ÿ‡ป๐Ÿ‡ณ": {}, + "๐Ÿ‡ป๐Ÿ‡บ": {}, + "๐Ÿ‡ผ๐Ÿ‡ซ": {}, + "๐Ÿ‡ผ๐Ÿ‡ธ": {}, + "๐Ÿ‡ฝ๐Ÿ‡ฐ": {}, + "๐Ÿ‡พ๐Ÿ‡ช": {}, + "๐Ÿ‡พ๐Ÿ‡น": {}, + "๐Ÿ‡ฟ๐Ÿ‡ฆ": {}, + "๐Ÿ‡ฟ๐Ÿ‡ฒ": {}, + "๐Ÿ‡ฟ๐Ÿ‡ผ": {}, + "๐Ÿˆ": {}, + "๐Ÿˆ‚๏ธ": {}, + "๐Ÿˆš": {}, + "๐Ÿˆฏ": {}, + "๐Ÿˆฒ": {}, + "๐Ÿˆณ": {}, + "๐Ÿˆด": {}, + "๐Ÿˆต": {}, + "๐Ÿˆถ": {}, + "๐Ÿˆท๏ธ": {}, + "๐Ÿˆธ": {}, + "๐Ÿˆน": {}, + "๐Ÿˆบ": {}, + "๐Ÿ‰": {}, + "๐Ÿ‰‘": {}, + "๐ŸŒ€": {}, + "๐ŸŒ": {}, + "๐ŸŒ‚": {}, + "๐ŸŒƒ": {}, + "๐ŸŒ„": {}, + "๐ŸŒ…": {}, + "๐ŸŒ†": {}, + "๐ŸŒ‡": {}, + "๐ŸŒˆ": {}, + "๐ŸŒ‰": {}, + "๐ŸŒŠ": {}, + "๐ŸŒ‹": {}, + "๐ŸŒŒ": {}, + "๐ŸŒ": {}, + "๐ŸŒŽ": {}, + "๐ŸŒ": {}, + "๐ŸŒ": {}, + "๐ŸŒ‘": {}, + "๐ŸŒ’": {}, + "๐ŸŒ“": {}, + "๐ŸŒ”": {}, + "๐ŸŒ•": {}, + "๐ŸŒ–": {}, + "๐ŸŒ—": {}, + "๐ŸŒ˜": {}, + "๐ŸŒ™": {}, + "๐ŸŒš": {}, + "๐ŸŒ›": {}, + "๐ŸŒœ": {}, + "๐ŸŒ": {}, + "๐ŸŒž": {}, + "๐ŸŒŸ": {}, + "๐ŸŒ ": {}, + "๐ŸŒก๏ธ": {}, + "๐ŸŒค๏ธ": {}, + "๐ŸŒฅ๏ธ": {}, + "๐ŸŒฆ๏ธ": {}, + "๐ŸŒง๏ธ": {}, + "๐ŸŒจ๏ธ": {}, + "๐ŸŒฉ๏ธ": {}, + "๐ŸŒช๏ธ": {}, + "๐ŸŒซ๏ธ": {}, + "๐ŸŒฌ๏ธ": {}, + "๐ŸŒญ": {}, + "๐ŸŒฎ": {}, + "๐ŸŒฏ": {}, + "๐ŸŒฐ": {}, + "๐ŸŒฑ": {}, + "๐ŸŒฒ": {}, + "๐ŸŒณ": {}, + "๐ŸŒด": {}, + "๐ŸŒต": {}, + "๐ŸŒถ๏ธ": {}, + "๐ŸŒท": {}, + "๐ŸŒธ": {}, + "๐ŸŒน": {}, + "๐ŸŒบ": {}, + "๐ŸŒป": {}, + "๐ŸŒผ": {}, + "๐ŸŒฝ": {}, + "๐ŸŒพ": {}, + "๐ŸŒฟ": {}, + "๐Ÿ€": {}, + "๐Ÿ": {}, + "๐Ÿ‚": {}, + "๐Ÿƒ": {}, + "๐Ÿ„": {}, + "๐Ÿ„\u200d๐ŸŸซ": {}, + "๐Ÿ…": {}, + "๐Ÿ†": {}, + "๐Ÿ‡": {}, + "๐Ÿˆ": {}, + "๐Ÿ‰": {}, + "๐ŸŠ": {}, + "๐Ÿ‹": {}, + "๐Ÿ‹\u200d๐ŸŸฉ": {}, + "๐ŸŒ": {}, + "๐Ÿ": {}, + "๐ŸŽ": {}, + "๐Ÿ": {}, + "๐Ÿ": {}, + "๐Ÿ‘": {}, + "๐Ÿ’": {}, + "๐Ÿ“": {}, + "๐Ÿ”": {}, + "๐Ÿ•": {}, + "๐Ÿ–": {}, + "๐Ÿ—": {}, + "๐Ÿ˜": {}, + "๐Ÿ™": {}, + "๐Ÿš": {}, + "๐Ÿ›": {}, + "๐Ÿœ": {}, + "๐Ÿ": {}, + "๐Ÿž": {}, + "๐ŸŸ": {}, + "๐Ÿ ": {}, + "๐Ÿก": {}, + "๐Ÿข": {}, + "๐Ÿฃ": {}, + "๐Ÿค": {}, + "๐Ÿฅ": {}, + "๐Ÿฆ": {}, + "๐Ÿง": {}, + "๐Ÿจ": {}, + "๐Ÿฉ": {}, + "๐Ÿช": {}, + "๐Ÿซ": {}, + "๐Ÿฌ": {}, + "๐Ÿญ": {}, + "๐Ÿฎ": {}, + "๐Ÿฏ": {}, + "๐Ÿฐ": {}, + "๐Ÿฑ": {}, + "๐Ÿฒ": {}, + "๐Ÿณ": {}, + "๐Ÿด": {}, + "๐Ÿต": {}, + "๐Ÿถ": {}, + "๐Ÿท": {}, + "๐Ÿธ": {}, + "๐Ÿน": {}, + "๐Ÿบ": {}, + "๐Ÿป": {}, + "๐Ÿผ": {}, + "๐Ÿฝ๏ธ": {}, + "๐Ÿพ": {}, + "๐Ÿฟ": {}, + "๐ŸŽ€": {}, + "๐ŸŽ": {}, + "๐ŸŽ‚": {}, + "๐ŸŽƒ": {}, + "๐ŸŽ„": {}, + "๐ŸŽ…": {}, + "๐ŸŽ…๐Ÿป": {}, + "๐ŸŽ…๐Ÿผ": {}, + "๐ŸŽ…๐Ÿฝ": {}, + "๐ŸŽ…๐Ÿพ": {}, + "๐ŸŽ…๐Ÿฟ": {}, + "๐ŸŽ†": {}, + "๐ŸŽ‡": {}, + "๐ŸŽˆ": {}, + "๐ŸŽ‰": {}, + "๐ŸŽŠ": {}, + "๐ŸŽ‹": {}, + "๐ŸŽŒ": {}, + "๐ŸŽ": {}, + "๐ŸŽŽ": {}, + "๐ŸŽ": {}, + "๐ŸŽ": {}, + "๐ŸŽ‘": {}, + "๐ŸŽ’": {}, + "๐ŸŽ“": {}, + "๐ŸŽ–๏ธ": {}, + "๐ŸŽ—๏ธ": {}, + "๐ŸŽ™๏ธ": {}, + "๐ŸŽš๏ธ": {}, + "๐ŸŽ›๏ธ": {}, + "๐ŸŽž๏ธ": {}, + "๐ŸŽŸ๏ธ": {}, + "๐ŸŽ ": {}, + "๐ŸŽก": {}, + "๐ŸŽข": {}, + "๐ŸŽฃ": {}, + "๐ŸŽค": {}, + "๐ŸŽฅ": {}, + "๐ŸŽฆ": {}, + "๐ŸŽง": {}, + "๐ŸŽจ": {}, + "๐ŸŽฉ": {}, + "๐ŸŽช": {}, + "๐ŸŽซ": {}, + "๐ŸŽฌ": {}, + "๐ŸŽญ": {}, + "๐ŸŽฎ": {}, + "๐ŸŽฏ": {}, + "๐ŸŽฐ": {}, + "๐ŸŽฑ": {}, + "๐ŸŽฒ": {}, + "๐ŸŽณ": {}, + "๐ŸŽด": {}, + "๐ŸŽต": {}, + "๐ŸŽถ": {}, + "๐ŸŽท": {}, + "๐ŸŽธ": {}, + "๐ŸŽน": {}, + "๐ŸŽบ": {}, + "๐ŸŽป": {}, + "๐ŸŽผ": {}, + "๐ŸŽฝ": {}, + "๐ŸŽพ": {}, + "๐ŸŽฟ": {}, + "๐Ÿ€": {}, + "๐Ÿ": {}, + "๐Ÿ‚": {}, + "๐Ÿ‚๐Ÿป": {}, + "๐Ÿ‚๐Ÿผ": {}, + "๐Ÿ‚๐Ÿฝ": {}, + "๐Ÿ‚๐Ÿพ": {}, + "๐Ÿ‚๐Ÿฟ": {}, + "๐Ÿƒ": {}, + "๐Ÿƒ\u200dโ™€๏ธ": {}, + "๐Ÿƒ\u200dโ™€๏ธ\u200dโžก๏ธ": {}, + "๐Ÿƒ\u200dโ™‚๏ธ": {}, + "๐Ÿƒ\u200dโ™‚๏ธ\u200dโžก๏ธ": {}, + "๐Ÿƒ\u200dโžก๏ธ": {}, + "๐Ÿƒ๐Ÿป": {}, + "๐Ÿƒ๐Ÿป\u200dโ™€๏ธ": {}, + "๐Ÿƒ๐Ÿป\u200dโ™€๏ธ\u200dโžก๏ธ": {}, + "๐Ÿƒ๐Ÿป\u200dโ™‚๏ธ": {}, + "๐Ÿƒ๐Ÿป\u200dโ™‚๏ธ\u200dโžก๏ธ": {}, + "๐Ÿƒ๐Ÿป\u200dโžก๏ธ": {}, + "๐Ÿƒ๐Ÿผ": {}, + "๐Ÿƒ๐Ÿผ\u200dโ™€๏ธ": {}, + "๐Ÿƒ๐Ÿผ\u200dโ™€๏ธ\u200dโžก๏ธ": {}, + "๐Ÿƒ๐Ÿผ\u200dโ™‚๏ธ": {}, + "๐Ÿƒ๐Ÿผ\u200dโ™‚๏ธ\u200dโžก๏ธ": {}, + "๐Ÿƒ๐Ÿผ\u200dโžก๏ธ": {}, + "๐Ÿƒ๐Ÿฝ": {}, + "๐Ÿƒ๐Ÿฝ\u200dโ™€๏ธ": {}, + "๐Ÿƒ๐Ÿฝ\u200dโ™€๏ธ\u200dโžก๏ธ": {}, + "๐Ÿƒ๐Ÿฝ\u200dโ™‚๏ธ": {}, + "๐Ÿƒ๐Ÿฝ\u200dโ™‚๏ธ\u200dโžก๏ธ": {}, + "๐Ÿƒ๐Ÿฝ\u200dโžก๏ธ": {}, + "๐Ÿƒ๐Ÿพ": {}, + "๐Ÿƒ๐Ÿพ\u200dโ™€๏ธ": {}, + "๐Ÿƒ๐Ÿพ\u200dโ™€๏ธ\u200dโžก๏ธ": {}, + "๐Ÿƒ๐Ÿพ\u200dโ™‚๏ธ": {}, + "๐Ÿƒ๐Ÿพ\u200dโ™‚๏ธ\u200dโžก๏ธ": {}, + "๐Ÿƒ๐Ÿพ\u200dโžก๏ธ": {}, + "๐Ÿƒ๐Ÿฟ": {}, + "๐Ÿƒ๐Ÿฟ\u200dโ™€๏ธ": {}, + "๐Ÿƒ๐Ÿฟ\u200dโ™€๏ธ\u200dโžก๏ธ": {}, + "๐Ÿƒ๐Ÿฟ\u200dโ™‚๏ธ": {}, + "๐Ÿƒ๐Ÿฟ\u200dโ™‚๏ธ\u200dโžก๏ธ": {}, + "๐Ÿƒ๐Ÿฟ\u200dโžก๏ธ": {}, + "๐Ÿ„": {}, + "๐Ÿ„\u200dโ™€๏ธ": {}, + "๐Ÿ„\u200dโ™‚๏ธ": {}, + "๐Ÿ„๐Ÿป": {}, + "๐Ÿ„๐Ÿป\u200dโ™€๏ธ": {}, + "๐Ÿ„๐Ÿป\u200dโ™‚๏ธ": {}, + "๐Ÿ„๐Ÿผ": {}, + "๐Ÿ„๐Ÿผ\u200dโ™€๏ธ": {}, + "๐Ÿ„๐Ÿผ\u200dโ™‚๏ธ": {}, + "๐Ÿ„๐Ÿฝ": {}, + "๐Ÿ„๐Ÿฝ\u200dโ™€๏ธ": {}, + "๐Ÿ„๐Ÿฝ\u200dโ™‚๏ธ": {}, + "๐Ÿ„๐Ÿพ": {}, + "๐Ÿ„๐Ÿพ\u200dโ™€๏ธ": {}, + "๐Ÿ„๐Ÿพ\u200dโ™‚๏ธ": {}, + "๐Ÿ„๐Ÿฟ": {}, + "๐Ÿ„๐Ÿฟ\u200dโ™€๏ธ": {}, + "๐Ÿ„๐Ÿฟ\u200dโ™‚๏ธ": {}, + "๐Ÿ…": {}, + "๐Ÿ†": {}, + "๐Ÿ‡": {}, + "๐Ÿ‡๐Ÿป": {}, + "๐Ÿ‡๐Ÿผ": {}, + "๐Ÿ‡๐Ÿฝ": {}, + "๐Ÿ‡๐Ÿพ": {}, + "๐Ÿ‡๐Ÿฟ": {}, + "๐Ÿˆ": {}, + "๐Ÿ‰": {}, + "๐ŸŠ": {}, + "๐ŸŠ\u200dโ™€๏ธ": {}, + "๐ŸŠ\u200dโ™‚๏ธ": {}, + "๐ŸŠ๐Ÿป": {}, + "๐ŸŠ๐Ÿป\u200dโ™€๏ธ": {}, + "๐ŸŠ๐Ÿป\u200dโ™‚๏ธ": {}, + "๐ŸŠ๐Ÿผ": {}, + "๐ŸŠ๐Ÿผ\u200dโ™€๏ธ": {}, + "๐ŸŠ๐Ÿผ\u200dโ™‚๏ธ": {}, + "๐ŸŠ๐Ÿฝ": {}, + "๐ŸŠ๐Ÿฝ\u200dโ™€๏ธ": {}, + "๐ŸŠ๐Ÿฝ\u200dโ™‚๏ธ": {}, + "๐ŸŠ๐Ÿพ": {}, + "๐ŸŠ๐Ÿพ\u200dโ™€๏ธ": {}, + "๐ŸŠ๐Ÿพ\u200dโ™‚๏ธ": {}, + "๐ŸŠ๐Ÿฟ": {}, + "๐ŸŠ๐Ÿฟ\u200dโ™€๏ธ": {}, + "๐ŸŠ๐Ÿฟ\u200dโ™‚๏ธ": {}, + "๐Ÿ‹๏ธ": {}, + "๐Ÿ‹๏ธ\u200dโ™€๏ธ": {}, + "๐Ÿ‹๏ธ\u200dโ™‚๏ธ": {}, + "๐Ÿ‹๐Ÿป": {}, + "๐Ÿ‹๐Ÿป\u200dโ™€๏ธ": {}, + "๐Ÿ‹๐Ÿป\u200dโ™‚๏ธ": {}, + "๐Ÿ‹๐Ÿผ": {}, + "๐Ÿ‹๐Ÿผ\u200dโ™€๏ธ": {}, + "๐Ÿ‹๐Ÿผ\u200dโ™‚๏ธ": {}, + "๐Ÿ‹๐Ÿฝ": {}, + "๐Ÿ‹๐Ÿฝ\u200dโ™€๏ธ": {}, + "๐Ÿ‹๐Ÿฝ\u200dโ™‚๏ธ": {}, + "๐Ÿ‹๐Ÿพ": {}, + "๐Ÿ‹๐Ÿพ\u200dโ™€๏ธ": {}, + "๐Ÿ‹๐Ÿพ\u200dโ™‚๏ธ": {}, + "๐Ÿ‹๐Ÿฟ": {}, + "๐Ÿ‹๐Ÿฟ\u200dโ™€๏ธ": {}, + "๐Ÿ‹๐Ÿฟ\u200dโ™‚๏ธ": {}, + "๐ŸŒ๏ธ": {}, + "๐ŸŒ๏ธ\u200dโ™€๏ธ": {}, + "๐ŸŒ๏ธ\u200dโ™‚๏ธ": {}, + "๐ŸŒ๐Ÿป": {}, + "๐ŸŒ๐Ÿป\u200dโ™€๏ธ": {}, + "๐ŸŒ๐Ÿป\u200dโ™‚๏ธ": {}, + "๐ŸŒ๐Ÿผ": {}, + "๐ŸŒ๐Ÿผ\u200dโ™€๏ธ": {}, + "๐ŸŒ๐Ÿผ\u200dโ™‚๏ธ": {}, + "๐ŸŒ๐Ÿฝ": {}, + "๐ŸŒ๐Ÿฝ\u200dโ™€๏ธ": {}, + "๐ŸŒ๐Ÿฝ\u200dโ™‚๏ธ": {}, + "๐ŸŒ๐Ÿพ": {}, + "๐ŸŒ๐Ÿพ\u200dโ™€๏ธ": {}, + "๐ŸŒ๐Ÿพ\u200dโ™‚๏ธ": {}, + "๐ŸŒ๐Ÿฟ": {}, + "๐ŸŒ๐Ÿฟ\u200dโ™€๏ธ": {}, + "๐ŸŒ๐Ÿฟ\u200dโ™‚๏ธ": {}, + "๐Ÿ๏ธ": {}, + "๐ŸŽ๏ธ": {}, + "๐Ÿ": {}, + "๐Ÿ": {}, + "๐Ÿ‘": {}, + "๐Ÿ’": {}, + "๐Ÿ“": {}, + "๐Ÿ”๏ธ": {}, + "๐Ÿ•๏ธ": {}, + "๐Ÿ–๏ธ": {}, + "๐Ÿ—๏ธ": {}, + "๐Ÿ˜๏ธ": {}, + "๐Ÿ™๏ธ": {}, + "๐Ÿš๏ธ": {}, + "๐Ÿ›๏ธ": {}, + "๐Ÿœ๏ธ": {}, + "๐Ÿ๏ธ": {}, + "๐Ÿž๏ธ": {}, + "๐ŸŸ๏ธ": {}, + "๐Ÿ ": {}, + "๐Ÿก": {}, + "๐Ÿข": {}, + "๐Ÿฃ": {}, + "๐Ÿค": {}, + "๐Ÿฅ": {}, + "๐Ÿฆ": {}, + "๐Ÿง": {}, + "๐Ÿจ": {}, + "๐Ÿฉ": {}, + "๐Ÿช": {}, + "๐Ÿซ": {}, + "๐Ÿฌ": {}, + "๐Ÿญ": {}, + "๐Ÿฎ": {}, + "๐Ÿฏ": {}, + "๐Ÿฐ": {}, + "๐Ÿณ๏ธ": {}, + "๐Ÿณ๏ธ\u200dโšง๏ธ": {}, + "๐Ÿณ๏ธ\u200d๐ŸŒˆ": {}, + "๐Ÿด": {}, + "๐Ÿด\u200dโ˜ ๏ธ": {}, + "๐Ÿด\U000e0067\U000e0062\U000e0065\U000e006e\U000e0067\U000e007f": {}, + "๐Ÿด\U000e0067\U000e0062\U000e0073\U000e0063\U000e0074\U000e007f": {}, + "๐Ÿด\U000e0067\U000e0062\U000e0077\U000e006c\U000e0073\U000e007f": {}, + "๐Ÿต๏ธ": {}, + "๐Ÿท๏ธ": {}, + "๐Ÿธ": {}, + "๐Ÿน": {}, + "๐Ÿบ": {}, + "๐Ÿ€": {}, + "๐Ÿ": {}, + "๐Ÿ‚": {}, + "๐Ÿƒ": {}, + "๐Ÿ„": {}, + "๐Ÿ…": {}, + "๐Ÿ†": {}, + "๐Ÿ‡": {}, + "๐Ÿˆ": {}, + "๐Ÿˆ\u200dโฌ›": {}, + "๐Ÿ‰": {}, + "๐ŸŠ": {}, + "๐Ÿ‹": {}, + "๐ŸŒ": {}, + "๐Ÿ": {}, + "๐ŸŽ": {}, + "๐Ÿ": {}, + "๐Ÿ": {}, + "๐Ÿ‘": {}, + "๐Ÿ’": {}, + "๐Ÿ“": {}, + "๐Ÿ”": {}, + "๐Ÿ•": {}, + "๐Ÿ•\u200d๐Ÿฆบ": {}, + "๐Ÿ–": {}, + "๐Ÿ—": {}, + "๐Ÿ˜": {}, + "๐Ÿ™": {}, + "๐Ÿš": {}, + "๐Ÿ›": {}, + "๐Ÿœ": {}, + "๐Ÿ": {}, + "๐Ÿž": {}, + "๐ŸŸ": {}, + "๐Ÿ ": {}, + "๐Ÿก": {}, + "๐Ÿข": {}, + "๐Ÿฃ": {}, + "๐Ÿค": {}, + "๐Ÿฅ": {}, + "๐Ÿฆ": {}, + "๐Ÿฆ\u200dโฌ›": {}, + "๐Ÿฆ\u200d๐Ÿ”ฅ": {}, + "๐Ÿง": {}, + "๐Ÿจ": {}, + "๐Ÿฉ": {}, + "๐Ÿช": {}, + "๐Ÿซ": {}, + "๐Ÿฌ": {}, + "๐Ÿญ": {}, + "๐Ÿฎ": {}, + "๐Ÿฏ": {}, + "๐Ÿฐ": {}, + "๐Ÿฑ": {}, + "๐Ÿฒ": {}, + "๐Ÿณ": {}, + "๐Ÿด": {}, + "๐Ÿต": {}, + "๐Ÿถ": {}, + "๐Ÿท": {}, + "๐Ÿธ": {}, + "๐Ÿน": {}, + "๐Ÿบ": {}, + "๐Ÿป": {}, + "๐Ÿป\u200dโ„๏ธ": {}, + "๐Ÿผ": {}, + "๐Ÿฝ": {}, + "๐Ÿพ": {}, + "๐Ÿฟ๏ธ": {}, + "๐Ÿ‘€": {}, + "๐Ÿ‘๏ธ": {}, + "๐Ÿ‘๏ธ\u200d๐Ÿ—จ๏ธ": {}, + "๐Ÿ‘‚": {}, + "๐Ÿ‘‚๐Ÿป": {}, + "๐Ÿ‘‚๐Ÿผ": {}, + "๐Ÿ‘‚๐Ÿฝ": {}, + "๐Ÿ‘‚๐Ÿพ": {}, + "๐Ÿ‘‚๐Ÿฟ": {}, + "๐Ÿ‘ƒ": {}, + "๐Ÿ‘ƒ๐Ÿป": {}, + "๐Ÿ‘ƒ๐Ÿผ": {}, + "๐Ÿ‘ƒ๐Ÿฝ": {}, + "๐Ÿ‘ƒ๐Ÿพ": {}, + "๐Ÿ‘ƒ๐Ÿฟ": {}, + "๐Ÿ‘„": {}, + "๐Ÿ‘…": {}, + "๐Ÿ‘†": {}, + "๐Ÿ‘†๐Ÿป": {}, + "๐Ÿ‘†๐Ÿผ": {}, + "๐Ÿ‘†๐Ÿฝ": {}, + "๐Ÿ‘†๐Ÿพ": {}, + "๐Ÿ‘†๐Ÿฟ": {}, + "๐Ÿ‘‡": {}, + "๐Ÿ‘‡๐Ÿป": {}, + "๐Ÿ‘‡๐Ÿผ": {}, + "๐Ÿ‘‡๐Ÿฝ": {}, + "๐Ÿ‘‡๐Ÿพ": {}, + "๐Ÿ‘‡๐Ÿฟ": {}, + "๐Ÿ‘ˆ": {}, + "๐Ÿ‘ˆ๐Ÿป": {}, + "๐Ÿ‘ˆ๐Ÿผ": {}, + "๐Ÿ‘ˆ๐Ÿฝ": {}, + "๐Ÿ‘ˆ๐Ÿพ": {}, + "๐Ÿ‘ˆ๐Ÿฟ": {}, + "๐Ÿ‘‰": {}, + "๐Ÿ‘‰๐Ÿป": {}, + "๐Ÿ‘‰๐Ÿผ": {}, + "๐Ÿ‘‰๐Ÿฝ": {}, + "๐Ÿ‘‰๐Ÿพ": {}, + "๐Ÿ‘‰๐Ÿฟ": {}, + "๐Ÿ‘Š": {}, + "๐Ÿ‘Š๐Ÿป": {}, + "๐Ÿ‘Š๐Ÿผ": {}, + "๐Ÿ‘Š๐Ÿฝ": {}, + "๐Ÿ‘Š๐Ÿพ": {}, + "๐Ÿ‘Š๐Ÿฟ": {}, + "๐Ÿ‘‹": {}, + "๐Ÿ‘‹๐Ÿป": {}, + "๐Ÿ‘‹๐Ÿผ": {}, + "๐Ÿ‘‹๐Ÿฝ": {}, + "๐Ÿ‘‹๐Ÿพ": {}, + "๐Ÿ‘‹๐Ÿฟ": {}, + "๐Ÿ‘Œ": {}, + "๐Ÿ‘Œ๐Ÿป": {}, + "๐Ÿ‘Œ๐Ÿผ": {}, + "๐Ÿ‘Œ๐Ÿฝ": {}, + "๐Ÿ‘Œ๐Ÿพ": {}, + "๐Ÿ‘Œ๐Ÿฟ": {}, + "๐Ÿ‘": {}, + "๐Ÿ‘๐Ÿป": {}, + "๐Ÿ‘๐Ÿผ": {}, + "๐Ÿ‘๐Ÿฝ": {}, + "๐Ÿ‘๐Ÿพ": {}, + "๐Ÿ‘๐Ÿฟ": {}, + "๐Ÿ‘Ž": {}, + "๐Ÿ‘Ž๐Ÿป": {}, + "๐Ÿ‘Ž๐Ÿผ": {}, + "๐Ÿ‘Ž๐Ÿฝ": {}, + "๐Ÿ‘Ž๐Ÿพ": {}, + "๐Ÿ‘Ž๐Ÿฟ": {}, + "๐Ÿ‘": {}, + "๐Ÿ‘๐Ÿป": {}, + "๐Ÿ‘๐Ÿผ": {}, + "๐Ÿ‘๐Ÿฝ": {}, + "๐Ÿ‘๐Ÿพ": {}, + "๐Ÿ‘๐Ÿฟ": {}, + "๐Ÿ‘": {}, + "๐Ÿ‘๐Ÿป": {}, + "๐Ÿ‘๐Ÿผ": {}, + "๐Ÿ‘๐Ÿฝ": {}, + "๐Ÿ‘๐Ÿพ": {}, + "๐Ÿ‘๐Ÿฟ": {}, + "๐Ÿ‘‘": {}, + "๐Ÿ‘’": {}, + "๐Ÿ‘“": {}, + "๐Ÿ‘”": {}, + "๐Ÿ‘•": {}, + "๐Ÿ‘–": {}, + "๐Ÿ‘—": {}, + "๐Ÿ‘˜": {}, + "๐Ÿ‘™": {}, + "๐Ÿ‘š": {}, + "๐Ÿ‘›": {}, + "๐Ÿ‘œ": {}, + "๐Ÿ‘": {}, + "๐Ÿ‘ž": {}, + "๐Ÿ‘Ÿ": {}, + "๐Ÿ‘ ": {}, + "๐Ÿ‘ก": {}, + "๐Ÿ‘ข": {}, + "๐Ÿ‘ฃ": {}, + "๐Ÿ‘ค": {}, + "๐Ÿ‘ฅ": {}, + "๐Ÿ‘ฆ": {}, + "๐Ÿ‘ฆ๐Ÿป": {}, + "๐Ÿ‘ฆ๐Ÿผ": {}, + "๐Ÿ‘ฆ๐Ÿฝ": {}, + "๐Ÿ‘ฆ๐Ÿพ": {}, + "๐Ÿ‘ฆ๐Ÿฟ": {}, + "๐Ÿ‘ง": {}, + "๐Ÿ‘ง๐Ÿป": {}, + "๐Ÿ‘ง๐Ÿผ": {}, + "๐Ÿ‘ง๐Ÿฝ": {}, + "๐Ÿ‘ง๐Ÿพ": {}, + "๐Ÿ‘ง๐Ÿฟ": {}, + "๐Ÿ‘จ": {}, + "๐Ÿ‘จ\u200dโš•๏ธ": {}, + "๐Ÿ‘จ\u200dโš–๏ธ": {}, + "๐Ÿ‘จ\u200dโœˆ๏ธ": {}, + "๐Ÿ‘จ\u200dโค๏ธ\u200d๐Ÿ‘จ": {}, + "๐Ÿ‘จ\u200dโค๏ธ\u200d๐Ÿ’‹\u200d๐Ÿ‘จ": {}, + "๐Ÿ‘จ\u200d๐ŸŒพ": {}, + "๐Ÿ‘จ\u200d๐Ÿณ": {}, + "๐Ÿ‘จ\u200d๐Ÿผ": {}, + "๐Ÿ‘จ\u200d๐ŸŽ“": {}, + "๐Ÿ‘จ\u200d๐ŸŽค": {}, + "๐Ÿ‘จ\u200d๐ŸŽจ": {}, + "๐Ÿ‘จ\u200d๐Ÿซ": {}, + "๐Ÿ‘จ\u200d๐Ÿญ": {}, + "๐Ÿ‘จ\u200d๐Ÿ‘ฆ": {}, + "๐Ÿ‘จ\u200d๐Ÿ‘ฆ\u200d๐Ÿ‘ฆ": {}, + "๐Ÿ‘จ\u200d๐Ÿ‘ง": {}, + "๐Ÿ‘จ\u200d๐Ÿ‘ง\u200d๐Ÿ‘ฆ": {}, + "๐Ÿ‘จ\u200d๐Ÿ‘ง\u200d๐Ÿ‘ง": {}, + "๐Ÿ‘จ\u200d๐Ÿ‘จ\u200d๐Ÿ‘ฆ": {}, + "๐Ÿ‘จ\u200d๐Ÿ‘จ\u200d๐Ÿ‘ฆ\u200d๐Ÿ‘ฆ": {}, + "๐Ÿ‘จ\u200d๐Ÿ‘จ\u200d๐Ÿ‘ง": {}, + "๐Ÿ‘จ\u200d๐Ÿ‘จ\u200d๐Ÿ‘ง\u200d๐Ÿ‘ฆ": {}, + "๐Ÿ‘จ\u200d๐Ÿ‘จ\u200d๐Ÿ‘ง\u200d๐Ÿ‘ง": {}, + "๐Ÿ‘จ\u200d๐Ÿ‘ฉ\u200d๐Ÿ‘ฆ": {}, + "๐Ÿ‘จ\u200d๐Ÿ‘ฉ\u200d๐Ÿ‘ฆ\u200d๐Ÿ‘ฆ": {}, + "๐Ÿ‘จ\u200d๐Ÿ‘ฉ\u200d๐Ÿ‘ง": {}, + "๐Ÿ‘จ\u200d๐Ÿ‘ฉ\u200d๐Ÿ‘ง\u200d๐Ÿ‘ฆ": {}, + "๐Ÿ‘จ\u200d๐Ÿ‘ฉ\u200d๐Ÿ‘ง\u200d๐Ÿ‘ง": {}, + "๐Ÿ‘จ\u200d๐Ÿ’ป": {}, + "๐Ÿ‘จ\u200d๐Ÿ’ผ": {}, + "๐Ÿ‘จ\u200d๐Ÿ”ง": {}, + "๐Ÿ‘จ\u200d๐Ÿ”ฌ": {}, + "๐Ÿ‘จ\u200d๐Ÿš€": {}, + "๐Ÿ‘จ\u200d๐Ÿš’": {}, + "๐Ÿ‘จ\u200d๐Ÿฆฏ": {}, + "๐Ÿ‘จ\u200d๐Ÿฆฏ\u200dโžก๏ธ": {}, + "๐Ÿ‘จ\u200d๐Ÿฆฐ": {}, + "๐Ÿ‘จ\u200d๐Ÿฆฑ": {}, + "๐Ÿ‘จ\u200d๐Ÿฆฒ": {}, + "๐Ÿ‘จ\u200d๐Ÿฆณ": {}, + "๐Ÿ‘จ\u200d๐Ÿฆผ": {}, + "๐Ÿ‘จ\u200d๐Ÿฆผ\u200dโžก๏ธ": {}, + "๐Ÿ‘จ\u200d๐Ÿฆฝ": {}, + "๐Ÿ‘จ\u200d๐Ÿฆฝ\u200dโžก๏ธ": {}, + "๐Ÿ‘จ๐Ÿป": {}, + "๐Ÿ‘จ๐Ÿป\u200dโš•๏ธ": {}, + "๐Ÿ‘จ๐Ÿป\u200dโš–๏ธ": {}, + "๐Ÿ‘จ๐Ÿป\u200dโœˆ๏ธ": {}, + "๐Ÿ‘จ๐Ÿป\u200dโค๏ธ\u200d๐Ÿ‘จ๐Ÿป": {}, + "๐Ÿ‘จ๐Ÿป\u200dโค๏ธ\u200d๐Ÿ‘จ๐Ÿผ": {}, + "๐Ÿ‘จ๐Ÿป\u200dโค๏ธ\u200d๐Ÿ‘จ๐Ÿฝ": {}, + "๐Ÿ‘จ๐Ÿป\u200dโค๏ธ\u200d๐Ÿ‘จ๐Ÿพ": {}, + "๐Ÿ‘จ๐Ÿป\u200dโค๏ธ\u200d๐Ÿ‘จ๐Ÿฟ": {}, + "๐Ÿ‘จ๐Ÿป\u200dโค๏ธ\u200d๐Ÿ’‹\u200d๐Ÿ‘จ๐Ÿป": {}, + "๐Ÿ‘จ๐Ÿป\u200dโค๏ธ\u200d๐Ÿ’‹\u200d๐Ÿ‘จ๐Ÿผ": {}, + "๐Ÿ‘จ๐Ÿป\u200dโค๏ธ\u200d๐Ÿ’‹\u200d๐Ÿ‘จ๐Ÿฝ": {}, + "๐Ÿ‘จ๐Ÿป\u200dโค๏ธ\u200d๐Ÿ’‹\u200d๐Ÿ‘จ๐Ÿพ": {}, + "๐Ÿ‘จ๐Ÿป\u200dโค๏ธ\u200d๐Ÿ’‹\u200d๐Ÿ‘จ๐Ÿฟ": {}, + "๐Ÿ‘จ๐Ÿป\u200d๐ŸŒพ": {}, + "๐Ÿ‘จ๐Ÿป\u200d๐Ÿณ": {}, + "๐Ÿ‘จ๐Ÿป\u200d๐Ÿผ": {}, + "๐Ÿ‘จ๐Ÿป\u200d๐ŸŽ“": {}, + "๐Ÿ‘จ๐Ÿป\u200d๐ŸŽค": {}, + "๐Ÿ‘จ๐Ÿป\u200d๐ŸŽจ": {}, + "๐Ÿ‘จ๐Ÿป\u200d๐Ÿซ": {}, + "๐Ÿ‘จ๐Ÿป\u200d๐Ÿญ": {}, + "๐Ÿ‘จ๐Ÿป\u200d๐Ÿฐ\u200d๐Ÿ‘จ๐Ÿผ": {}, + "๐Ÿ‘จ๐Ÿป\u200d๐Ÿฐ\u200d๐Ÿ‘จ๐Ÿฝ": {}, + "๐Ÿ‘จ๐Ÿป\u200d๐Ÿฐ\u200d๐Ÿ‘จ๐Ÿพ": {}, + "๐Ÿ‘จ๐Ÿป\u200d๐Ÿฐ\u200d๐Ÿ‘จ๐Ÿฟ": {}, + "๐Ÿ‘จ๐Ÿป\u200d๐Ÿ’ป": {}, + "๐Ÿ‘จ๐Ÿป\u200d๐Ÿ’ผ": {}, + "๐Ÿ‘จ๐Ÿป\u200d๐Ÿ”ง": {}, + "๐Ÿ‘จ๐Ÿป\u200d๐Ÿ”ฌ": {}, + "๐Ÿ‘จ๐Ÿป\u200d๐Ÿš€": {}, + "๐Ÿ‘จ๐Ÿป\u200d๐Ÿš’": {}, + "๐Ÿ‘จ๐Ÿป\u200d๐Ÿค\u200d๐Ÿ‘จ๐Ÿผ": {}, + "๐Ÿ‘จ๐Ÿป\u200d๐Ÿค\u200d๐Ÿ‘จ๐Ÿฝ": {}, + "๐Ÿ‘จ๐Ÿป\u200d๐Ÿค\u200d๐Ÿ‘จ๐Ÿพ": {}, + "๐Ÿ‘จ๐Ÿป\u200d๐Ÿค\u200d๐Ÿ‘จ๐Ÿฟ": {}, + "๐Ÿ‘จ๐Ÿป\u200d๐Ÿฆฏ": {}, + "๐Ÿ‘จ๐Ÿป\u200d๐Ÿฆฏ\u200dโžก๏ธ": {}, + "๐Ÿ‘จ๐Ÿป\u200d๐Ÿฆฐ": {}, + "๐Ÿ‘จ๐Ÿป\u200d๐Ÿฆฑ": {}, + "๐Ÿ‘จ๐Ÿป\u200d๐Ÿฆฒ": {}, + "๐Ÿ‘จ๐Ÿป\u200d๐Ÿฆณ": {}, + "๐Ÿ‘จ๐Ÿป\u200d๐Ÿฆผ": {}, + "๐Ÿ‘จ๐Ÿป\u200d๐Ÿฆผ\u200dโžก๏ธ": {}, + "๐Ÿ‘จ๐Ÿป\u200d๐Ÿฆฝ": {}, + "๐Ÿ‘จ๐Ÿป\u200d๐Ÿฆฝ\u200dโžก๏ธ": {}, + "๐Ÿ‘จ๐Ÿป\u200d\U0001faef\u200d๐Ÿ‘จ๐Ÿผ": {}, + "๐Ÿ‘จ๐Ÿป\u200d\U0001faef\u200d๐Ÿ‘จ๐Ÿฝ": {}, + "๐Ÿ‘จ๐Ÿป\u200d\U0001faef\u200d๐Ÿ‘จ๐Ÿพ": {}, + "๐Ÿ‘จ๐Ÿป\u200d\U0001faef\u200d๐Ÿ‘จ๐Ÿฟ": {}, + "๐Ÿ‘จ๐Ÿผ": {}, + "๐Ÿ‘จ๐Ÿผ\u200dโš•๏ธ": {}, + "๐Ÿ‘จ๐Ÿผ\u200dโš–๏ธ": {}, + "๐Ÿ‘จ๐Ÿผ\u200dโœˆ๏ธ": {}, + "๐Ÿ‘จ๐Ÿผ\u200dโค๏ธ\u200d๐Ÿ‘จ๐Ÿป": {}, + "๐Ÿ‘จ๐Ÿผ\u200dโค๏ธ\u200d๐Ÿ‘จ๐Ÿผ": {}, + "๐Ÿ‘จ๐Ÿผ\u200dโค๏ธ\u200d๐Ÿ‘จ๐Ÿฝ": {}, + "๐Ÿ‘จ๐Ÿผ\u200dโค๏ธ\u200d๐Ÿ‘จ๐Ÿพ": {}, + "๐Ÿ‘จ๐Ÿผ\u200dโค๏ธ\u200d๐Ÿ‘จ๐Ÿฟ": {}, + "๐Ÿ‘จ๐Ÿผ\u200dโค๏ธ\u200d๐Ÿ’‹\u200d๐Ÿ‘จ๐Ÿป": {}, + "๐Ÿ‘จ๐Ÿผ\u200dโค๏ธ\u200d๐Ÿ’‹\u200d๐Ÿ‘จ๐Ÿผ": {}, + "๐Ÿ‘จ๐Ÿผ\u200dโค๏ธ\u200d๐Ÿ’‹\u200d๐Ÿ‘จ๐Ÿฝ": {}, + "๐Ÿ‘จ๐Ÿผ\u200dโค๏ธ\u200d๐Ÿ’‹\u200d๐Ÿ‘จ๐Ÿพ": {}, + "๐Ÿ‘จ๐Ÿผ\u200dโค๏ธ\u200d๐Ÿ’‹\u200d๐Ÿ‘จ๐Ÿฟ": {}, + "๐Ÿ‘จ๐Ÿผ\u200d๐ŸŒพ": {}, + "๐Ÿ‘จ๐Ÿผ\u200d๐Ÿณ": {}, + "๐Ÿ‘จ๐Ÿผ\u200d๐Ÿผ": {}, + "๐Ÿ‘จ๐Ÿผ\u200d๐ŸŽ“": {}, + "๐Ÿ‘จ๐Ÿผ\u200d๐ŸŽค": {}, + "๐Ÿ‘จ๐Ÿผ\u200d๐ŸŽจ": {}, + "๐Ÿ‘จ๐Ÿผ\u200d๐Ÿซ": {}, + "๐Ÿ‘จ๐Ÿผ\u200d๐Ÿญ": {}, + "๐Ÿ‘จ๐Ÿผ\u200d๐Ÿฐ\u200d๐Ÿ‘จ๐Ÿป": {}, + "๐Ÿ‘จ๐Ÿผ\u200d๐Ÿฐ\u200d๐Ÿ‘จ๐Ÿฝ": {}, + "๐Ÿ‘จ๐Ÿผ\u200d๐Ÿฐ\u200d๐Ÿ‘จ๐Ÿพ": {}, + "๐Ÿ‘จ๐Ÿผ\u200d๐Ÿฐ\u200d๐Ÿ‘จ๐Ÿฟ": {}, + "๐Ÿ‘จ๐Ÿผ\u200d๐Ÿ’ป": {}, + "๐Ÿ‘จ๐Ÿผ\u200d๐Ÿ’ผ": {}, + "๐Ÿ‘จ๐Ÿผ\u200d๐Ÿ”ง": {}, + "๐Ÿ‘จ๐Ÿผ\u200d๐Ÿ”ฌ": {}, + "๐Ÿ‘จ๐Ÿผ\u200d๐Ÿš€": {}, + "๐Ÿ‘จ๐Ÿผ\u200d๐Ÿš’": {}, + "๐Ÿ‘จ๐Ÿผ\u200d๐Ÿค\u200d๐Ÿ‘จ๐Ÿป": {}, + "๐Ÿ‘จ๐Ÿผ\u200d๐Ÿค\u200d๐Ÿ‘จ๐Ÿฝ": {}, + "๐Ÿ‘จ๐Ÿผ\u200d๐Ÿค\u200d๐Ÿ‘จ๐Ÿพ": {}, + "๐Ÿ‘จ๐Ÿผ\u200d๐Ÿค\u200d๐Ÿ‘จ๐Ÿฟ": {}, + "๐Ÿ‘จ๐Ÿผ\u200d๐Ÿฆฏ": {}, + "๐Ÿ‘จ๐Ÿผ\u200d๐Ÿฆฏ\u200dโžก๏ธ": {}, + "๐Ÿ‘จ๐Ÿผ\u200d๐Ÿฆฐ": {}, + "๐Ÿ‘จ๐Ÿผ\u200d๐Ÿฆฑ": {}, + "๐Ÿ‘จ๐Ÿผ\u200d๐Ÿฆฒ": {}, + "๐Ÿ‘จ๐Ÿผ\u200d๐Ÿฆณ": {}, + "๐Ÿ‘จ๐Ÿผ\u200d๐Ÿฆผ": {}, + "๐Ÿ‘จ๐Ÿผ\u200d๐Ÿฆผ\u200dโžก๏ธ": {}, + "๐Ÿ‘จ๐Ÿผ\u200d๐Ÿฆฝ": {}, + "๐Ÿ‘จ๐Ÿผ\u200d๐Ÿฆฝ\u200dโžก๏ธ": {}, + "๐Ÿ‘จ๐Ÿผ\u200d\U0001faef\u200d๐Ÿ‘จ๐Ÿป": {}, + "๐Ÿ‘จ๐Ÿผ\u200d\U0001faef\u200d๐Ÿ‘จ๐Ÿฝ": {}, + "๐Ÿ‘จ๐Ÿผ\u200d\U0001faef\u200d๐Ÿ‘จ๐Ÿพ": {}, + "๐Ÿ‘จ๐Ÿผ\u200d\U0001faef\u200d๐Ÿ‘จ๐Ÿฟ": {}, + "๐Ÿ‘จ๐Ÿฝ": {}, + "๐Ÿ‘จ๐Ÿฝ\u200dโš•๏ธ": {}, + "๐Ÿ‘จ๐Ÿฝ\u200dโš–๏ธ": {}, + "๐Ÿ‘จ๐Ÿฝ\u200dโœˆ๏ธ": {}, + "๐Ÿ‘จ๐Ÿฝ\u200dโค๏ธ\u200d๐Ÿ‘จ๐Ÿป": {}, + "๐Ÿ‘จ๐Ÿฝ\u200dโค๏ธ\u200d๐Ÿ‘จ๐Ÿผ": {}, + "๐Ÿ‘จ๐Ÿฝ\u200dโค๏ธ\u200d๐Ÿ‘จ๐Ÿฝ": {}, + "๐Ÿ‘จ๐Ÿฝ\u200dโค๏ธ\u200d๐Ÿ‘จ๐Ÿพ": {}, + "๐Ÿ‘จ๐Ÿฝ\u200dโค๏ธ\u200d๐Ÿ‘จ๐Ÿฟ": {}, + "๐Ÿ‘จ๐Ÿฝ\u200dโค๏ธ\u200d๐Ÿ’‹\u200d๐Ÿ‘จ๐Ÿป": {}, + "๐Ÿ‘จ๐Ÿฝ\u200dโค๏ธ\u200d๐Ÿ’‹\u200d๐Ÿ‘จ๐Ÿผ": {}, + "๐Ÿ‘จ๐Ÿฝ\u200dโค๏ธ\u200d๐Ÿ’‹\u200d๐Ÿ‘จ๐Ÿฝ": {}, + "๐Ÿ‘จ๐Ÿฝ\u200dโค๏ธ\u200d๐Ÿ’‹\u200d๐Ÿ‘จ๐Ÿพ": {}, + "๐Ÿ‘จ๐Ÿฝ\u200dโค๏ธ\u200d๐Ÿ’‹\u200d๐Ÿ‘จ๐Ÿฟ": {}, + "๐Ÿ‘จ๐Ÿฝ\u200d๐ŸŒพ": {}, + "๐Ÿ‘จ๐Ÿฝ\u200d๐Ÿณ": {}, + "๐Ÿ‘จ๐Ÿฝ\u200d๐Ÿผ": {}, + "๐Ÿ‘จ๐Ÿฝ\u200d๐ŸŽ“": {}, + "๐Ÿ‘จ๐Ÿฝ\u200d๐ŸŽค": {}, + "๐Ÿ‘จ๐Ÿฝ\u200d๐ŸŽจ": {}, + "๐Ÿ‘จ๐Ÿฝ\u200d๐Ÿซ": {}, + "๐Ÿ‘จ๐Ÿฝ\u200d๐Ÿญ": {}, + "๐Ÿ‘จ๐Ÿฝ\u200d๐Ÿฐ\u200d๐Ÿ‘จ๐Ÿป": {}, + "๐Ÿ‘จ๐Ÿฝ\u200d๐Ÿฐ\u200d๐Ÿ‘จ๐Ÿผ": {}, + "๐Ÿ‘จ๐Ÿฝ\u200d๐Ÿฐ\u200d๐Ÿ‘จ๐Ÿพ": {}, + "๐Ÿ‘จ๐Ÿฝ\u200d๐Ÿฐ\u200d๐Ÿ‘จ๐Ÿฟ": {}, + "๐Ÿ‘จ๐Ÿฝ\u200d๐Ÿ’ป": {}, + "๐Ÿ‘จ๐Ÿฝ\u200d๐Ÿ’ผ": {}, + "๐Ÿ‘จ๐Ÿฝ\u200d๐Ÿ”ง": {}, + "๐Ÿ‘จ๐Ÿฝ\u200d๐Ÿ”ฌ": {}, + "๐Ÿ‘จ๐Ÿฝ\u200d๐Ÿš€": {}, + "๐Ÿ‘จ๐Ÿฝ\u200d๐Ÿš’": {}, + "๐Ÿ‘จ๐Ÿฝ\u200d๐Ÿค\u200d๐Ÿ‘จ๐Ÿป": {}, + "๐Ÿ‘จ๐Ÿฝ\u200d๐Ÿค\u200d๐Ÿ‘จ๐Ÿผ": {}, + "๐Ÿ‘จ๐Ÿฝ\u200d๐Ÿค\u200d๐Ÿ‘จ๐Ÿพ": {}, + "๐Ÿ‘จ๐Ÿฝ\u200d๐Ÿค\u200d๐Ÿ‘จ๐Ÿฟ": {}, + "๐Ÿ‘จ๐Ÿฝ\u200d๐Ÿฆฏ": {}, + "๐Ÿ‘จ๐Ÿฝ\u200d๐Ÿฆฏ\u200dโžก๏ธ": {}, + "๐Ÿ‘จ๐Ÿฝ\u200d๐Ÿฆฐ": {}, + "๐Ÿ‘จ๐Ÿฝ\u200d๐Ÿฆฑ": {}, + "๐Ÿ‘จ๐Ÿฝ\u200d๐Ÿฆฒ": {}, + "๐Ÿ‘จ๐Ÿฝ\u200d๐Ÿฆณ": {}, + "๐Ÿ‘จ๐Ÿฝ\u200d๐Ÿฆผ": {}, + "๐Ÿ‘จ๐Ÿฝ\u200d๐Ÿฆผ\u200dโžก๏ธ": {}, + "๐Ÿ‘จ๐Ÿฝ\u200d๐Ÿฆฝ": {}, + "๐Ÿ‘จ๐Ÿฝ\u200d๐Ÿฆฝ\u200dโžก๏ธ": {}, + "๐Ÿ‘จ๐Ÿฝ\u200d\U0001faef\u200d๐Ÿ‘จ๐Ÿป": {}, + "๐Ÿ‘จ๐Ÿฝ\u200d\U0001faef\u200d๐Ÿ‘จ๐Ÿผ": {}, + "๐Ÿ‘จ๐Ÿฝ\u200d\U0001faef\u200d๐Ÿ‘จ๐Ÿพ": {}, + "๐Ÿ‘จ๐Ÿฝ\u200d\U0001faef\u200d๐Ÿ‘จ๐Ÿฟ": {}, + "๐Ÿ‘จ๐Ÿพ": {}, + "๐Ÿ‘จ๐Ÿพ\u200dโš•๏ธ": {}, + "๐Ÿ‘จ๐Ÿพ\u200dโš–๏ธ": {}, + "๐Ÿ‘จ๐Ÿพ\u200dโœˆ๏ธ": {}, + "๐Ÿ‘จ๐Ÿพ\u200dโค๏ธ\u200d๐Ÿ‘จ๐Ÿป": {}, + "๐Ÿ‘จ๐Ÿพ\u200dโค๏ธ\u200d๐Ÿ‘จ๐Ÿผ": {}, + "๐Ÿ‘จ๐Ÿพ\u200dโค๏ธ\u200d๐Ÿ‘จ๐Ÿฝ": {}, + "๐Ÿ‘จ๐Ÿพ\u200dโค๏ธ\u200d๐Ÿ‘จ๐Ÿพ": {}, + "๐Ÿ‘จ๐Ÿพ\u200dโค๏ธ\u200d๐Ÿ‘จ๐Ÿฟ": {}, + "๐Ÿ‘จ๐Ÿพ\u200dโค๏ธ\u200d๐Ÿ’‹\u200d๐Ÿ‘จ๐Ÿป": {}, + "๐Ÿ‘จ๐Ÿพ\u200dโค๏ธ\u200d๐Ÿ’‹\u200d๐Ÿ‘จ๐Ÿผ": {}, + "๐Ÿ‘จ๐Ÿพ\u200dโค๏ธ\u200d๐Ÿ’‹\u200d๐Ÿ‘จ๐Ÿฝ": {}, + "๐Ÿ‘จ๐Ÿพ\u200dโค๏ธ\u200d๐Ÿ’‹\u200d๐Ÿ‘จ๐Ÿพ": {}, + "๐Ÿ‘จ๐Ÿพ\u200dโค๏ธ\u200d๐Ÿ’‹\u200d๐Ÿ‘จ๐Ÿฟ": {}, + "๐Ÿ‘จ๐Ÿพ\u200d๐ŸŒพ": {}, + "๐Ÿ‘จ๐Ÿพ\u200d๐Ÿณ": {}, + "๐Ÿ‘จ๐Ÿพ\u200d๐Ÿผ": {}, + "๐Ÿ‘จ๐Ÿพ\u200d๐ŸŽ“": {}, + "๐Ÿ‘จ๐Ÿพ\u200d๐ŸŽค": {}, + "๐Ÿ‘จ๐Ÿพ\u200d๐ŸŽจ": {}, + "๐Ÿ‘จ๐Ÿพ\u200d๐Ÿซ": {}, + "๐Ÿ‘จ๐Ÿพ\u200d๐Ÿญ": {}, + "๐Ÿ‘จ๐Ÿพ\u200d๐Ÿฐ\u200d๐Ÿ‘จ๐Ÿป": {}, + "๐Ÿ‘จ๐Ÿพ\u200d๐Ÿฐ\u200d๐Ÿ‘จ๐Ÿผ": {}, + "๐Ÿ‘จ๐Ÿพ\u200d๐Ÿฐ\u200d๐Ÿ‘จ๐Ÿฝ": {}, + "๐Ÿ‘จ๐Ÿพ\u200d๐Ÿฐ\u200d๐Ÿ‘จ๐Ÿฟ": {}, + "๐Ÿ‘จ๐Ÿพ\u200d๐Ÿ’ป": {}, + "๐Ÿ‘จ๐Ÿพ\u200d๐Ÿ’ผ": {}, + "๐Ÿ‘จ๐Ÿพ\u200d๐Ÿ”ง": {}, + "๐Ÿ‘จ๐Ÿพ\u200d๐Ÿ”ฌ": {}, + "๐Ÿ‘จ๐Ÿพ\u200d๐Ÿš€": {}, + "๐Ÿ‘จ๐Ÿพ\u200d๐Ÿš’": {}, + "๐Ÿ‘จ๐Ÿพ\u200d๐Ÿค\u200d๐Ÿ‘จ๐Ÿป": {}, + "๐Ÿ‘จ๐Ÿพ\u200d๐Ÿค\u200d๐Ÿ‘จ๐Ÿผ": {}, + "๐Ÿ‘จ๐Ÿพ\u200d๐Ÿค\u200d๐Ÿ‘จ๐Ÿฝ": {}, + "๐Ÿ‘จ๐Ÿพ\u200d๐Ÿค\u200d๐Ÿ‘จ๐Ÿฟ": {}, + "๐Ÿ‘จ๐Ÿพ\u200d๐Ÿฆฏ": {}, + "๐Ÿ‘จ๐Ÿพ\u200d๐Ÿฆฏ\u200dโžก๏ธ": {}, + "๐Ÿ‘จ๐Ÿพ\u200d๐Ÿฆฐ": {}, + "๐Ÿ‘จ๐Ÿพ\u200d๐Ÿฆฑ": {}, + "๐Ÿ‘จ๐Ÿพ\u200d๐Ÿฆฒ": {}, + "๐Ÿ‘จ๐Ÿพ\u200d๐Ÿฆณ": {}, + "๐Ÿ‘จ๐Ÿพ\u200d๐Ÿฆผ": {}, + "๐Ÿ‘จ๐Ÿพ\u200d๐Ÿฆผ\u200dโžก๏ธ": {}, + "๐Ÿ‘จ๐Ÿพ\u200d๐Ÿฆฝ": {}, + "๐Ÿ‘จ๐Ÿพ\u200d๐Ÿฆฝ\u200dโžก๏ธ": {}, + "๐Ÿ‘จ๐Ÿพ\u200d\U0001faef\u200d๐Ÿ‘จ๐Ÿป": {}, + "๐Ÿ‘จ๐Ÿพ\u200d\U0001faef\u200d๐Ÿ‘จ๐Ÿผ": {}, + "๐Ÿ‘จ๐Ÿพ\u200d\U0001faef\u200d๐Ÿ‘จ๐Ÿฝ": {}, + "๐Ÿ‘จ๐Ÿพ\u200d\U0001faef\u200d๐Ÿ‘จ๐Ÿฟ": {}, + "๐Ÿ‘จ๐Ÿฟ": {}, + "๐Ÿ‘จ๐Ÿฟ\u200dโš•๏ธ": {}, + "๐Ÿ‘จ๐Ÿฟ\u200dโš–๏ธ": {}, + "๐Ÿ‘จ๐Ÿฟ\u200dโœˆ๏ธ": {}, + "๐Ÿ‘จ๐Ÿฟ\u200dโค๏ธ\u200d๐Ÿ‘จ๐Ÿป": {}, + "๐Ÿ‘จ๐Ÿฟ\u200dโค๏ธ\u200d๐Ÿ‘จ๐Ÿผ": {}, + "๐Ÿ‘จ๐Ÿฟ\u200dโค๏ธ\u200d๐Ÿ‘จ๐Ÿฝ": {}, + "๐Ÿ‘จ๐Ÿฟ\u200dโค๏ธ\u200d๐Ÿ‘จ๐Ÿพ": {}, + "๐Ÿ‘จ๐Ÿฟ\u200dโค๏ธ\u200d๐Ÿ‘จ๐Ÿฟ": {}, + "๐Ÿ‘จ๐Ÿฟ\u200dโค๏ธ\u200d๐Ÿ’‹\u200d๐Ÿ‘จ๐Ÿป": {}, + "๐Ÿ‘จ๐Ÿฟ\u200dโค๏ธ\u200d๐Ÿ’‹\u200d๐Ÿ‘จ๐Ÿผ": {}, + "๐Ÿ‘จ๐Ÿฟ\u200dโค๏ธ\u200d๐Ÿ’‹\u200d๐Ÿ‘จ๐Ÿฝ": {}, + "๐Ÿ‘จ๐Ÿฟ\u200dโค๏ธ\u200d๐Ÿ’‹\u200d๐Ÿ‘จ๐Ÿพ": {}, + "๐Ÿ‘จ๐Ÿฟ\u200dโค๏ธ\u200d๐Ÿ’‹\u200d๐Ÿ‘จ๐Ÿฟ": {}, + "๐Ÿ‘จ๐Ÿฟ\u200d๐ŸŒพ": {}, + "๐Ÿ‘จ๐Ÿฟ\u200d๐Ÿณ": {}, + "๐Ÿ‘จ๐Ÿฟ\u200d๐Ÿผ": {}, + "๐Ÿ‘จ๐Ÿฟ\u200d๐ŸŽ“": {}, + "๐Ÿ‘จ๐Ÿฟ\u200d๐ŸŽค": {}, + "๐Ÿ‘จ๐Ÿฟ\u200d๐ŸŽจ": {}, + "๐Ÿ‘จ๐Ÿฟ\u200d๐Ÿซ": {}, + "๐Ÿ‘จ๐Ÿฟ\u200d๐Ÿญ": {}, + "๐Ÿ‘จ๐Ÿฟ\u200d๐Ÿฐ\u200d๐Ÿ‘จ๐Ÿป": {}, + "๐Ÿ‘จ๐Ÿฟ\u200d๐Ÿฐ\u200d๐Ÿ‘จ๐Ÿผ": {}, + "๐Ÿ‘จ๐Ÿฟ\u200d๐Ÿฐ\u200d๐Ÿ‘จ๐Ÿฝ": {}, + "๐Ÿ‘จ๐Ÿฟ\u200d๐Ÿฐ\u200d๐Ÿ‘จ๐Ÿพ": {}, + "๐Ÿ‘จ๐Ÿฟ\u200d๐Ÿ’ป": {}, + "๐Ÿ‘จ๐Ÿฟ\u200d๐Ÿ’ผ": {}, + "๐Ÿ‘จ๐Ÿฟ\u200d๐Ÿ”ง": {}, + "๐Ÿ‘จ๐Ÿฟ\u200d๐Ÿ”ฌ": {}, + "๐Ÿ‘จ๐Ÿฟ\u200d๐Ÿš€": {}, + "๐Ÿ‘จ๐Ÿฟ\u200d๐Ÿš’": {}, + "๐Ÿ‘จ๐Ÿฟ\u200d๐Ÿค\u200d๐Ÿ‘จ๐Ÿป": {}, + "๐Ÿ‘จ๐Ÿฟ\u200d๐Ÿค\u200d๐Ÿ‘จ๐Ÿผ": {}, + "๐Ÿ‘จ๐Ÿฟ\u200d๐Ÿค\u200d๐Ÿ‘จ๐Ÿฝ": {}, + "๐Ÿ‘จ๐Ÿฟ\u200d๐Ÿค\u200d๐Ÿ‘จ๐Ÿพ": {}, + "๐Ÿ‘จ๐Ÿฟ\u200d๐Ÿฆฏ": {}, + "๐Ÿ‘จ๐Ÿฟ\u200d๐Ÿฆฏ\u200dโžก๏ธ": {}, + "๐Ÿ‘จ๐Ÿฟ\u200d๐Ÿฆฐ": {}, + "๐Ÿ‘จ๐Ÿฟ\u200d๐Ÿฆฑ": {}, + "๐Ÿ‘จ๐Ÿฟ\u200d๐Ÿฆฒ": {}, + "๐Ÿ‘จ๐Ÿฟ\u200d๐Ÿฆณ": {}, + "๐Ÿ‘จ๐Ÿฟ\u200d๐Ÿฆผ": {}, + "๐Ÿ‘จ๐Ÿฟ\u200d๐Ÿฆผ\u200dโžก๏ธ": {}, + "๐Ÿ‘จ๐Ÿฟ\u200d๐Ÿฆฝ": {}, + "๐Ÿ‘จ๐Ÿฟ\u200d๐Ÿฆฝ\u200dโžก๏ธ": {}, + "๐Ÿ‘จ๐Ÿฟ\u200d\U0001faef\u200d๐Ÿ‘จ๐Ÿป": {}, + "๐Ÿ‘จ๐Ÿฟ\u200d\U0001faef\u200d๐Ÿ‘จ๐Ÿผ": {}, + "๐Ÿ‘จ๐Ÿฟ\u200d\U0001faef\u200d๐Ÿ‘จ๐Ÿฝ": {}, + "๐Ÿ‘จ๐Ÿฟ\u200d\U0001faef\u200d๐Ÿ‘จ๐Ÿพ": {}, + "๐Ÿ‘ฉ": {}, + "๐Ÿ‘ฉ\u200dโš•๏ธ": {}, + "๐Ÿ‘ฉ\u200dโš–๏ธ": {}, + "๐Ÿ‘ฉ\u200dโœˆ๏ธ": {}, + "๐Ÿ‘ฉ\u200dโค๏ธ\u200d๐Ÿ‘จ": {}, + "๐Ÿ‘ฉ\u200dโค๏ธ\u200d๐Ÿ‘ฉ": {}, + "๐Ÿ‘ฉ\u200dโค๏ธ\u200d๐Ÿ’‹\u200d๐Ÿ‘จ": {}, + "๐Ÿ‘ฉ\u200dโค๏ธ\u200d๐Ÿ’‹\u200d๐Ÿ‘ฉ": {}, + "๐Ÿ‘ฉ\u200d๐ŸŒพ": {}, + "๐Ÿ‘ฉ\u200d๐Ÿณ": {}, + "๐Ÿ‘ฉ\u200d๐Ÿผ": {}, + "๐Ÿ‘ฉ\u200d๐ŸŽ“": {}, + "๐Ÿ‘ฉ\u200d๐ŸŽค": {}, + "๐Ÿ‘ฉ\u200d๐ŸŽจ": {}, + "๐Ÿ‘ฉ\u200d๐Ÿซ": {}, + "๐Ÿ‘ฉ\u200d๐Ÿญ": {}, + "๐Ÿ‘ฉ\u200d๐Ÿ‘ฆ": {}, + "๐Ÿ‘ฉ\u200d๐Ÿ‘ฆ\u200d๐Ÿ‘ฆ": {}, + "๐Ÿ‘ฉ\u200d๐Ÿ‘ง": {}, + "๐Ÿ‘ฉ\u200d๐Ÿ‘ง\u200d๐Ÿ‘ฆ": {}, + "๐Ÿ‘ฉ\u200d๐Ÿ‘ง\u200d๐Ÿ‘ง": {}, + "๐Ÿ‘ฉ\u200d๐Ÿ‘ฉ\u200d๐Ÿ‘ฆ": {}, + "๐Ÿ‘ฉ\u200d๐Ÿ‘ฉ\u200d๐Ÿ‘ฆ\u200d๐Ÿ‘ฆ": {}, + "๐Ÿ‘ฉ\u200d๐Ÿ‘ฉ\u200d๐Ÿ‘ง": {}, + "๐Ÿ‘ฉ\u200d๐Ÿ‘ฉ\u200d๐Ÿ‘ง\u200d๐Ÿ‘ฆ": {}, + "๐Ÿ‘ฉ\u200d๐Ÿ‘ฉ\u200d๐Ÿ‘ง\u200d๐Ÿ‘ง": {}, + "๐Ÿ‘ฉ\u200d๐Ÿ’ป": {}, + "๐Ÿ‘ฉ\u200d๐Ÿ’ผ": {}, + "๐Ÿ‘ฉ\u200d๐Ÿ”ง": {}, + "๐Ÿ‘ฉ\u200d๐Ÿ”ฌ": {}, + "๐Ÿ‘ฉ\u200d๐Ÿš€": {}, + "๐Ÿ‘ฉ\u200d๐Ÿš’": {}, + "๐Ÿ‘ฉ\u200d๐Ÿฆฏ": {}, + "๐Ÿ‘ฉ\u200d๐Ÿฆฏ\u200dโžก๏ธ": {}, + "๐Ÿ‘ฉ\u200d๐Ÿฆฐ": {}, + "๐Ÿ‘ฉ\u200d๐Ÿฆฑ": {}, + "๐Ÿ‘ฉ\u200d๐Ÿฆฒ": {}, + "๐Ÿ‘ฉ\u200d๐Ÿฆณ": {}, + "๐Ÿ‘ฉ\u200d๐Ÿฆผ": {}, + "๐Ÿ‘ฉ\u200d๐Ÿฆผ\u200dโžก๏ธ": {}, + "๐Ÿ‘ฉ\u200d๐Ÿฆฝ": {}, + "๐Ÿ‘ฉ\u200d๐Ÿฆฝ\u200dโžก๏ธ": {}, + "๐Ÿ‘ฉ๐Ÿป": {}, + "๐Ÿ‘ฉ๐Ÿป\u200dโš•๏ธ": {}, + "๐Ÿ‘ฉ๐Ÿป\u200dโš–๏ธ": {}, + "๐Ÿ‘ฉ๐Ÿป\u200dโœˆ๏ธ": {}, + "๐Ÿ‘ฉ๐Ÿป\u200dโค๏ธ\u200d๐Ÿ‘จ๐Ÿป": {}, + "๐Ÿ‘ฉ๐Ÿป\u200dโค๏ธ\u200d๐Ÿ‘จ๐Ÿผ": {}, + "๐Ÿ‘ฉ๐Ÿป\u200dโค๏ธ\u200d๐Ÿ‘จ๐Ÿฝ": {}, + "๐Ÿ‘ฉ๐Ÿป\u200dโค๏ธ\u200d๐Ÿ‘จ๐Ÿพ": {}, + "๐Ÿ‘ฉ๐Ÿป\u200dโค๏ธ\u200d๐Ÿ‘จ๐Ÿฟ": {}, + "๐Ÿ‘ฉ๐Ÿป\u200dโค๏ธ\u200d๐Ÿ‘ฉ๐Ÿป": {}, + "๐Ÿ‘ฉ๐Ÿป\u200dโค๏ธ\u200d๐Ÿ‘ฉ๐Ÿผ": {}, + "๐Ÿ‘ฉ๐Ÿป\u200dโค๏ธ\u200d๐Ÿ‘ฉ๐Ÿฝ": {}, + "๐Ÿ‘ฉ๐Ÿป\u200dโค๏ธ\u200d๐Ÿ‘ฉ๐Ÿพ": {}, + "๐Ÿ‘ฉ๐Ÿป\u200dโค๏ธ\u200d๐Ÿ‘ฉ๐Ÿฟ": {}, + "๐Ÿ‘ฉ๐Ÿป\u200dโค๏ธ\u200d๐Ÿ’‹\u200d๐Ÿ‘จ๐Ÿป": {}, + "๐Ÿ‘ฉ๐Ÿป\u200dโค๏ธ\u200d๐Ÿ’‹\u200d๐Ÿ‘จ๐Ÿผ": {}, + "๐Ÿ‘ฉ๐Ÿป\u200dโค๏ธ\u200d๐Ÿ’‹\u200d๐Ÿ‘จ๐Ÿฝ": {}, + "๐Ÿ‘ฉ๐Ÿป\u200dโค๏ธ\u200d๐Ÿ’‹\u200d๐Ÿ‘จ๐Ÿพ": {}, + "๐Ÿ‘ฉ๐Ÿป\u200dโค๏ธ\u200d๐Ÿ’‹\u200d๐Ÿ‘จ๐Ÿฟ": {}, + "๐Ÿ‘ฉ๐Ÿป\u200dโค๏ธ\u200d๐Ÿ’‹\u200d๐Ÿ‘ฉ๐Ÿป": {}, + "๐Ÿ‘ฉ๐Ÿป\u200dโค๏ธ\u200d๐Ÿ’‹\u200d๐Ÿ‘ฉ๐Ÿผ": {}, + "๐Ÿ‘ฉ๐Ÿป\u200dโค๏ธ\u200d๐Ÿ’‹\u200d๐Ÿ‘ฉ๐Ÿฝ": {}, + "๐Ÿ‘ฉ๐Ÿป\u200dโค๏ธ\u200d๐Ÿ’‹\u200d๐Ÿ‘ฉ๐Ÿพ": {}, + "๐Ÿ‘ฉ๐Ÿป\u200dโค๏ธ\u200d๐Ÿ’‹\u200d๐Ÿ‘ฉ๐Ÿฟ": {}, + "๐Ÿ‘ฉ๐Ÿป\u200d๐ŸŒพ": {}, + "๐Ÿ‘ฉ๐Ÿป\u200d๐Ÿณ": {}, + "๐Ÿ‘ฉ๐Ÿป\u200d๐Ÿผ": {}, + "๐Ÿ‘ฉ๐Ÿป\u200d๐ŸŽ“": {}, + "๐Ÿ‘ฉ๐Ÿป\u200d๐ŸŽค": {}, + "๐Ÿ‘ฉ๐Ÿป\u200d๐ŸŽจ": {}, + "๐Ÿ‘ฉ๐Ÿป\u200d๐Ÿซ": {}, + "๐Ÿ‘ฉ๐Ÿป\u200d๐Ÿญ": {}, + "๐Ÿ‘ฉ๐Ÿป\u200d๐Ÿฐ\u200d๐Ÿ‘ฉ๐Ÿผ": {}, + "๐Ÿ‘ฉ๐Ÿป\u200d๐Ÿฐ\u200d๐Ÿ‘ฉ๐Ÿฝ": {}, + "๐Ÿ‘ฉ๐Ÿป\u200d๐Ÿฐ\u200d๐Ÿ‘ฉ๐Ÿพ": {}, + "๐Ÿ‘ฉ๐Ÿป\u200d๐Ÿฐ\u200d๐Ÿ‘ฉ๐Ÿฟ": {}, + "๐Ÿ‘ฉ๐Ÿป\u200d๐Ÿ’ป": {}, + "๐Ÿ‘ฉ๐Ÿป\u200d๐Ÿ’ผ": {}, + "๐Ÿ‘ฉ๐Ÿป\u200d๐Ÿ”ง": {}, + "๐Ÿ‘ฉ๐Ÿป\u200d๐Ÿ”ฌ": {}, + "๐Ÿ‘ฉ๐Ÿป\u200d๐Ÿš€": {}, + "๐Ÿ‘ฉ๐Ÿป\u200d๐Ÿš’": {}, + "๐Ÿ‘ฉ๐Ÿป\u200d๐Ÿค\u200d๐Ÿ‘จ๐Ÿผ": {}, + "๐Ÿ‘ฉ๐Ÿป\u200d๐Ÿค\u200d๐Ÿ‘จ๐Ÿฝ": {}, + "๐Ÿ‘ฉ๐Ÿป\u200d๐Ÿค\u200d๐Ÿ‘จ๐Ÿพ": {}, + "๐Ÿ‘ฉ๐Ÿป\u200d๐Ÿค\u200d๐Ÿ‘จ๐Ÿฟ": {}, + "๐Ÿ‘ฉ๐Ÿป\u200d๐Ÿค\u200d๐Ÿ‘ฉ๐Ÿผ": {}, + "๐Ÿ‘ฉ๐Ÿป\u200d๐Ÿค\u200d๐Ÿ‘ฉ๐Ÿฝ": {}, + "๐Ÿ‘ฉ๐Ÿป\u200d๐Ÿค\u200d๐Ÿ‘ฉ๐Ÿพ": {}, + "๐Ÿ‘ฉ๐Ÿป\u200d๐Ÿค\u200d๐Ÿ‘ฉ๐Ÿฟ": {}, + "๐Ÿ‘ฉ๐Ÿป\u200d๐Ÿฆฏ": {}, + "๐Ÿ‘ฉ๐Ÿป\u200d๐Ÿฆฏ\u200dโžก๏ธ": {}, + "๐Ÿ‘ฉ๐Ÿป\u200d๐Ÿฆฐ": {}, + "๐Ÿ‘ฉ๐Ÿป\u200d๐Ÿฆฑ": {}, + "๐Ÿ‘ฉ๐Ÿป\u200d๐Ÿฆฒ": {}, + "๐Ÿ‘ฉ๐Ÿป\u200d๐Ÿฆณ": {}, + "๐Ÿ‘ฉ๐Ÿป\u200d๐Ÿฆผ": {}, + "๐Ÿ‘ฉ๐Ÿป\u200d๐Ÿฆผ\u200dโžก๏ธ": {}, + "๐Ÿ‘ฉ๐Ÿป\u200d๐Ÿฆฝ": {}, + "๐Ÿ‘ฉ๐Ÿป\u200d๐Ÿฆฝ\u200dโžก๏ธ": {}, + "๐Ÿ‘ฉ๐Ÿป\u200d\U0001faef\u200d๐Ÿ‘ฉ๐Ÿผ": {}, + "๐Ÿ‘ฉ๐Ÿป\u200d\U0001faef\u200d๐Ÿ‘ฉ๐Ÿฝ": {}, + "๐Ÿ‘ฉ๐Ÿป\u200d\U0001faef\u200d๐Ÿ‘ฉ๐Ÿพ": {}, + "๐Ÿ‘ฉ๐Ÿป\u200d\U0001faef\u200d๐Ÿ‘ฉ๐Ÿฟ": {}, + "๐Ÿ‘ฉ๐Ÿผ": {}, + "๐Ÿ‘ฉ๐Ÿผ\u200dโš•๏ธ": {}, + "๐Ÿ‘ฉ๐Ÿผ\u200dโš–๏ธ": {}, + "๐Ÿ‘ฉ๐Ÿผ\u200dโœˆ๏ธ": {}, + "๐Ÿ‘ฉ๐Ÿผ\u200dโค๏ธ\u200d๐Ÿ‘จ๐Ÿป": {}, + "๐Ÿ‘ฉ๐Ÿผ\u200dโค๏ธ\u200d๐Ÿ‘จ๐Ÿผ": {}, + "๐Ÿ‘ฉ๐Ÿผ\u200dโค๏ธ\u200d๐Ÿ‘จ๐Ÿฝ": {}, + "๐Ÿ‘ฉ๐Ÿผ\u200dโค๏ธ\u200d๐Ÿ‘จ๐Ÿพ": {}, + "๐Ÿ‘ฉ๐Ÿผ\u200dโค๏ธ\u200d๐Ÿ‘จ๐Ÿฟ": {}, + "๐Ÿ‘ฉ๐Ÿผ\u200dโค๏ธ\u200d๐Ÿ‘ฉ๐Ÿป": {}, + "๐Ÿ‘ฉ๐Ÿผ\u200dโค๏ธ\u200d๐Ÿ‘ฉ๐Ÿผ": {}, + "๐Ÿ‘ฉ๐Ÿผ\u200dโค๏ธ\u200d๐Ÿ‘ฉ๐Ÿฝ": {}, + "๐Ÿ‘ฉ๐Ÿผ\u200dโค๏ธ\u200d๐Ÿ‘ฉ๐Ÿพ": {}, + "๐Ÿ‘ฉ๐Ÿผ\u200dโค๏ธ\u200d๐Ÿ‘ฉ๐Ÿฟ": {}, + "๐Ÿ‘ฉ๐Ÿผ\u200dโค๏ธ\u200d๐Ÿ’‹\u200d๐Ÿ‘จ๐Ÿป": {}, + "๐Ÿ‘ฉ๐Ÿผ\u200dโค๏ธ\u200d๐Ÿ’‹\u200d๐Ÿ‘จ๐Ÿผ": {}, + "๐Ÿ‘ฉ๐Ÿผ\u200dโค๏ธ\u200d๐Ÿ’‹\u200d๐Ÿ‘จ๐Ÿฝ": {}, + "๐Ÿ‘ฉ๐Ÿผ\u200dโค๏ธ\u200d๐Ÿ’‹\u200d๐Ÿ‘จ๐Ÿพ": {}, + "๐Ÿ‘ฉ๐Ÿผ\u200dโค๏ธ\u200d๐Ÿ’‹\u200d๐Ÿ‘จ๐Ÿฟ": {}, + "๐Ÿ‘ฉ๐Ÿผ\u200dโค๏ธ\u200d๐Ÿ’‹\u200d๐Ÿ‘ฉ๐Ÿป": {}, + "๐Ÿ‘ฉ๐Ÿผ\u200dโค๏ธ\u200d๐Ÿ’‹\u200d๐Ÿ‘ฉ๐Ÿผ": {}, + "๐Ÿ‘ฉ๐Ÿผ\u200dโค๏ธ\u200d๐Ÿ’‹\u200d๐Ÿ‘ฉ๐Ÿฝ": {}, + "๐Ÿ‘ฉ๐Ÿผ\u200dโค๏ธ\u200d๐Ÿ’‹\u200d๐Ÿ‘ฉ๐Ÿพ": {}, + "๐Ÿ‘ฉ๐Ÿผ\u200dโค๏ธ\u200d๐Ÿ’‹\u200d๐Ÿ‘ฉ๐Ÿฟ": {}, + "๐Ÿ‘ฉ๐Ÿผ\u200d๐ŸŒพ": {}, + "๐Ÿ‘ฉ๐Ÿผ\u200d๐Ÿณ": {}, + "๐Ÿ‘ฉ๐Ÿผ\u200d๐Ÿผ": {}, + "๐Ÿ‘ฉ๐Ÿผ\u200d๐ŸŽ“": {}, + "๐Ÿ‘ฉ๐Ÿผ\u200d๐ŸŽค": {}, + "๐Ÿ‘ฉ๐Ÿผ\u200d๐ŸŽจ": {}, + "๐Ÿ‘ฉ๐Ÿผ\u200d๐Ÿซ": {}, + "๐Ÿ‘ฉ๐Ÿผ\u200d๐Ÿญ": {}, + "๐Ÿ‘ฉ๐Ÿผ\u200d๐Ÿฐ\u200d๐Ÿ‘ฉ๐Ÿป": {}, + "๐Ÿ‘ฉ๐Ÿผ\u200d๐Ÿฐ\u200d๐Ÿ‘ฉ๐Ÿฝ": {}, + "๐Ÿ‘ฉ๐Ÿผ\u200d๐Ÿฐ\u200d๐Ÿ‘ฉ๐Ÿพ": {}, + "๐Ÿ‘ฉ๐Ÿผ\u200d๐Ÿฐ\u200d๐Ÿ‘ฉ๐Ÿฟ": {}, + "๐Ÿ‘ฉ๐Ÿผ\u200d๐Ÿ’ป": {}, + "๐Ÿ‘ฉ๐Ÿผ\u200d๐Ÿ’ผ": {}, + "๐Ÿ‘ฉ๐Ÿผ\u200d๐Ÿ”ง": {}, + "๐Ÿ‘ฉ๐Ÿผ\u200d๐Ÿ”ฌ": {}, + "๐Ÿ‘ฉ๐Ÿผ\u200d๐Ÿš€": {}, + "๐Ÿ‘ฉ๐Ÿผ\u200d๐Ÿš’": {}, + "๐Ÿ‘ฉ๐Ÿผ\u200d๐Ÿค\u200d๐Ÿ‘จ๐Ÿป": {}, + "๐Ÿ‘ฉ๐Ÿผ\u200d๐Ÿค\u200d๐Ÿ‘จ๐Ÿฝ": {}, + "๐Ÿ‘ฉ๐Ÿผ\u200d๐Ÿค\u200d๐Ÿ‘จ๐Ÿพ": {}, + "๐Ÿ‘ฉ๐Ÿผ\u200d๐Ÿค\u200d๐Ÿ‘จ๐Ÿฟ": {}, + "๐Ÿ‘ฉ๐Ÿผ\u200d๐Ÿค\u200d๐Ÿ‘ฉ๐Ÿป": {}, + "๐Ÿ‘ฉ๐Ÿผ\u200d๐Ÿค\u200d๐Ÿ‘ฉ๐Ÿฝ": {}, + "๐Ÿ‘ฉ๐Ÿผ\u200d๐Ÿค\u200d๐Ÿ‘ฉ๐Ÿพ": {}, + "๐Ÿ‘ฉ๐Ÿผ\u200d๐Ÿค\u200d๐Ÿ‘ฉ๐Ÿฟ": {}, + "๐Ÿ‘ฉ๐Ÿผ\u200d๐Ÿฆฏ": {}, + "๐Ÿ‘ฉ๐Ÿผ\u200d๐Ÿฆฏ\u200dโžก๏ธ": {}, + "๐Ÿ‘ฉ๐Ÿผ\u200d๐Ÿฆฐ": {}, + "๐Ÿ‘ฉ๐Ÿผ\u200d๐Ÿฆฑ": {}, + "๐Ÿ‘ฉ๐Ÿผ\u200d๐Ÿฆฒ": {}, + "๐Ÿ‘ฉ๐Ÿผ\u200d๐Ÿฆณ": {}, + "๐Ÿ‘ฉ๐Ÿผ\u200d๐Ÿฆผ": {}, + "๐Ÿ‘ฉ๐Ÿผ\u200d๐Ÿฆผ\u200dโžก๏ธ": {}, + "๐Ÿ‘ฉ๐Ÿผ\u200d๐Ÿฆฝ": {}, + "๐Ÿ‘ฉ๐Ÿผ\u200d๐Ÿฆฝ\u200dโžก๏ธ": {}, + "๐Ÿ‘ฉ๐Ÿผ\u200d\U0001faef\u200d๐Ÿ‘ฉ๐Ÿป": {}, + "๐Ÿ‘ฉ๐Ÿผ\u200d\U0001faef\u200d๐Ÿ‘ฉ๐Ÿฝ": {}, + "๐Ÿ‘ฉ๐Ÿผ\u200d\U0001faef\u200d๐Ÿ‘ฉ๐Ÿพ": {}, + "๐Ÿ‘ฉ๐Ÿผ\u200d\U0001faef\u200d๐Ÿ‘ฉ๐Ÿฟ": {}, + "๐Ÿ‘ฉ๐Ÿฝ": {}, + "๐Ÿ‘ฉ๐Ÿฝ\u200dโš•๏ธ": {}, + "๐Ÿ‘ฉ๐Ÿฝ\u200dโš–๏ธ": {}, + "๐Ÿ‘ฉ๐Ÿฝ\u200dโœˆ๏ธ": {}, + "๐Ÿ‘ฉ๐Ÿฝ\u200dโค๏ธ\u200d๐Ÿ‘จ๐Ÿป": {}, + "๐Ÿ‘ฉ๐Ÿฝ\u200dโค๏ธ\u200d๐Ÿ‘จ๐Ÿผ": {}, + "๐Ÿ‘ฉ๐Ÿฝ\u200dโค๏ธ\u200d๐Ÿ‘จ๐Ÿฝ": {}, + "๐Ÿ‘ฉ๐Ÿฝ\u200dโค๏ธ\u200d๐Ÿ‘จ๐Ÿพ": {}, + "๐Ÿ‘ฉ๐Ÿฝ\u200dโค๏ธ\u200d๐Ÿ‘จ๐Ÿฟ": {}, + "๐Ÿ‘ฉ๐Ÿฝ\u200dโค๏ธ\u200d๐Ÿ‘ฉ๐Ÿป": {}, + "๐Ÿ‘ฉ๐Ÿฝ\u200dโค๏ธ\u200d๐Ÿ‘ฉ๐Ÿผ": {}, + "๐Ÿ‘ฉ๐Ÿฝ\u200dโค๏ธ\u200d๐Ÿ‘ฉ๐Ÿฝ": {}, + "๐Ÿ‘ฉ๐Ÿฝ\u200dโค๏ธ\u200d๐Ÿ‘ฉ๐Ÿพ": {}, + "๐Ÿ‘ฉ๐Ÿฝ\u200dโค๏ธ\u200d๐Ÿ‘ฉ๐Ÿฟ": {}, + "๐Ÿ‘ฉ๐Ÿฝ\u200dโค๏ธ\u200d๐Ÿ’‹\u200d๐Ÿ‘จ๐Ÿป": {}, + "๐Ÿ‘ฉ๐Ÿฝ\u200dโค๏ธ\u200d๐Ÿ’‹\u200d๐Ÿ‘จ๐Ÿผ": {}, + "๐Ÿ‘ฉ๐Ÿฝ\u200dโค๏ธ\u200d๐Ÿ’‹\u200d๐Ÿ‘จ๐Ÿฝ": {}, + "๐Ÿ‘ฉ๐Ÿฝ\u200dโค๏ธ\u200d๐Ÿ’‹\u200d๐Ÿ‘จ๐Ÿพ": {}, + "๐Ÿ‘ฉ๐Ÿฝ\u200dโค๏ธ\u200d๐Ÿ’‹\u200d๐Ÿ‘จ๐Ÿฟ": {}, + "๐Ÿ‘ฉ๐Ÿฝ\u200dโค๏ธ\u200d๐Ÿ’‹\u200d๐Ÿ‘ฉ๐Ÿป": {}, + "๐Ÿ‘ฉ๐Ÿฝ\u200dโค๏ธ\u200d๐Ÿ’‹\u200d๐Ÿ‘ฉ๐Ÿผ": {}, + "๐Ÿ‘ฉ๐Ÿฝ\u200dโค๏ธ\u200d๐Ÿ’‹\u200d๐Ÿ‘ฉ๐Ÿฝ": {}, + "๐Ÿ‘ฉ๐Ÿฝ\u200dโค๏ธ\u200d๐Ÿ’‹\u200d๐Ÿ‘ฉ๐Ÿพ": {}, + "๐Ÿ‘ฉ๐Ÿฝ\u200dโค๏ธ\u200d๐Ÿ’‹\u200d๐Ÿ‘ฉ๐Ÿฟ": {}, + "๐Ÿ‘ฉ๐Ÿฝ\u200d๐ŸŒพ": {}, + "๐Ÿ‘ฉ๐Ÿฝ\u200d๐Ÿณ": {}, + "๐Ÿ‘ฉ๐Ÿฝ\u200d๐Ÿผ": {}, + "๐Ÿ‘ฉ๐Ÿฝ\u200d๐ŸŽ“": {}, + "๐Ÿ‘ฉ๐Ÿฝ\u200d๐ŸŽค": {}, + "๐Ÿ‘ฉ๐Ÿฝ\u200d๐ŸŽจ": {}, + "๐Ÿ‘ฉ๐Ÿฝ\u200d๐Ÿซ": {}, + "๐Ÿ‘ฉ๐Ÿฝ\u200d๐Ÿญ": {}, + "๐Ÿ‘ฉ๐Ÿฝ\u200d๐Ÿฐ\u200d๐Ÿ‘ฉ๐Ÿป": {}, + "๐Ÿ‘ฉ๐Ÿฝ\u200d๐Ÿฐ\u200d๐Ÿ‘ฉ๐Ÿผ": {}, + "๐Ÿ‘ฉ๐Ÿฝ\u200d๐Ÿฐ\u200d๐Ÿ‘ฉ๐Ÿพ": {}, + "๐Ÿ‘ฉ๐Ÿฝ\u200d๐Ÿฐ\u200d๐Ÿ‘ฉ๐Ÿฟ": {}, + "๐Ÿ‘ฉ๐Ÿฝ\u200d๐Ÿ’ป": {}, + "๐Ÿ‘ฉ๐Ÿฝ\u200d๐Ÿ’ผ": {}, + "๐Ÿ‘ฉ๐Ÿฝ\u200d๐Ÿ”ง": {}, + "๐Ÿ‘ฉ๐Ÿฝ\u200d๐Ÿ”ฌ": {}, + "๐Ÿ‘ฉ๐Ÿฝ\u200d๐Ÿš€": {}, + "๐Ÿ‘ฉ๐Ÿฝ\u200d๐Ÿš’": {}, + "๐Ÿ‘ฉ๐Ÿฝ\u200d๐Ÿค\u200d๐Ÿ‘จ๐Ÿป": {}, + "๐Ÿ‘ฉ๐Ÿฝ\u200d๐Ÿค\u200d๐Ÿ‘จ๐Ÿผ": {}, + "๐Ÿ‘ฉ๐Ÿฝ\u200d๐Ÿค\u200d๐Ÿ‘จ๐Ÿพ": {}, + "๐Ÿ‘ฉ๐Ÿฝ\u200d๐Ÿค\u200d๐Ÿ‘จ๐Ÿฟ": {}, + "๐Ÿ‘ฉ๐Ÿฝ\u200d๐Ÿค\u200d๐Ÿ‘ฉ๐Ÿป": {}, + "๐Ÿ‘ฉ๐Ÿฝ\u200d๐Ÿค\u200d๐Ÿ‘ฉ๐Ÿผ": {}, + "๐Ÿ‘ฉ๐Ÿฝ\u200d๐Ÿค\u200d๐Ÿ‘ฉ๐Ÿพ": {}, + "๐Ÿ‘ฉ๐Ÿฝ\u200d๐Ÿค\u200d๐Ÿ‘ฉ๐Ÿฟ": {}, + "๐Ÿ‘ฉ๐Ÿฝ\u200d๐Ÿฆฏ": {}, + "๐Ÿ‘ฉ๐Ÿฝ\u200d๐Ÿฆฏ\u200dโžก๏ธ": {}, + "๐Ÿ‘ฉ๐Ÿฝ\u200d๐Ÿฆฐ": {}, + "๐Ÿ‘ฉ๐Ÿฝ\u200d๐Ÿฆฑ": {}, + "๐Ÿ‘ฉ๐Ÿฝ\u200d๐Ÿฆฒ": {}, + "๐Ÿ‘ฉ๐Ÿฝ\u200d๐Ÿฆณ": {}, + "๐Ÿ‘ฉ๐Ÿฝ\u200d๐Ÿฆผ": {}, + "๐Ÿ‘ฉ๐Ÿฝ\u200d๐Ÿฆผ\u200dโžก๏ธ": {}, + "๐Ÿ‘ฉ๐Ÿฝ\u200d๐Ÿฆฝ": {}, + "๐Ÿ‘ฉ๐Ÿฝ\u200d๐Ÿฆฝ\u200dโžก๏ธ": {}, + "๐Ÿ‘ฉ๐Ÿฝ\u200d\U0001faef\u200d๐Ÿ‘ฉ๐Ÿป": {}, + "๐Ÿ‘ฉ๐Ÿฝ\u200d\U0001faef\u200d๐Ÿ‘ฉ๐Ÿผ": {}, + "๐Ÿ‘ฉ๐Ÿฝ\u200d\U0001faef\u200d๐Ÿ‘ฉ๐Ÿพ": {}, + "๐Ÿ‘ฉ๐Ÿฝ\u200d\U0001faef\u200d๐Ÿ‘ฉ๐Ÿฟ": {}, + "๐Ÿ‘ฉ๐Ÿพ": {}, + "๐Ÿ‘ฉ๐Ÿพ\u200dโš•๏ธ": {}, + "๐Ÿ‘ฉ๐Ÿพ\u200dโš–๏ธ": {}, + "๐Ÿ‘ฉ๐Ÿพ\u200dโœˆ๏ธ": {}, + "๐Ÿ‘ฉ๐Ÿพ\u200dโค๏ธ\u200d๐Ÿ‘จ๐Ÿป": {}, + "๐Ÿ‘ฉ๐Ÿพ\u200dโค๏ธ\u200d๐Ÿ‘จ๐Ÿผ": {}, + "๐Ÿ‘ฉ๐Ÿพ\u200dโค๏ธ\u200d๐Ÿ‘จ๐Ÿฝ": {}, + "๐Ÿ‘ฉ๐Ÿพ\u200dโค๏ธ\u200d๐Ÿ‘จ๐Ÿพ": {}, + "๐Ÿ‘ฉ๐Ÿพ\u200dโค๏ธ\u200d๐Ÿ‘จ๐Ÿฟ": {}, + "๐Ÿ‘ฉ๐Ÿพ\u200dโค๏ธ\u200d๐Ÿ‘ฉ๐Ÿป": {}, + "๐Ÿ‘ฉ๐Ÿพ\u200dโค๏ธ\u200d๐Ÿ‘ฉ๐Ÿผ": {}, + "๐Ÿ‘ฉ๐Ÿพ\u200dโค๏ธ\u200d๐Ÿ‘ฉ๐Ÿฝ": {}, + "๐Ÿ‘ฉ๐Ÿพ\u200dโค๏ธ\u200d๐Ÿ‘ฉ๐Ÿพ": {}, + "๐Ÿ‘ฉ๐Ÿพ\u200dโค๏ธ\u200d๐Ÿ‘ฉ๐Ÿฟ": {}, + "๐Ÿ‘ฉ๐Ÿพ\u200dโค๏ธ\u200d๐Ÿ’‹\u200d๐Ÿ‘จ๐Ÿป": {}, + "๐Ÿ‘ฉ๐Ÿพ\u200dโค๏ธ\u200d๐Ÿ’‹\u200d๐Ÿ‘จ๐Ÿผ": {}, + "๐Ÿ‘ฉ๐Ÿพ\u200dโค๏ธ\u200d๐Ÿ’‹\u200d๐Ÿ‘จ๐Ÿฝ": {}, + "๐Ÿ‘ฉ๐Ÿพ\u200dโค๏ธ\u200d๐Ÿ’‹\u200d๐Ÿ‘จ๐Ÿพ": {}, + "๐Ÿ‘ฉ๐Ÿพ\u200dโค๏ธ\u200d๐Ÿ’‹\u200d๐Ÿ‘จ๐Ÿฟ": {}, + "๐Ÿ‘ฉ๐Ÿพ\u200dโค๏ธ\u200d๐Ÿ’‹\u200d๐Ÿ‘ฉ๐Ÿป": {}, + "๐Ÿ‘ฉ๐Ÿพ\u200dโค๏ธ\u200d๐Ÿ’‹\u200d๐Ÿ‘ฉ๐Ÿผ": {}, + "๐Ÿ‘ฉ๐Ÿพ\u200dโค๏ธ\u200d๐Ÿ’‹\u200d๐Ÿ‘ฉ๐Ÿฝ": {}, + "๐Ÿ‘ฉ๐Ÿพ\u200dโค๏ธ\u200d๐Ÿ’‹\u200d๐Ÿ‘ฉ๐Ÿพ": {}, + "๐Ÿ‘ฉ๐Ÿพ\u200dโค๏ธ\u200d๐Ÿ’‹\u200d๐Ÿ‘ฉ๐Ÿฟ": {}, + "๐Ÿ‘ฉ๐Ÿพ\u200d๐ŸŒพ": {}, + "๐Ÿ‘ฉ๐Ÿพ\u200d๐Ÿณ": {}, + "๐Ÿ‘ฉ๐Ÿพ\u200d๐Ÿผ": {}, + "๐Ÿ‘ฉ๐Ÿพ\u200d๐ŸŽ“": {}, + "๐Ÿ‘ฉ๐Ÿพ\u200d๐ŸŽค": {}, + "๐Ÿ‘ฉ๐Ÿพ\u200d๐ŸŽจ": {}, + "๐Ÿ‘ฉ๐Ÿพ\u200d๐Ÿซ": {}, + "๐Ÿ‘ฉ๐Ÿพ\u200d๐Ÿญ": {}, + "๐Ÿ‘ฉ๐Ÿพ\u200d๐Ÿฐ\u200d๐Ÿ‘ฉ๐Ÿป": {}, + "๐Ÿ‘ฉ๐Ÿพ\u200d๐Ÿฐ\u200d๐Ÿ‘ฉ๐Ÿผ": {}, + "๐Ÿ‘ฉ๐Ÿพ\u200d๐Ÿฐ\u200d๐Ÿ‘ฉ๐Ÿฝ": {}, + "๐Ÿ‘ฉ๐Ÿพ\u200d๐Ÿฐ\u200d๐Ÿ‘ฉ๐Ÿฟ": {}, + "๐Ÿ‘ฉ๐Ÿพ\u200d๐Ÿ’ป": {}, + "๐Ÿ‘ฉ๐Ÿพ\u200d๐Ÿ’ผ": {}, + "๐Ÿ‘ฉ๐Ÿพ\u200d๐Ÿ”ง": {}, + "๐Ÿ‘ฉ๐Ÿพ\u200d๐Ÿ”ฌ": {}, + "๐Ÿ‘ฉ๐Ÿพ\u200d๐Ÿš€": {}, + "๐Ÿ‘ฉ๐Ÿพ\u200d๐Ÿš’": {}, + "๐Ÿ‘ฉ๐Ÿพ\u200d๐Ÿค\u200d๐Ÿ‘จ๐Ÿป": {}, + "๐Ÿ‘ฉ๐Ÿพ\u200d๐Ÿค\u200d๐Ÿ‘จ๐Ÿผ": {}, + "๐Ÿ‘ฉ๐Ÿพ\u200d๐Ÿค\u200d๐Ÿ‘จ๐Ÿฝ": {}, + "๐Ÿ‘ฉ๐Ÿพ\u200d๐Ÿค\u200d๐Ÿ‘จ๐Ÿฟ": {}, + "๐Ÿ‘ฉ๐Ÿพ\u200d๐Ÿค\u200d๐Ÿ‘ฉ๐Ÿป": {}, + "๐Ÿ‘ฉ๐Ÿพ\u200d๐Ÿค\u200d๐Ÿ‘ฉ๐Ÿผ": {}, + "๐Ÿ‘ฉ๐Ÿพ\u200d๐Ÿค\u200d๐Ÿ‘ฉ๐Ÿฝ": {}, + "๐Ÿ‘ฉ๐Ÿพ\u200d๐Ÿค\u200d๐Ÿ‘ฉ๐Ÿฟ": {}, + "๐Ÿ‘ฉ๐Ÿพ\u200d๐Ÿฆฏ": {}, + "๐Ÿ‘ฉ๐Ÿพ\u200d๐Ÿฆฏ\u200dโžก๏ธ": {}, + "๐Ÿ‘ฉ๐Ÿพ\u200d๐Ÿฆฐ": {}, + "๐Ÿ‘ฉ๐Ÿพ\u200d๐Ÿฆฑ": {}, + "๐Ÿ‘ฉ๐Ÿพ\u200d๐Ÿฆฒ": {}, + "๐Ÿ‘ฉ๐Ÿพ\u200d๐Ÿฆณ": {}, + "๐Ÿ‘ฉ๐Ÿพ\u200d๐Ÿฆผ": {}, + "๐Ÿ‘ฉ๐Ÿพ\u200d๐Ÿฆผ\u200dโžก๏ธ": {}, + "๐Ÿ‘ฉ๐Ÿพ\u200d๐Ÿฆฝ": {}, + "๐Ÿ‘ฉ๐Ÿพ\u200d๐Ÿฆฝ\u200dโžก๏ธ": {}, + "๐Ÿ‘ฉ๐Ÿพ\u200d\U0001faef\u200d๐Ÿ‘ฉ๐Ÿป": {}, + "๐Ÿ‘ฉ๐Ÿพ\u200d\U0001faef\u200d๐Ÿ‘ฉ๐Ÿผ": {}, + "๐Ÿ‘ฉ๐Ÿพ\u200d\U0001faef\u200d๐Ÿ‘ฉ๐Ÿฝ": {}, + "๐Ÿ‘ฉ๐Ÿพ\u200d\U0001faef\u200d๐Ÿ‘ฉ๐Ÿฟ": {}, + "๐Ÿ‘ฉ๐Ÿฟ": {}, + "๐Ÿ‘ฉ๐Ÿฟ\u200dโš•๏ธ": {}, + "๐Ÿ‘ฉ๐Ÿฟ\u200dโš–๏ธ": {}, + "๐Ÿ‘ฉ๐Ÿฟ\u200dโœˆ๏ธ": {}, + "๐Ÿ‘ฉ๐Ÿฟ\u200dโค๏ธ\u200d๐Ÿ‘จ๐Ÿป": {}, + "๐Ÿ‘ฉ๐Ÿฟ\u200dโค๏ธ\u200d๐Ÿ‘จ๐Ÿผ": {}, + "๐Ÿ‘ฉ๐Ÿฟ\u200dโค๏ธ\u200d๐Ÿ‘จ๐Ÿฝ": {}, + "๐Ÿ‘ฉ๐Ÿฟ\u200dโค๏ธ\u200d๐Ÿ‘จ๐Ÿพ": {}, + "๐Ÿ‘ฉ๐Ÿฟ\u200dโค๏ธ\u200d๐Ÿ‘จ๐Ÿฟ": {}, + "๐Ÿ‘ฉ๐Ÿฟ\u200dโค๏ธ\u200d๐Ÿ‘ฉ๐Ÿป": {}, + "๐Ÿ‘ฉ๐Ÿฟ\u200dโค๏ธ\u200d๐Ÿ‘ฉ๐Ÿผ": {}, + "๐Ÿ‘ฉ๐Ÿฟ\u200dโค๏ธ\u200d๐Ÿ‘ฉ๐Ÿฝ": {}, + "๐Ÿ‘ฉ๐Ÿฟ\u200dโค๏ธ\u200d๐Ÿ‘ฉ๐Ÿพ": {}, + "๐Ÿ‘ฉ๐Ÿฟ\u200dโค๏ธ\u200d๐Ÿ‘ฉ๐Ÿฟ": {}, + "๐Ÿ‘ฉ๐Ÿฟ\u200dโค๏ธ\u200d๐Ÿ’‹\u200d๐Ÿ‘จ๐Ÿป": {}, + "๐Ÿ‘ฉ๐Ÿฟ\u200dโค๏ธ\u200d๐Ÿ’‹\u200d๐Ÿ‘จ๐Ÿผ": {}, + "๐Ÿ‘ฉ๐Ÿฟ\u200dโค๏ธ\u200d๐Ÿ’‹\u200d๐Ÿ‘จ๐Ÿฝ": {}, + "๐Ÿ‘ฉ๐Ÿฟ\u200dโค๏ธ\u200d๐Ÿ’‹\u200d๐Ÿ‘จ๐Ÿพ": {}, + "๐Ÿ‘ฉ๐Ÿฟ\u200dโค๏ธ\u200d๐Ÿ’‹\u200d๐Ÿ‘จ๐Ÿฟ": {}, + "๐Ÿ‘ฉ๐Ÿฟ\u200dโค๏ธ\u200d๐Ÿ’‹\u200d๐Ÿ‘ฉ๐Ÿป": {}, + "๐Ÿ‘ฉ๐Ÿฟ\u200dโค๏ธ\u200d๐Ÿ’‹\u200d๐Ÿ‘ฉ๐Ÿผ": {}, + "๐Ÿ‘ฉ๐Ÿฟ\u200dโค๏ธ\u200d๐Ÿ’‹\u200d๐Ÿ‘ฉ๐Ÿฝ": {}, + "๐Ÿ‘ฉ๐Ÿฟ\u200dโค๏ธ\u200d๐Ÿ’‹\u200d๐Ÿ‘ฉ๐Ÿพ": {}, + "๐Ÿ‘ฉ๐Ÿฟ\u200dโค๏ธ\u200d๐Ÿ’‹\u200d๐Ÿ‘ฉ๐Ÿฟ": {}, + "๐Ÿ‘ฉ๐Ÿฟ\u200d๐ŸŒพ": {}, + "๐Ÿ‘ฉ๐Ÿฟ\u200d๐Ÿณ": {}, + "๐Ÿ‘ฉ๐Ÿฟ\u200d๐Ÿผ": {}, + "๐Ÿ‘ฉ๐Ÿฟ\u200d๐ŸŽ“": {}, + "๐Ÿ‘ฉ๐Ÿฟ\u200d๐ŸŽค": {}, + "๐Ÿ‘ฉ๐Ÿฟ\u200d๐ŸŽจ": {}, + "๐Ÿ‘ฉ๐Ÿฟ\u200d๐Ÿซ": {}, + "๐Ÿ‘ฉ๐Ÿฟ\u200d๐Ÿญ": {}, + "๐Ÿ‘ฉ๐Ÿฟ\u200d๐Ÿฐ\u200d๐Ÿ‘ฉ๐Ÿป": {}, + "๐Ÿ‘ฉ๐Ÿฟ\u200d๐Ÿฐ\u200d๐Ÿ‘ฉ๐Ÿผ": {}, + "๐Ÿ‘ฉ๐Ÿฟ\u200d๐Ÿฐ\u200d๐Ÿ‘ฉ๐Ÿฝ": {}, + "๐Ÿ‘ฉ๐Ÿฟ\u200d๐Ÿฐ\u200d๐Ÿ‘ฉ๐Ÿพ": {}, + "๐Ÿ‘ฉ๐Ÿฟ\u200d๐Ÿ’ป": {}, + "๐Ÿ‘ฉ๐Ÿฟ\u200d๐Ÿ’ผ": {}, + "๐Ÿ‘ฉ๐Ÿฟ\u200d๐Ÿ”ง": {}, + "๐Ÿ‘ฉ๐Ÿฟ\u200d๐Ÿ”ฌ": {}, + "๐Ÿ‘ฉ๐Ÿฟ\u200d๐Ÿš€": {}, + "๐Ÿ‘ฉ๐Ÿฟ\u200d๐Ÿš’": {}, + "๐Ÿ‘ฉ๐Ÿฟ\u200d๐Ÿค\u200d๐Ÿ‘จ๐Ÿป": {}, + "๐Ÿ‘ฉ๐Ÿฟ\u200d๐Ÿค\u200d๐Ÿ‘จ๐Ÿผ": {}, + "๐Ÿ‘ฉ๐Ÿฟ\u200d๐Ÿค\u200d๐Ÿ‘จ๐Ÿฝ": {}, + "๐Ÿ‘ฉ๐Ÿฟ\u200d๐Ÿค\u200d๐Ÿ‘จ๐Ÿพ": {}, + "๐Ÿ‘ฉ๐Ÿฟ\u200d๐Ÿค\u200d๐Ÿ‘ฉ๐Ÿป": {}, + "๐Ÿ‘ฉ๐Ÿฟ\u200d๐Ÿค\u200d๐Ÿ‘ฉ๐Ÿผ": {}, + "๐Ÿ‘ฉ๐Ÿฟ\u200d๐Ÿค\u200d๐Ÿ‘ฉ๐Ÿฝ": {}, + "๐Ÿ‘ฉ๐Ÿฟ\u200d๐Ÿค\u200d๐Ÿ‘ฉ๐Ÿพ": {}, + "๐Ÿ‘ฉ๐Ÿฟ\u200d๐Ÿฆฏ": {}, + "๐Ÿ‘ฉ๐Ÿฟ\u200d๐Ÿฆฏ\u200dโžก๏ธ": {}, + "๐Ÿ‘ฉ๐Ÿฟ\u200d๐Ÿฆฐ": {}, + "๐Ÿ‘ฉ๐Ÿฟ\u200d๐Ÿฆฑ": {}, + "๐Ÿ‘ฉ๐Ÿฟ\u200d๐Ÿฆฒ": {}, + "๐Ÿ‘ฉ๐Ÿฟ\u200d๐Ÿฆณ": {}, + "๐Ÿ‘ฉ๐Ÿฟ\u200d๐Ÿฆผ": {}, + "๐Ÿ‘ฉ๐Ÿฟ\u200d๐Ÿฆผ\u200dโžก๏ธ": {}, + "๐Ÿ‘ฉ๐Ÿฟ\u200d๐Ÿฆฝ": {}, + "๐Ÿ‘ฉ๐Ÿฟ\u200d๐Ÿฆฝ\u200dโžก๏ธ": {}, + "๐Ÿ‘ฉ๐Ÿฟ\u200d\U0001faef\u200d๐Ÿ‘ฉ๐Ÿป": {}, + "๐Ÿ‘ฉ๐Ÿฟ\u200d\U0001faef\u200d๐Ÿ‘ฉ๐Ÿผ": {}, + "๐Ÿ‘ฉ๐Ÿฟ\u200d\U0001faef\u200d๐Ÿ‘ฉ๐Ÿฝ": {}, + "๐Ÿ‘ฉ๐Ÿฟ\u200d\U0001faef\u200d๐Ÿ‘ฉ๐Ÿพ": {}, + "๐Ÿ‘ช": {}, + "๐Ÿ‘ซ": {}, + "๐Ÿ‘ซ๐Ÿป": {}, + "๐Ÿ‘ซ๐Ÿผ": {}, + "๐Ÿ‘ซ๐Ÿฝ": {}, + "๐Ÿ‘ซ๐Ÿพ": {}, + "๐Ÿ‘ซ๐Ÿฟ": {}, + "๐Ÿ‘ฌ": {}, + "๐Ÿ‘ฌ๐Ÿป": {}, + "๐Ÿ‘ฌ๐Ÿผ": {}, + "๐Ÿ‘ฌ๐Ÿฝ": {}, + "๐Ÿ‘ฌ๐Ÿพ": {}, + "๐Ÿ‘ฌ๐Ÿฟ": {}, + "๐Ÿ‘ญ": {}, + "๐Ÿ‘ญ๐Ÿป": {}, + "๐Ÿ‘ญ๐Ÿผ": {}, + "๐Ÿ‘ญ๐Ÿฝ": {}, + "๐Ÿ‘ญ๐Ÿพ": {}, + "๐Ÿ‘ญ๐Ÿฟ": {}, + "๐Ÿ‘ฎ": {}, + "๐Ÿ‘ฎ\u200dโ™€๏ธ": {}, + "๐Ÿ‘ฎ\u200dโ™‚๏ธ": {}, + "๐Ÿ‘ฎ๐Ÿป": {}, + "๐Ÿ‘ฎ๐Ÿป\u200dโ™€๏ธ": {}, + "๐Ÿ‘ฎ๐Ÿป\u200dโ™‚๏ธ": {}, + "๐Ÿ‘ฎ๐Ÿผ": {}, + "๐Ÿ‘ฎ๐Ÿผ\u200dโ™€๏ธ": {}, + "๐Ÿ‘ฎ๐Ÿผ\u200dโ™‚๏ธ": {}, + "๐Ÿ‘ฎ๐Ÿฝ": {}, + "๐Ÿ‘ฎ๐Ÿฝ\u200dโ™€๏ธ": {}, + "๐Ÿ‘ฎ๐Ÿฝ\u200dโ™‚๏ธ": {}, + "๐Ÿ‘ฎ๐Ÿพ": {}, + "๐Ÿ‘ฎ๐Ÿพ\u200dโ™€๏ธ": {}, + "๐Ÿ‘ฎ๐Ÿพ\u200dโ™‚๏ธ": {}, + "๐Ÿ‘ฎ๐Ÿฟ": {}, + "๐Ÿ‘ฎ๐Ÿฟ\u200dโ™€๏ธ": {}, + "๐Ÿ‘ฎ๐Ÿฟ\u200dโ™‚๏ธ": {}, + "๐Ÿ‘ฏ": {}, + "๐Ÿ‘ฏ\u200dโ™€๏ธ": {}, + "๐Ÿ‘ฏ\u200dโ™‚๏ธ": {}, + "๐Ÿ‘ฏ๐Ÿป": {}, + "๐Ÿ‘ฏ๐Ÿป\u200dโ™€๏ธ": {}, + "๐Ÿ‘ฏ๐Ÿป\u200dโ™‚๏ธ": {}, + "๐Ÿ‘ฏ๐Ÿผ": {}, + "๐Ÿ‘ฏ๐Ÿผ\u200dโ™€๏ธ": {}, + "๐Ÿ‘ฏ๐Ÿผ\u200dโ™‚๏ธ": {}, + "๐Ÿ‘ฏ๐Ÿฝ": {}, + "๐Ÿ‘ฏ๐Ÿฝ\u200dโ™€๏ธ": {}, + "๐Ÿ‘ฏ๐Ÿฝ\u200dโ™‚๏ธ": {}, + "๐Ÿ‘ฏ๐Ÿพ": {}, + "๐Ÿ‘ฏ๐Ÿพ\u200dโ™€๏ธ": {}, + "๐Ÿ‘ฏ๐Ÿพ\u200dโ™‚๏ธ": {}, + "๐Ÿ‘ฏ๐Ÿฟ": {}, + "๐Ÿ‘ฏ๐Ÿฟ\u200dโ™€๏ธ": {}, + "๐Ÿ‘ฏ๐Ÿฟ\u200dโ™‚๏ธ": {}, + "๐Ÿ‘ฐ": {}, + "๐Ÿ‘ฐ\u200dโ™€๏ธ": {}, + "๐Ÿ‘ฐ\u200dโ™‚๏ธ": {}, + "๐Ÿ‘ฐ๐Ÿป": {}, + "๐Ÿ‘ฐ๐Ÿป\u200dโ™€๏ธ": {}, + "๐Ÿ‘ฐ๐Ÿป\u200dโ™‚๏ธ": {}, + "๐Ÿ‘ฐ๐Ÿผ": {}, + "๐Ÿ‘ฐ๐Ÿผ\u200dโ™€๏ธ": {}, + "๐Ÿ‘ฐ๐Ÿผ\u200dโ™‚๏ธ": {}, + "๐Ÿ‘ฐ๐Ÿฝ": {}, + "๐Ÿ‘ฐ๐Ÿฝ\u200dโ™€๏ธ": {}, + "๐Ÿ‘ฐ๐Ÿฝ\u200dโ™‚๏ธ": {}, + "๐Ÿ‘ฐ๐Ÿพ": {}, + "๐Ÿ‘ฐ๐Ÿพ\u200dโ™€๏ธ": {}, + "๐Ÿ‘ฐ๐Ÿพ\u200dโ™‚๏ธ": {}, + "๐Ÿ‘ฐ๐Ÿฟ": {}, + "๐Ÿ‘ฐ๐Ÿฟ\u200dโ™€๏ธ": {}, + "๐Ÿ‘ฐ๐Ÿฟ\u200dโ™‚๏ธ": {}, + "๐Ÿ‘ฑ": {}, + "๐Ÿ‘ฑ\u200dโ™€๏ธ": {}, + "๐Ÿ‘ฑ\u200dโ™‚๏ธ": {}, + "๐Ÿ‘ฑ๐Ÿป": {}, + "๐Ÿ‘ฑ๐Ÿป\u200dโ™€๏ธ": {}, + "๐Ÿ‘ฑ๐Ÿป\u200dโ™‚๏ธ": {}, + "๐Ÿ‘ฑ๐Ÿผ": {}, + "๐Ÿ‘ฑ๐Ÿผ\u200dโ™€๏ธ": {}, + "๐Ÿ‘ฑ๐Ÿผ\u200dโ™‚๏ธ": {}, + "๐Ÿ‘ฑ๐Ÿฝ": {}, + "๐Ÿ‘ฑ๐Ÿฝ\u200dโ™€๏ธ": {}, + "๐Ÿ‘ฑ๐Ÿฝ\u200dโ™‚๏ธ": {}, + "๐Ÿ‘ฑ๐Ÿพ": {}, + "๐Ÿ‘ฑ๐Ÿพ\u200dโ™€๏ธ": {}, + "๐Ÿ‘ฑ๐Ÿพ\u200dโ™‚๏ธ": {}, + "๐Ÿ‘ฑ๐Ÿฟ": {}, + "๐Ÿ‘ฑ๐Ÿฟ\u200dโ™€๏ธ": {}, + "๐Ÿ‘ฑ๐Ÿฟ\u200dโ™‚๏ธ": {}, + "๐Ÿ‘ฒ": {}, + "๐Ÿ‘ฒ๐Ÿป": {}, + "๐Ÿ‘ฒ๐Ÿผ": {}, + "๐Ÿ‘ฒ๐Ÿฝ": {}, + "๐Ÿ‘ฒ๐Ÿพ": {}, + "๐Ÿ‘ฒ๐Ÿฟ": {}, + "๐Ÿ‘ณ": {}, + "๐Ÿ‘ณ\u200dโ™€๏ธ": {}, + "๐Ÿ‘ณ\u200dโ™‚๏ธ": {}, + "๐Ÿ‘ณ๐Ÿป": {}, + "๐Ÿ‘ณ๐Ÿป\u200dโ™€๏ธ": {}, + "๐Ÿ‘ณ๐Ÿป\u200dโ™‚๏ธ": {}, + "๐Ÿ‘ณ๐Ÿผ": {}, + "๐Ÿ‘ณ๐Ÿผ\u200dโ™€๏ธ": {}, + "๐Ÿ‘ณ๐Ÿผ\u200dโ™‚๏ธ": {}, + "๐Ÿ‘ณ๐Ÿฝ": {}, + "๐Ÿ‘ณ๐Ÿฝ\u200dโ™€๏ธ": {}, + "๐Ÿ‘ณ๐Ÿฝ\u200dโ™‚๏ธ": {}, + "๐Ÿ‘ณ๐Ÿพ": {}, + "๐Ÿ‘ณ๐Ÿพ\u200dโ™€๏ธ": {}, + "๐Ÿ‘ณ๐Ÿพ\u200dโ™‚๏ธ": {}, + "๐Ÿ‘ณ๐Ÿฟ": {}, + "๐Ÿ‘ณ๐Ÿฟ\u200dโ™€๏ธ": {}, + "๐Ÿ‘ณ๐Ÿฟ\u200dโ™‚๏ธ": {}, + "๐Ÿ‘ด": {}, + "๐Ÿ‘ด๐Ÿป": {}, + "๐Ÿ‘ด๐Ÿผ": {}, + "๐Ÿ‘ด๐Ÿฝ": {}, + "๐Ÿ‘ด๐Ÿพ": {}, + "๐Ÿ‘ด๐Ÿฟ": {}, + "๐Ÿ‘ต": {}, + "๐Ÿ‘ต๐Ÿป": {}, + "๐Ÿ‘ต๐Ÿผ": {}, + "๐Ÿ‘ต๐Ÿฝ": {}, + "๐Ÿ‘ต๐Ÿพ": {}, + "๐Ÿ‘ต๐Ÿฟ": {}, + "๐Ÿ‘ถ": {}, + "๐Ÿ‘ถ๐Ÿป": {}, + "๐Ÿ‘ถ๐Ÿผ": {}, + "๐Ÿ‘ถ๐Ÿฝ": {}, + "๐Ÿ‘ถ๐Ÿพ": {}, + "๐Ÿ‘ถ๐Ÿฟ": {}, + "๐Ÿ‘ท": {}, + "๐Ÿ‘ท\u200dโ™€๏ธ": {}, + "๐Ÿ‘ท\u200dโ™‚๏ธ": {}, + "๐Ÿ‘ท๐Ÿป": {}, + "๐Ÿ‘ท๐Ÿป\u200dโ™€๏ธ": {}, + "๐Ÿ‘ท๐Ÿป\u200dโ™‚๏ธ": {}, + "๐Ÿ‘ท๐Ÿผ": {}, + "๐Ÿ‘ท๐Ÿผ\u200dโ™€๏ธ": {}, + "๐Ÿ‘ท๐Ÿผ\u200dโ™‚๏ธ": {}, + "๐Ÿ‘ท๐Ÿฝ": {}, + "๐Ÿ‘ท๐Ÿฝ\u200dโ™€๏ธ": {}, + "๐Ÿ‘ท๐Ÿฝ\u200dโ™‚๏ธ": {}, + "๐Ÿ‘ท๐Ÿพ": {}, + "๐Ÿ‘ท๐Ÿพ\u200dโ™€๏ธ": {}, + "๐Ÿ‘ท๐Ÿพ\u200dโ™‚๏ธ": {}, + "๐Ÿ‘ท๐Ÿฟ": {}, + "๐Ÿ‘ท๐Ÿฟ\u200dโ™€๏ธ": {}, + "๐Ÿ‘ท๐Ÿฟ\u200dโ™‚๏ธ": {}, + "๐Ÿ‘ธ": {}, + "๐Ÿ‘ธ๐Ÿป": {}, + "๐Ÿ‘ธ๐Ÿผ": {}, + "๐Ÿ‘ธ๐Ÿฝ": {}, + "๐Ÿ‘ธ๐Ÿพ": {}, + "๐Ÿ‘ธ๐Ÿฟ": {}, + "๐Ÿ‘น": {}, + "๐Ÿ‘บ": {}, + "๐Ÿ‘ป": {}, + "๐Ÿ‘ผ": {}, + "๐Ÿ‘ผ๐Ÿป": {}, + "๐Ÿ‘ผ๐Ÿผ": {}, + "๐Ÿ‘ผ๐Ÿฝ": {}, + "๐Ÿ‘ผ๐Ÿพ": {}, + "๐Ÿ‘ผ๐Ÿฟ": {}, + "๐Ÿ‘ฝ": {}, + "๐Ÿ‘พ": {}, + "๐Ÿ‘ฟ": {}, + "๐Ÿ’€": {}, + "๐Ÿ’": {}, + "๐Ÿ’\u200dโ™€๏ธ": {}, + "๐Ÿ’\u200dโ™‚๏ธ": {}, + "๐Ÿ’๐Ÿป": {}, + "๐Ÿ’๐Ÿป\u200dโ™€๏ธ": {}, + "๐Ÿ’๐Ÿป\u200dโ™‚๏ธ": {}, + "๐Ÿ’๐Ÿผ": {}, + "๐Ÿ’๐Ÿผ\u200dโ™€๏ธ": {}, + "๐Ÿ’๐Ÿผ\u200dโ™‚๏ธ": {}, + "๐Ÿ’๐Ÿฝ": {}, + "๐Ÿ’๐Ÿฝ\u200dโ™€๏ธ": {}, + "๐Ÿ’๐Ÿฝ\u200dโ™‚๏ธ": {}, + "๐Ÿ’๐Ÿพ": {}, + "๐Ÿ’๐Ÿพ\u200dโ™€๏ธ": {}, + "๐Ÿ’๐Ÿพ\u200dโ™‚๏ธ": {}, + "๐Ÿ’๐Ÿฟ": {}, + "๐Ÿ’๐Ÿฟ\u200dโ™€๏ธ": {}, + "๐Ÿ’๐Ÿฟ\u200dโ™‚๏ธ": {}, + "๐Ÿ’‚": {}, + "๐Ÿ’‚\u200dโ™€๏ธ": {}, + "๐Ÿ’‚\u200dโ™‚๏ธ": {}, + "๐Ÿ’‚๐Ÿป": {}, + "๐Ÿ’‚๐Ÿป\u200dโ™€๏ธ": {}, + "๐Ÿ’‚๐Ÿป\u200dโ™‚๏ธ": {}, + "๐Ÿ’‚๐Ÿผ": {}, + "๐Ÿ’‚๐Ÿผ\u200dโ™€๏ธ": {}, + "๐Ÿ’‚๐Ÿผ\u200dโ™‚๏ธ": {}, + "๐Ÿ’‚๐Ÿฝ": {}, + "๐Ÿ’‚๐Ÿฝ\u200dโ™€๏ธ": {}, + "๐Ÿ’‚๐Ÿฝ\u200dโ™‚๏ธ": {}, + "๐Ÿ’‚๐Ÿพ": {}, + "๐Ÿ’‚๐Ÿพ\u200dโ™€๏ธ": {}, + "๐Ÿ’‚๐Ÿพ\u200dโ™‚๏ธ": {}, + "๐Ÿ’‚๐Ÿฟ": {}, + "๐Ÿ’‚๐Ÿฟ\u200dโ™€๏ธ": {}, + "๐Ÿ’‚๐Ÿฟ\u200dโ™‚๏ธ": {}, + "๐Ÿ’ƒ": {}, + "๐Ÿ’ƒ๐Ÿป": {}, + "๐Ÿ’ƒ๐Ÿผ": {}, + "๐Ÿ’ƒ๐Ÿฝ": {}, + "๐Ÿ’ƒ๐Ÿพ": {}, + "๐Ÿ’ƒ๐Ÿฟ": {}, + "๐Ÿ’„": {}, + "๐Ÿ’…": {}, + "๐Ÿ’…๐Ÿป": {}, + "๐Ÿ’…๐Ÿผ": {}, + "๐Ÿ’…๐Ÿฝ": {}, + "๐Ÿ’…๐Ÿพ": {}, + "๐Ÿ’…๐Ÿฟ": {}, + "๐Ÿ’†": {}, + "๐Ÿ’†\u200dโ™€๏ธ": {}, + "๐Ÿ’†\u200dโ™‚๏ธ": {}, + "๐Ÿ’†๐Ÿป": {}, + "๐Ÿ’†๐Ÿป\u200dโ™€๏ธ": {}, + "๐Ÿ’†๐Ÿป\u200dโ™‚๏ธ": {}, + "๐Ÿ’†๐Ÿผ": {}, + "๐Ÿ’†๐Ÿผ\u200dโ™€๏ธ": {}, + "๐Ÿ’†๐Ÿผ\u200dโ™‚๏ธ": {}, + "๐Ÿ’†๐Ÿฝ": {}, + "๐Ÿ’†๐Ÿฝ\u200dโ™€๏ธ": {}, + "๐Ÿ’†๐Ÿฝ\u200dโ™‚๏ธ": {}, + "๐Ÿ’†๐Ÿพ": {}, + "๐Ÿ’†๐Ÿพ\u200dโ™€๏ธ": {}, + "๐Ÿ’†๐Ÿพ\u200dโ™‚๏ธ": {}, + "๐Ÿ’†๐Ÿฟ": {}, + "๐Ÿ’†๐Ÿฟ\u200dโ™€๏ธ": {}, + "๐Ÿ’†๐Ÿฟ\u200dโ™‚๏ธ": {}, + "๐Ÿ’‡": {}, + "๐Ÿ’‡\u200dโ™€๏ธ": {}, + "๐Ÿ’‡\u200dโ™‚๏ธ": {}, + "๐Ÿ’‡๐Ÿป": {}, + "๐Ÿ’‡๐Ÿป\u200dโ™€๏ธ": {}, + "๐Ÿ’‡๐Ÿป\u200dโ™‚๏ธ": {}, + "๐Ÿ’‡๐Ÿผ": {}, + "๐Ÿ’‡๐Ÿผ\u200dโ™€๏ธ": {}, + "๐Ÿ’‡๐Ÿผ\u200dโ™‚๏ธ": {}, + "๐Ÿ’‡๐Ÿฝ": {}, + "๐Ÿ’‡๐Ÿฝ\u200dโ™€๏ธ": {}, + "๐Ÿ’‡๐Ÿฝ\u200dโ™‚๏ธ": {}, + "๐Ÿ’‡๐Ÿพ": {}, + "๐Ÿ’‡๐Ÿพ\u200dโ™€๏ธ": {}, + "๐Ÿ’‡๐Ÿพ\u200dโ™‚๏ธ": {}, + "๐Ÿ’‡๐Ÿฟ": {}, + "๐Ÿ’‡๐Ÿฟ\u200dโ™€๏ธ": {}, + "๐Ÿ’‡๐Ÿฟ\u200dโ™‚๏ธ": {}, + "๐Ÿ’ˆ": {}, + "๐Ÿ’‰": {}, + "๐Ÿ’Š": {}, + "๐Ÿ’‹": {}, + "๐Ÿ’Œ": {}, + "๐Ÿ’": {}, + "๐Ÿ’Ž": {}, + "๐Ÿ’": {}, + "๐Ÿ’๐Ÿป": {}, + "๐Ÿ’๐Ÿผ": {}, + "๐Ÿ’๐Ÿฝ": {}, + "๐Ÿ’๐Ÿพ": {}, + "๐Ÿ’๐Ÿฟ": {}, + "๐Ÿ’": {}, + "๐Ÿ’‘": {}, + "๐Ÿ’‘๐Ÿป": {}, + "๐Ÿ’‘๐Ÿผ": {}, + "๐Ÿ’‘๐Ÿฝ": {}, + "๐Ÿ’‘๐Ÿพ": {}, + "๐Ÿ’‘๐Ÿฟ": {}, + "๐Ÿ’’": {}, + "๐Ÿ’“": {}, + "๐Ÿ’”": {}, + "๐Ÿ’•": {}, + "๐Ÿ’–": {}, + "๐Ÿ’—": {}, + "๐Ÿ’˜": {}, + "๐Ÿ’™": {}, + "๐Ÿ’š": {}, + "๐Ÿ’›": {}, + "๐Ÿ’œ": {}, + "๐Ÿ’": {}, + "๐Ÿ’ž": {}, + "๐Ÿ’Ÿ": {}, + "๐Ÿ’ ": {}, + "๐Ÿ’ก": {}, + "๐Ÿ’ข": {}, + "๐Ÿ’ฃ": {}, + "๐Ÿ’ค": {}, + "๐Ÿ’ฅ": {}, + "๐Ÿ’ฆ": {}, + "๐Ÿ’ง": {}, + "๐Ÿ’จ": {}, + "๐Ÿ’ฉ": {}, + "๐Ÿ’ช": {}, + "๐Ÿ’ช๐Ÿป": {}, + "๐Ÿ’ช๐Ÿผ": {}, + "๐Ÿ’ช๐Ÿฝ": {}, + "๐Ÿ’ช๐Ÿพ": {}, + "๐Ÿ’ช๐Ÿฟ": {}, + "๐Ÿ’ซ": {}, + "๐Ÿ’ฌ": {}, + "๐Ÿ’ญ": {}, + "๐Ÿ’ฎ": {}, + "๐Ÿ’ฏ": {}, + "๐Ÿ’ฐ": {}, + "๐Ÿ’ฑ": {}, + "๐Ÿ’ฒ": {}, + "๐Ÿ’ณ": {}, + "๐Ÿ’ด": {}, + "๐Ÿ’ต": {}, + "๐Ÿ’ถ": {}, + "๐Ÿ’ท": {}, + "๐Ÿ’ธ": {}, + "๐Ÿ’น": {}, + "๐Ÿ’บ": {}, + "๐Ÿ’ป": {}, + "๐Ÿ’ผ": {}, + "๐Ÿ’ฝ": {}, + "๐Ÿ’พ": {}, + "๐Ÿ’ฟ": {}, + "๐Ÿ“€": {}, + "๐Ÿ“": {}, + "๐Ÿ“‚": {}, + "๐Ÿ“ƒ": {}, + "๐Ÿ“„": {}, + "๐Ÿ“…": {}, + "๐Ÿ“†": {}, + "๐Ÿ“‡": {}, + "๐Ÿ“ˆ": {}, + "๐Ÿ“‰": {}, + "๐Ÿ“Š": {}, + "๐Ÿ“‹": {}, + "๐Ÿ“Œ": {}, + "๐Ÿ“": {}, + "๐Ÿ“Ž": {}, + "๐Ÿ“": {}, + "๐Ÿ“": {}, + "๐Ÿ“‘": {}, + "๐Ÿ“’": {}, + "๐Ÿ““": {}, + "๐Ÿ“”": {}, + "๐Ÿ“•": {}, + "๐Ÿ“–": {}, + "๐Ÿ“—": {}, + "๐Ÿ“˜": {}, + "๐Ÿ“™": {}, + "๐Ÿ“š": {}, + "๐Ÿ“›": {}, + "๐Ÿ“œ": {}, + "๐Ÿ“": {}, + "๐Ÿ“ž": {}, + "๐Ÿ“Ÿ": {}, + "๐Ÿ“ ": {}, + "๐Ÿ“ก": {}, + "๐Ÿ“ข": {}, + "๐Ÿ“ฃ": {}, + "๐Ÿ“ค": {}, + "๐Ÿ“ฅ": {}, + "๐Ÿ“ฆ": {}, + "๐Ÿ“ง": {}, + "๐Ÿ“จ": {}, + "๐Ÿ“ฉ": {}, + "๐Ÿ“ช": {}, + "๐Ÿ“ซ": {}, + "๐Ÿ“ฌ": {}, + "๐Ÿ“ญ": {}, + "๐Ÿ“ฎ": {}, + "๐Ÿ“ฏ": {}, + "๐Ÿ“ฐ": {}, + "๐Ÿ“ฑ": {}, + "๐Ÿ“ฒ": {}, + "๐Ÿ“ณ": {}, + "๐Ÿ“ด": {}, + "๐Ÿ“ต": {}, + "๐Ÿ“ถ": {}, + "๐Ÿ“ท": {}, + "๐Ÿ“ธ": {}, + "๐Ÿ“น": {}, + "๐Ÿ“บ": {}, + "๐Ÿ“ป": {}, + "๐Ÿ“ผ": {}, + "๐Ÿ“ฝ๏ธ": {}, + "๐Ÿ“ฟ": {}, + "๐Ÿ”€": {}, + "๐Ÿ”": {}, + "๐Ÿ”‚": {}, + "๐Ÿ”ƒ": {}, + "๐Ÿ”„": {}, + "๐Ÿ”…": {}, + "๐Ÿ”†": {}, + "๐Ÿ”‡": {}, + "๐Ÿ”ˆ": {}, + "๐Ÿ”‰": {}, + "๐Ÿ”Š": {}, + "๐Ÿ”‹": {}, + "๐Ÿ”Œ": {}, + "๐Ÿ”": {}, + "๐Ÿ”Ž": {}, + "๐Ÿ”": {}, + "๐Ÿ”": {}, + "๐Ÿ”‘": {}, + "๐Ÿ”’": {}, + "๐Ÿ”“": {}, + "๐Ÿ””": {}, + "๐Ÿ”•": {}, + "๐Ÿ”–": {}, + "๐Ÿ”—": {}, + "๐Ÿ”˜": {}, + "๐Ÿ”™": {}, + "๐Ÿ”š": {}, + "๐Ÿ”›": {}, + "๐Ÿ”œ": {}, + "๐Ÿ”": {}, + "๐Ÿ”ž": {}, + "๐Ÿ”Ÿ": {}, + "๐Ÿ” ": {}, + "๐Ÿ”ก": {}, + "๐Ÿ”ข": {}, + "๐Ÿ”ฃ": {}, + "๐Ÿ”ค": {}, + "๐Ÿ”ฅ": {}, + "๐Ÿ”ฆ": {}, + "๐Ÿ”ง": {}, + "๐Ÿ”จ": {}, + "๐Ÿ”ฉ": {}, + "๐Ÿ”ช": {}, + "๐Ÿ”ซ": {}, + "๐Ÿ”ฌ": {}, + "๐Ÿ”ญ": {}, + "๐Ÿ”ฎ": {}, + "๐Ÿ”ฏ": {}, + "๐Ÿ”ฐ": {}, + "๐Ÿ”ฑ": {}, + "๐Ÿ”ฒ": {}, + "๐Ÿ”ณ": {}, + "๐Ÿ”ด": {}, + "๐Ÿ”ต": {}, + "๐Ÿ”ถ": {}, + "๐Ÿ”ท": {}, + "๐Ÿ”ธ": {}, + "๐Ÿ”น": {}, + "๐Ÿ”บ": {}, + "๐Ÿ”ป": {}, + "๐Ÿ”ผ": {}, + "๐Ÿ”ฝ": {}, + "๐Ÿ•‰๏ธ": {}, + "๐Ÿ•Š๏ธ": {}, + "๐Ÿ•‹": {}, + "๐Ÿ•Œ": {}, + "๐Ÿ•": {}, + "๐Ÿ•Ž": {}, + "๐Ÿ•": {}, + "๐Ÿ•‘": {}, + "๐Ÿ•’": {}, + "๐Ÿ•“": {}, + "๐Ÿ•”": {}, + "๐Ÿ••": {}, + "๐Ÿ•–": {}, + "๐Ÿ•—": {}, + "๐Ÿ•˜": {}, + "๐Ÿ•™": {}, + "๐Ÿ•š": {}, + "๐Ÿ•›": {}, + "๐Ÿ•œ": {}, + "๐Ÿ•": {}, + "๐Ÿ•ž": {}, + "๐Ÿ•Ÿ": {}, + "๐Ÿ• ": {}, + "๐Ÿ•ก": {}, + "๐Ÿ•ข": {}, + "๐Ÿ•ฃ": {}, + "๐Ÿ•ค": {}, + "๐Ÿ•ฅ": {}, + "๐Ÿ•ฆ": {}, + "๐Ÿ•ง": {}, + "๐Ÿ•ฏ๏ธ": {}, + "๐Ÿ•ฐ๏ธ": {}, + "๐Ÿ•ณ๏ธ": {}, + "๐Ÿ•ด๏ธ": {}, + "๐Ÿ•ด๐Ÿป": {}, + "๐Ÿ•ด๐Ÿผ": {}, + "๐Ÿ•ด๐Ÿฝ": {}, + "๐Ÿ•ด๐Ÿพ": {}, + "๐Ÿ•ด๐Ÿฟ": {}, + "๐Ÿ•ต๏ธ": {}, + "๐Ÿ•ต๏ธ\u200dโ™€๏ธ": {}, + "๐Ÿ•ต๏ธ\u200dโ™‚๏ธ": {}, + "๐Ÿ•ต๐Ÿป": {}, + "๐Ÿ•ต๐Ÿป\u200dโ™€๏ธ": {}, + "๐Ÿ•ต๐Ÿป\u200dโ™‚๏ธ": {}, + "๐Ÿ•ต๐Ÿผ": {}, + "๐Ÿ•ต๐Ÿผ\u200dโ™€๏ธ": {}, + "๐Ÿ•ต๐Ÿผ\u200dโ™‚๏ธ": {}, + "๐Ÿ•ต๐Ÿฝ": {}, + "๐Ÿ•ต๐Ÿฝ\u200dโ™€๏ธ": {}, + "๐Ÿ•ต๐Ÿฝ\u200dโ™‚๏ธ": {}, + "๐Ÿ•ต๐Ÿพ": {}, + "๐Ÿ•ต๐Ÿพ\u200dโ™€๏ธ": {}, + "๐Ÿ•ต๐Ÿพ\u200dโ™‚๏ธ": {}, + "๐Ÿ•ต๐Ÿฟ": {}, + "๐Ÿ•ต๐Ÿฟ\u200dโ™€๏ธ": {}, + "๐Ÿ•ต๐Ÿฟ\u200dโ™‚๏ธ": {}, + "๐Ÿ•ถ๏ธ": {}, + "๐Ÿ•ท๏ธ": {}, + "๐Ÿ•ธ๏ธ": {}, + "๐Ÿ•น๏ธ": {}, + "๐Ÿ•บ": {}, + "๐Ÿ•บ๐Ÿป": {}, + "๐Ÿ•บ๐Ÿผ": {}, + "๐Ÿ•บ๐Ÿฝ": {}, + "๐Ÿ•บ๐Ÿพ": {}, + "๐Ÿ•บ๐Ÿฟ": {}, + "๐Ÿ–‡๏ธ": {}, + "๐Ÿ–Š๏ธ": {}, + "๐Ÿ–‹๏ธ": {}, + "๐Ÿ–Œ๏ธ": {}, + "๐Ÿ–๏ธ": {}, + "๐Ÿ–๏ธ": {}, + "๐Ÿ–๐Ÿป": {}, + "๐Ÿ–๐Ÿผ": {}, + "๐Ÿ–๐Ÿฝ": {}, + "๐Ÿ–๐Ÿพ": {}, + "๐Ÿ–๐Ÿฟ": {}, + "๐Ÿ–•": {}, + "๐Ÿ–•๐Ÿป": {}, + "๐Ÿ–•๐Ÿผ": {}, + "๐Ÿ–•๐Ÿฝ": {}, + "๐Ÿ–•๐Ÿพ": {}, + "๐Ÿ–•๐Ÿฟ": {}, + "๐Ÿ––": {}, + "๐Ÿ––๐Ÿป": {}, + "๐Ÿ––๐Ÿผ": {}, + "๐Ÿ––๐Ÿฝ": {}, + "๐Ÿ––๐Ÿพ": {}, + "๐Ÿ––๐Ÿฟ": {}, + "๐Ÿ–ค": {}, + "๐Ÿ–ฅ๏ธ": {}, + "๐Ÿ–จ๏ธ": {}, + "๐Ÿ–ฑ๏ธ": {}, + "๐Ÿ–ฒ๏ธ": {}, + "๐Ÿ–ผ๏ธ": {}, + "๐Ÿ—‚๏ธ": {}, + "๐Ÿ—ƒ๏ธ": {}, + "๐Ÿ—„๏ธ": {}, + "๐Ÿ—‘๏ธ": {}, + "๐Ÿ—’๏ธ": {}, + "๐Ÿ—“๏ธ": {}, + "๐Ÿ—œ๏ธ": {}, + "๐Ÿ—๏ธ": {}, + "๐Ÿ—ž๏ธ": {}, + "๐Ÿ—ก๏ธ": {}, + "๐Ÿ—ฃ๏ธ": {}, + "๐Ÿ—จ๏ธ": {}, + "๐Ÿ—ฏ๏ธ": {}, + "๐Ÿ—ณ๏ธ": {}, + "๐Ÿ—บ๏ธ": {}, + "๐Ÿ—ป": {}, + "๐Ÿ—ผ": {}, + "๐Ÿ—ฝ": {}, + "๐Ÿ—พ": {}, + "๐Ÿ—ฟ": {}, + "๐Ÿ˜€": {}, + "๐Ÿ˜": {}, + "๐Ÿ˜‚": {}, + "๐Ÿ˜ƒ": {}, + "๐Ÿ˜„": {}, + "๐Ÿ˜…": {}, + "๐Ÿ˜†": {}, + "๐Ÿ˜‡": {}, + "๐Ÿ˜ˆ": {}, + "๐Ÿ˜‰": {}, + "๐Ÿ˜Š": {}, + "๐Ÿ˜‹": {}, + "๐Ÿ˜Œ": {}, + "๐Ÿ˜": {}, + "๐Ÿ˜Ž": {}, + "๐Ÿ˜": {}, + "๐Ÿ˜": {}, + "๐Ÿ˜‘": {}, + "๐Ÿ˜’": {}, + "๐Ÿ˜“": {}, + "๐Ÿ˜”": {}, + "๐Ÿ˜•": {}, + "๐Ÿ˜–": {}, + "๐Ÿ˜—": {}, + "๐Ÿ˜˜": {}, + "๐Ÿ˜™": {}, + "๐Ÿ˜š": {}, + "๐Ÿ˜›": {}, + "๐Ÿ˜œ": {}, + "๐Ÿ˜": {}, + "๐Ÿ˜ž": {}, + "๐Ÿ˜Ÿ": {}, + "๐Ÿ˜ ": {}, + "๐Ÿ˜ก": {}, + "๐Ÿ˜ข": {}, + "๐Ÿ˜ฃ": {}, + "๐Ÿ˜ค": {}, + "๐Ÿ˜ฅ": {}, + "๐Ÿ˜ฆ": {}, + "๐Ÿ˜ง": {}, + "๐Ÿ˜จ": {}, + "๐Ÿ˜ฉ": {}, + "๐Ÿ˜ช": {}, + "๐Ÿ˜ซ": {}, + "๐Ÿ˜ฌ": {}, + "๐Ÿ˜ญ": {}, + "๐Ÿ˜ฎ": {}, + "๐Ÿ˜ฎ\u200d๐Ÿ’จ": {}, + "๐Ÿ˜ฏ": {}, + "๐Ÿ˜ฐ": {}, + "๐Ÿ˜ฑ": {}, + "๐Ÿ˜ฒ": {}, + "๐Ÿ˜ณ": {}, + "๐Ÿ˜ด": {}, + "๐Ÿ˜ต": {}, + "๐Ÿ˜ต\u200d๐Ÿ’ซ": {}, + "๐Ÿ˜ถ": {}, + "๐Ÿ˜ถ\u200d๐ŸŒซ๏ธ": {}, + "๐Ÿ˜ท": {}, + "๐Ÿ˜ธ": {}, + "๐Ÿ˜น": {}, + "๐Ÿ˜บ": {}, + "๐Ÿ˜ป": {}, + "๐Ÿ˜ผ": {}, + "๐Ÿ˜ฝ": {}, + "๐Ÿ˜พ": {}, + "๐Ÿ˜ฟ": {}, + "๐Ÿ™€": {}, + "๐Ÿ™": {}, + "๐Ÿ™‚": {}, + "๐Ÿ™‚\u200dโ†”๏ธ": {}, + "๐Ÿ™‚\u200dโ†•๏ธ": {}, + "๐Ÿ™ƒ": {}, + "๐Ÿ™„": {}, + "๐Ÿ™…": {}, + "๐Ÿ™…\u200dโ™€๏ธ": {}, + "๐Ÿ™…\u200dโ™‚๏ธ": {}, + "๐Ÿ™…๐Ÿป": {}, + "๐Ÿ™…๐Ÿป\u200dโ™€๏ธ": {}, + "๐Ÿ™…๐Ÿป\u200dโ™‚๏ธ": {}, + "๐Ÿ™…๐Ÿผ": {}, + "๐Ÿ™…๐Ÿผ\u200dโ™€๏ธ": {}, + "๐Ÿ™…๐Ÿผ\u200dโ™‚๏ธ": {}, + "๐Ÿ™…๐Ÿฝ": {}, + "๐Ÿ™…๐Ÿฝ\u200dโ™€๏ธ": {}, + "๐Ÿ™…๐Ÿฝ\u200dโ™‚๏ธ": {}, + "๐Ÿ™…๐Ÿพ": {}, + "๐Ÿ™…๐Ÿพ\u200dโ™€๏ธ": {}, + "๐Ÿ™…๐Ÿพ\u200dโ™‚๏ธ": {}, + "๐Ÿ™…๐Ÿฟ": {}, + "๐Ÿ™…๐Ÿฟ\u200dโ™€๏ธ": {}, + "๐Ÿ™…๐Ÿฟ\u200dโ™‚๏ธ": {}, + "๐Ÿ™†": {}, + "๐Ÿ™†\u200dโ™€๏ธ": {}, + "๐Ÿ™†\u200dโ™‚๏ธ": {}, + "๐Ÿ™†๐Ÿป": {}, + "๐Ÿ™†๐Ÿป\u200dโ™€๏ธ": {}, + "๐Ÿ™†๐Ÿป\u200dโ™‚๏ธ": {}, + "๐Ÿ™†๐Ÿผ": {}, + "๐Ÿ™†๐Ÿผ\u200dโ™€๏ธ": {}, + "๐Ÿ™†๐Ÿผ\u200dโ™‚๏ธ": {}, + "๐Ÿ™†๐Ÿฝ": {}, + "๐Ÿ™†๐Ÿฝ\u200dโ™€๏ธ": {}, + "๐Ÿ™†๐Ÿฝ\u200dโ™‚๏ธ": {}, + "๐Ÿ™†๐Ÿพ": {}, + "๐Ÿ™†๐Ÿพ\u200dโ™€๏ธ": {}, + "๐Ÿ™†๐Ÿพ\u200dโ™‚๏ธ": {}, + "๐Ÿ™†๐Ÿฟ": {}, + "๐Ÿ™†๐Ÿฟ\u200dโ™€๏ธ": {}, + "๐Ÿ™†๐Ÿฟ\u200dโ™‚๏ธ": {}, + "๐Ÿ™‡": {}, + "๐Ÿ™‡\u200dโ™€๏ธ": {}, + "๐Ÿ™‡\u200dโ™‚๏ธ": {}, + "๐Ÿ™‡๐Ÿป": {}, + "๐Ÿ™‡๐Ÿป\u200dโ™€๏ธ": {}, + "๐Ÿ™‡๐Ÿป\u200dโ™‚๏ธ": {}, + "๐Ÿ™‡๐Ÿผ": {}, + "๐Ÿ™‡๐Ÿผ\u200dโ™€๏ธ": {}, + "๐Ÿ™‡๐Ÿผ\u200dโ™‚๏ธ": {}, + "๐Ÿ™‡๐Ÿฝ": {}, + "๐Ÿ™‡๐Ÿฝ\u200dโ™€๏ธ": {}, + "๐Ÿ™‡๐Ÿฝ\u200dโ™‚๏ธ": {}, + "๐Ÿ™‡๐Ÿพ": {}, + "๐Ÿ™‡๐Ÿพ\u200dโ™€๏ธ": {}, + "๐Ÿ™‡๐Ÿพ\u200dโ™‚๏ธ": {}, + "๐Ÿ™‡๐Ÿฟ": {}, + "๐Ÿ™‡๐Ÿฟ\u200dโ™€๏ธ": {}, + "๐Ÿ™‡๐Ÿฟ\u200dโ™‚๏ธ": {}, + "๐Ÿ™ˆ": {}, + "๐Ÿ™‰": {}, + "๐Ÿ™Š": {}, + "๐Ÿ™‹": {}, + "๐Ÿ™‹\u200dโ™€๏ธ": {}, + "๐Ÿ™‹\u200dโ™‚๏ธ": {}, + "๐Ÿ™‹๐Ÿป": {}, + "๐Ÿ™‹๐Ÿป\u200dโ™€๏ธ": {}, + "๐Ÿ™‹๐Ÿป\u200dโ™‚๏ธ": {}, + "๐Ÿ™‹๐Ÿผ": {}, + "๐Ÿ™‹๐Ÿผ\u200dโ™€๏ธ": {}, + "๐Ÿ™‹๐Ÿผ\u200dโ™‚๏ธ": {}, + "๐Ÿ™‹๐Ÿฝ": {}, + "๐Ÿ™‹๐Ÿฝ\u200dโ™€๏ธ": {}, + "๐Ÿ™‹๐Ÿฝ\u200dโ™‚๏ธ": {}, + "๐Ÿ™‹๐Ÿพ": {}, + "๐Ÿ™‹๐Ÿพ\u200dโ™€๏ธ": {}, + "๐Ÿ™‹๐Ÿพ\u200dโ™‚๏ธ": {}, + "๐Ÿ™‹๐Ÿฟ": {}, + "๐Ÿ™‹๐Ÿฟ\u200dโ™€๏ธ": {}, + "๐Ÿ™‹๐Ÿฟ\u200dโ™‚๏ธ": {}, + "๐Ÿ™Œ": {}, + "๐Ÿ™Œ๐Ÿป": {}, + "๐Ÿ™Œ๐Ÿผ": {}, + "๐Ÿ™Œ๐Ÿฝ": {}, + "๐Ÿ™Œ๐Ÿพ": {}, + "๐Ÿ™Œ๐Ÿฟ": {}, + "๐Ÿ™": {}, + "๐Ÿ™\u200dโ™€๏ธ": {}, + "๐Ÿ™\u200dโ™‚๏ธ": {}, + "๐Ÿ™๐Ÿป": {}, + "๐Ÿ™๐Ÿป\u200dโ™€๏ธ": {}, + "๐Ÿ™๐Ÿป\u200dโ™‚๏ธ": {}, + "๐Ÿ™๐Ÿผ": {}, + "๐Ÿ™๐Ÿผ\u200dโ™€๏ธ": {}, + "๐Ÿ™๐Ÿผ\u200dโ™‚๏ธ": {}, + "๐Ÿ™๐Ÿฝ": {}, + "๐Ÿ™๐Ÿฝ\u200dโ™€๏ธ": {}, + "๐Ÿ™๐Ÿฝ\u200dโ™‚๏ธ": {}, + "๐Ÿ™๐Ÿพ": {}, + "๐Ÿ™๐Ÿพ\u200dโ™€๏ธ": {}, + "๐Ÿ™๐Ÿพ\u200dโ™‚๏ธ": {}, + "๐Ÿ™๐Ÿฟ": {}, + "๐Ÿ™๐Ÿฟ\u200dโ™€๏ธ": {}, + "๐Ÿ™๐Ÿฟ\u200dโ™‚๏ธ": {}, + "๐Ÿ™Ž": {}, + "๐Ÿ™Ž\u200dโ™€๏ธ": {}, + "๐Ÿ™Ž\u200dโ™‚๏ธ": {}, + "๐Ÿ™Ž๐Ÿป": {}, + "๐Ÿ™Ž๐Ÿป\u200dโ™€๏ธ": {}, + "๐Ÿ™Ž๐Ÿป\u200dโ™‚๏ธ": {}, + "๐Ÿ™Ž๐Ÿผ": {}, + "๐Ÿ™Ž๐Ÿผ\u200dโ™€๏ธ": {}, + "๐Ÿ™Ž๐Ÿผ\u200dโ™‚๏ธ": {}, + "๐Ÿ™Ž๐Ÿฝ": {}, + "๐Ÿ™Ž๐Ÿฝ\u200dโ™€๏ธ": {}, + "๐Ÿ™Ž๐Ÿฝ\u200dโ™‚๏ธ": {}, + "๐Ÿ™Ž๐Ÿพ": {}, + "๐Ÿ™Ž๐Ÿพ\u200dโ™€๏ธ": {}, + "๐Ÿ™Ž๐Ÿพ\u200dโ™‚๏ธ": {}, + "๐Ÿ™Ž๐Ÿฟ": {}, + "๐Ÿ™Ž๐Ÿฟ\u200dโ™€๏ธ": {}, + "๐Ÿ™Ž๐Ÿฟ\u200dโ™‚๏ธ": {}, + "๐Ÿ™": {}, + "๐Ÿ™๐Ÿป": {}, + "๐Ÿ™๐Ÿผ": {}, + "๐Ÿ™๐Ÿฝ": {}, + "๐Ÿ™๐Ÿพ": {}, + "๐Ÿ™๐Ÿฟ": {}, + "๐Ÿš€": {}, + "๐Ÿš": {}, + "๐Ÿš‚": {}, + "๐Ÿšƒ": {}, + "๐Ÿš„": {}, + "๐Ÿš…": {}, + "๐Ÿš†": {}, + "๐Ÿš‡": {}, + "๐Ÿšˆ": {}, + "๐Ÿš‰": {}, + "๐ŸšŠ": {}, + "๐Ÿš‹": {}, + "๐ŸšŒ": {}, + "๐Ÿš": {}, + "๐ŸšŽ": {}, + "๐Ÿš": {}, + "๐Ÿš": {}, + "๐Ÿš‘": {}, + "๐Ÿš’": {}, + "๐Ÿš“": {}, + "๐Ÿš”": {}, + "๐Ÿš•": {}, + "๐Ÿš–": {}, + "๐Ÿš—": {}, + "๐Ÿš˜": {}, + "๐Ÿš™": {}, + "๐Ÿšš": {}, + "๐Ÿš›": {}, + "๐Ÿšœ": {}, + "๐Ÿš": {}, + "๐Ÿšž": {}, + "๐ŸšŸ": {}, + "๐Ÿš ": {}, + "๐Ÿšก": {}, + "๐Ÿšข": {}, + "๐Ÿšฃ": {}, + "๐Ÿšฃ\u200dโ™€๏ธ": {}, + "๐Ÿšฃ\u200dโ™‚๏ธ": {}, + "๐Ÿšฃ๐Ÿป": {}, + "๐Ÿšฃ๐Ÿป\u200dโ™€๏ธ": {}, + "๐Ÿšฃ๐Ÿป\u200dโ™‚๏ธ": {}, + "๐Ÿšฃ๐Ÿผ": {}, + "๐Ÿšฃ๐Ÿผ\u200dโ™€๏ธ": {}, + "๐Ÿšฃ๐Ÿผ\u200dโ™‚๏ธ": {}, + "๐Ÿšฃ๐Ÿฝ": {}, + "๐Ÿšฃ๐Ÿฝ\u200dโ™€๏ธ": {}, + "๐Ÿšฃ๐Ÿฝ\u200dโ™‚๏ธ": {}, + "๐Ÿšฃ๐Ÿพ": {}, + "๐Ÿšฃ๐Ÿพ\u200dโ™€๏ธ": {}, + "๐Ÿšฃ๐Ÿพ\u200dโ™‚๏ธ": {}, + "๐Ÿšฃ๐Ÿฟ": {}, + "๐Ÿšฃ๐Ÿฟ\u200dโ™€๏ธ": {}, + "๐Ÿšฃ๐Ÿฟ\u200dโ™‚๏ธ": {}, + "๐Ÿšค": {}, + "๐Ÿšฅ": {}, + "๐Ÿšฆ": {}, + "๐Ÿšง": {}, + "๐Ÿšจ": {}, + "๐Ÿšฉ": {}, + "๐Ÿšช": {}, + "๐Ÿšซ": {}, + "๐Ÿšฌ": {}, + "๐Ÿšญ": {}, + "๐Ÿšฎ": {}, + "๐Ÿšฏ": {}, + "๐Ÿšฐ": {}, + "๐Ÿšฑ": {}, + "๐Ÿšฒ": {}, + "๐Ÿšณ": {}, + "๐Ÿšด": {}, + "๐Ÿšด\u200dโ™€๏ธ": {}, + "๐Ÿšด\u200dโ™‚๏ธ": {}, + "๐Ÿšด๐Ÿป": {}, + "๐Ÿšด๐Ÿป\u200dโ™€๏ธ": {}, + "๐Ÿšด๐Ÿป\u200dโ™‚๏ธ": {}, + "๐Ÿšด๐Ÿผ": {}, + "๐Ÿšด๐Ÿผ\u200dโ™€๏ธ": {}, + "๐Ÿšด๐Ÿผ\u200dโ™‚๏ธ": {}, + "๐Ÿšด๐Ÿฝ": {}, + "๐Ÿšด๐Ÿฝ\u200dโ™€๏ธ": {}, + "๐Ÿšด๐Ÿฝ\u200dโ™‚๏ธ": {}, + "๐Ÿšด๐Ÿพ": {}, + "๐Ÿšด๐Ÿพ\u200dโ™€๏ธ": {}, + "๐Ÿšด๐Ÿพ\u200dโ™‚๏ธ": {}, + "๐Ÿšด๐Ÿฟ": {}, + "๐Ÿšด๐Ÿฟ\u200dโ™€๏ธ": {}, + "๐Ÿšด๐Ÿฟ\u200dโ™‚๏ธ": {}, + "๐Ÿšต": {}, + "๐Ÿšต\u200dโ™€๏ธ": {}, + "๐Ÿšต\u200dโ™‚๏ธ": {}, + "๐Ÿšต๐Ÿป": {}, + "๐Ÿšต๐Ÿป\u200dโ™€๏ธ": {}, + "๐Ÿšต๐Ÿป\u200dโ™‚๏ธ": {}, + "๐Ÿšต๐Ÿผ": {}, + "๐Ÿšต๐Ÿผ\u200dโ™€๏ธ": {}, + "๐Ÿšต๐Ÿผ\u200dโ™‚๏ธ": {}, + "๐Ÿšต๐Ÿฝ": {}, + "๐Ÿšต๐Ÿฝ\u200dโ™€๏ธ": {}, + "๐Ÿšต๐Ÿฝ\u200dโ™‚๏ธ": {}, + "๐Ÿšต๐Ÿพ": {}, + "๐Ÿšต๐Ÿพ\u200dโ™€๏ธ": {}, + "๐Ÿšต๐Ÿพ\u200dโ™‚๏ธ": {}, + "๐Ÿšต๐Ÿฟ": {}, + "๐Ÿšต๐Ÿฟ\u200dโ™€๏ธ": {}, + "๐Ÿšต๐Ÿฟ\u200dโ™‚๏ธ": {}, + "๐Ÿšถ": {}, + "๐Ÿšถ\u200dโ™€๏ธ": {}, + "๐Ÿšถ\u200dโ™€๏ธ\u200dโžก๏ธ": {}, + "๐Ÿšถ\u200dโ™‚๏ธ": {}, + "๐Ÿšถ\u200dโ™‚๏ธ\u200dโžก๏ธ": {}, + "๐Ÿšถ\u200dโžก๏ธ": {}, + "๐Ÿšถ๐Ÿป": {}, + "๐Ÿšถ๐Ÿป\u200dโ™€๏ธ": {}, + "๐Ÿšถ๐Ÿป\u200dโ™€๏ธ\u200dโžก๏ธ": {}, + "๐Ÿšถ๐Ÿป\u200dโ™‚๏ธ": {}, + "๐Ÿšถ๐Ÿป\u200dโ™‚๏ธ\u200dโžก๏ธ": {}, + "๐Ÿšถ๐Ÿป\u200dโžก๏ธ": {}, + "๐Ÿšถ๐Ÿผ": {}, + "๐Ÿšถ๐Ÿผ\u200dโ™€๏ธ": {}, + "๐Ÿšถ๐Ÿผ\u200dโ™€๏ธ\u200dโžก๏ธ": {}, + "๐Ÿšถ๐Ÿผ\u200dโ™‚๏ธ": {}, + "๐Ÿšถ๐Ÿผ\u200dโ™‚๏ธ\u200dโžก๏ธ": {}, + "๐Ÿšถ๐Ÿผ\u200dโžก๏ธ": {}, + "๐Ÿšถ๐Ÿฝ": {}, + "๐Ÿšถ๐Ÿฝ\u200dโ™€๏ธ": {}, + "๐Ÿšถ๐Ÿฝ\u200dโ™€๏ธ\u200dโžก๏ธ": {}, + "๐Ÿšถ๐Ÿฝ\u200dโ™‚๏ธ": {}, + "๐Ÿšถ๐Ÿฝ\u200dโ™‚๏ธ\u200dโžก๏ธ": {}, + "๐Ÿšถ๐Ÿฝ\u200dโžก๏ธ": {}, + "๐Ÿšถ๐Ÿพ": {}, + "๐Ÿšถ๐Ÿพ\u200dโ™€๏ธ": {}, + "๐Ÿšถ๐Ÿพ\u200dโ™€๏ธ\u200dโžก๏ธ": {}, + "๐Ÿšถ๐Ÿพ\u200dโ™‚๏ธ": {}, + "๐Ÿšถ๐Ÿพ\u200dโ™‚๏ธ\u200dโžก๏ธ": {}, + "๐Ÿšถ๐Ÿพ\u200dโžก๏ธ": {}, + "๐Ÿšถ๐Ÿฟ": {}, + "๐Ÿšถ๐Ÿฟ\u200dโ™€๏ธ": {}, + "๐Ÿšถ๐Ÿฟ\u200dโ™€๏ธ\u200dโžก๏ธ": {}, + "๐Ÿšถ๐Ÿฟ\u200dโ™‚๏ธ": {}, + "๐Ÿšถ๐Ÿฟ\u200dโ™‚๏ธ\u200dโžก๏ธ": {}, + "๐Ÿšถ๐Ÿฟ\u200dโžก๏ธ": {}, + "๐Ÿšท": {}, + "๐Ÿšธ": {}, + "๐Ÿšน": {}, + "๐Ÿšบ": {}, + "๐Ÿšป": {}, + "๐Ÿšผ": {}, + "๐Ÿšฝ": {}, + "๐Ÿšพ": {}, + "๐Ÿšฟ": {}, + "๐Ÿ›€": {}, + "๐Ÿ›€๐Ÿป": {}, + "๐Ÿ›€๐Ÿผ": {}, + "๐Ÿ›€๐Ÿฝ": {}, + "๐Ÿ›€๐Ÿพ": {}, + "๐Ÿ›€๐Ÿฟ": {}, + "๐Ÿ›": {}, + "๐Ÿ›‚": {}, + "๐Ÿ›ƒ": {}, + "๐Ÿ›„": {}, + "๐Ÿ›…": {}, + "๐Ÿ›‹๏ธ": {}, + "๐Ÿ›Œ": {}, + "๐Ÿ›Œ๐Ÿป": {}, + "๐Ÿ›Œ๐Ÿผ": {}, + "๐Ÿ›Œ๐Ÿฝ": {}, + "๐Ÿ›Œ๐Ÿพ": {}, + "๐Ÿ›Œ๐Ÿฟ": {}, + "๐Ÿ›๏ธ": {}, + "๐Ÿ›Ž๏ธ": {}, + "๐Ÿ›๏ธ": {}, + "๐Ÿ›": {}, + "๐Ÿ›‘": {}, + "๐Ÿ›’": {}, + "๐Ÿ›•": {}, + "๐Ÿ›–": {}, + "๐Ÿ›—": {}, + "\U0001f6d8": {}, + "๐Ÿ›œ": {}, + "๐Ÿ›": {}, + "๐Ÿ›ž": {}, + "๐Ÿ›Ÿ": {}, + "๐Ÿ› ๏ธ": {}, + "๐Ÿ›ก๏ธ": {}, + "๐Ÿ›ข๏ธ": {}, + "๐Ÿ›ฃ๏ธ": {}, + "๐Ÿ›ค๏ธ": {}, + "๐Ÿ›ฅ๏ธ": {}, + "๐Ÿ›ฉ๏ธ": {}, + "๐Ÿ›ซ": {}, + "๐Ÿ›ฌ": {}, + "๐Ÿ›ฐ๏ธ": {}, + "๐Ÿ›ณ๏ธ": {}, + "๐Ÿ›ด": {}, + "๐Ÿ›ต": {}, + "๐Ÿ›ถ": {}, + "๐Ÿ›ท": {}, + "๐Ÿ›ธ": {}, + "๐Ÿ›น": {}, + "๐Ÿ›บ": {}, + "๐Ÿ›ป": {}, + "๐Ÿ›ผ": {}, + "๐ŸŸ ": {}, + "๐ŸŸก": {}, + "๐ŸŸข": {}, + "๐ŸŸฃ": {}, + "๐ŸŸค": {}, + "๐ŸŸฅ": {}, + "๐ŸŸฆ": {}, + "๐ŸŸง": {}, + "๐ŸŸจ": {}, + "๐ŸŸฉ": {}, + "๐ŸŸช": {}, + "๐ŸŸซ": {}, + "๐ŸŸฐ": {}, + "๐ŸคŒ": {}, + "๐ŸคŒ๐Ÿป": {}, + "๐ŸคŒ๐Ÿผ": {}, + "๐ŸคŒ๐Ÿฝ": {}, + "๐ŸคŒ๐Ÿพ": {}, + "๐ŸคŒ๐Ÿฟ": {}, + "๐Ÿค": {}, + "๐ŸคŽ": {}, + "๐Ÿค": {}, + "๐Ÿค๐Ÿป": {}, + "๐Ÿค๐Ÿผ": {}, + "๐Ÿค๐Ÿฝ": {}, + "๐Ÿค๐Ÿพ": {}, + "๐Ÿค๐Ÿฟ": {}, + "๐Ÿค": {}, + "๐Ÿค‘": {}, + "๐Ÿค’": {}, + "๐Ÿค“": {}, + "๐Ÿค”": {}, + "๐Ÿค•": {}, + "๐Ÿค–": {}, + "๐Ÿค—": {}, + "๐Ÿค˜": {}, + "๐Ÿค˜๐Ÿป": {}, + "๐Ÿค˜๐Ÿผ": {}, + "๐Ÿค˜๐Ÿฝ": {}, + "๐Ÿค˜๐Ÿพ": {}, + "๐Ÿค˜๐Ÿฟ": {}, + "๐Ÿค™": {}, + "๐Ÿค™๐Ÿป": {}, + "๐Ÿค™๐Ÿผ": {}, + "๐Ÿค™๐Ÿฝ": {}, + "๐Ÿค™๐Ÿพ": {}, + "๐Ÿค™๐Ÿฟ": {}, + "๐Ÿคš": {}, + "๐Ÿคš๐Ÿป": {}, + "๐Ÿคš๐Ÿผ": {}, + "๐Ÿคš๐Ÿฝ": {}, + "๐Ÿคš๐Ÿพ": {}, + "๐Ÿคš๐Ÿฟ": {}, + "๐Ÿค›": {}, + "๐Ÿค›๐Ÿป": {}, + "๐Ÿค›๐Ÿผ": {}, + "๐Ÿค›๐Ÿฝ": {}, + "๐Ÿค›๐Ÿพ": {}, + "๐Ÿค›๐Ÿฟ": {}, + "๐Ÿคœ": {}, + "๐Ÿคœ๐Ÿป": {}, + "๐Ÿคœ๐Ÿผ": {}, + "๐Ÿคœ๐Ÿฝ": {}, + "๐Ÿคœ๐Ÿพ": {}, + "๐Ÿคœ๐Ÿฟ": {}, + "๐Ÿค": {}, + "๐Ÿค๐Ÿป": {}, + "๐Ÿค๐Ÿผ": {}, + "๐Ÿค๐Ÿฝ": {}, + "๐Ÿค๐Ÿพ": {}, + "๐Ÿค๐Ÿฟ": {}, + "๐Ÿคž": {}, + "๐Ÿคž๐Ÿป": {}, + "๐Ÿคž๐Ÿผ": {}, + "๐Ÿคž๐Ÿฝ": {}, + "๐Ÿคž๐Ÿพ": {}, + "๐Ÿคž๐Ÿฟ": {}, + "๐ŸคŸ": {}, + "๐ŸคŸ๐Ÿป": {}, + "๐ŸคŸ๐Ÿผ": {}, + "๐ŸคŸ๐Ÿฝ": {}, + "๐ŸคŸ๐Ÿพ": {}, + "๐ŸคŸ๐Ÿฟ": {}, + "๐Ÿค ": {}, + "๐Ÿคก": {}, + "๐Ÿคข": {}, + "๐Ÿคฃ": {}, + "๐Ÿคค": {}, + "๐Ÿคฅ": {}, + "๐Ÿคฆ": {}, + "๐Ÿคฆ\u200dโ™€๏ธ": {}, + "๐Ÿคฆ\u200dโ™‚๏ธ": {}, + "๐Ÿคฆ๐Ÿป": {}, + "๐Ÿคฆ๐Ÿป\u200dโ™€๏ธ": {}, + "๐Ÿคฆ๐Ÿป\u200dโ™‚๏ธ": {}, + "๐Ÿคฆ๐Ÿผ": {}, + "๐Ÿคฆ๐Ÿผ\u200dโ™€๏ธ": {}, + "๐Ÿคฆ๐Ÿผ\u200dโ™‚๏ธ": {}, + "๐Ÿคฆ๐Ÿฝ": {}, + "๐Ÿคฆ๐Ÿฝ\u200dโ™€๏ธ": {}, + "๐Ÿคฆ๐Ÿฝ\u200dโ™‚๏ธ": {}, + "๐Ÿคฆ๐Ÿพ": {}, + "๐Ÿคฆ๐Ÿพ\u200dโ™€๏ธ": {}, + "๐Ÿคฆ๐Ÿพ\u200dโ™‚๏ธ": {}, + "๐Ÿคฆ๐Ÿฟ": {}, + "๐Ÿคฆ๐Ÿฟ\u200dโ™€๏ธ": {}, + "๐Ÿคฆ๐Ÿฟ\u200dโ™‚๏ธ": {}, + "๐Ÿคง": {}, + "๐Ÿคจ": {}, + "๐Ÿคฉ": {}, + "๐Ÿคช": {}, + "๐Ÿคซ": {}, + "๐Ÿคฌ": {}, + "๐Ÿคญ": {}, + "๐Ÿคฎ": {}, + "๐Ÿคฏ": {}, + "๐Ÿคฐ": {}, + "๐Ÿคฐ๐Ÿป": {}, + "๐Ÿคฐ๐Ÿผ": {}, + "๐Ÿคฐ๐Ÿฝ": {}, + "๐Ÿคฐ๐Ÿพ": {}, + "๐Ÿคฐ๐Ÿฟ": {}, + "๐Ÿคฑ": {}, + "๐Ÿคฑ๐Ÿป": {}, + "๐Ÿคฑ๐Ÿผ": {}, + "๐Ÿคฑ๐Ÿฝ": {}, + "๐Ÿคฑ๐Ÿพ": {}, + "๐Ÿคฑ๐Ÿฟ": {}, + "๐Ÿคฒ": {}, + "๐Ÿคฒ๐Ÿป": {}, + "๐Ÿคฒ๐Ÿผ": {}, + "๐Ÿคฒ๐Ÿฝ": {}, + "๐Ÿคฒ๐Ÿพ": {}, + "๐Ÿคฒ๐Ÿฟ": {}, + "๐Ÿคณ": {}, + "๐Ÿคณ๐Ÿป": {}, + "๐Ÿคณ๐Ÿผ": {}, + "๐Ÿคณ๐Ÿฝ": {}, + "๐Ÿคณ๐Ÿพ": {}, + "๐Ÿคณ๐Ÿฟ": {}, + "๐Ÿคด": {}, + "๐Ÿคด๐Ÿป": {}, + "๐Ÿคด๐Ÿผ": {}, + "๐Ÿคด๐Ÿฝ": {}, + "๐Ÿคด๐Ÿพ": {}, + "๐Ÿคด๐Ÿฟ": {}, + "๐Ÿคต": {}, + "๐Ÿคต\u200dโ™€๏ธ": {}, + "๐Ÿคต\u200dโ™‚๏ธ": {}, + "๐Ÿคต๐Ÿป": {}, + "๐Ÿคต๐Ÿป\u200dโ™€๏ธ": {}, + "๐Ÿคต๐Ÿป\u200dโ™‚๏ธ": {}, + "๐Ÿคต๐Ÿผ": {}, + "๐Ÿคต๐Ÿผ\u200dโ™€๏ธ": {}, + "๐Ÿคต๐Ÿผ\u200dโ™‚๏ธ": {}, + "๐Ÿคต๐Ÿฝ": {}, + "๐Ÿคต๐Ÿฝ\u200dโ™€๏ธ": {}, + "๐Ÿคต๐Ÿฝ\u200dโ™‚๏ธ": {}, + "๐Ÿคต๐Ÿพ": {}, + "๐Ÿคต๐Ÿพ\u200dโ™€๏ธ": {}, + "๐Ÿคต๐Ÿพ\u200dโ™‚๏ธ": {}, + "๐Ÿคต๐Ÿฟ": {}, + "๐Ÿคต๐Ÿฟ\u200dโ™€๏ธ": {}, + "๐Ÿคต๐Ÿฟ\u200dโ™‚๏ธ": {}, + "๐Ÿคถ": {}, + "๐Ÿคถ๐Ÿป": {}, + "๐Ÿคถ๐Ÿผ": {}, + "๐Ÿคถ๐Ÿฝ": {}, + "๐Ÿคถ๐Ÿพ": {}, + "๐Ÿคถ๐Ÿฟ": {}, + "๐Ÿคท": {}, + "๐Ÿคท\u200dโ™€๏ธ": {}, + "๐Ÿคท\u200dโ™‚๏ธ": {}, + "๐Ÿคท๐Ÿป": {}, + "๐Ÿคท๐Ÿป\u200dโ™€๏ธ": {}, + "๐Ÿคท๐Ÿป\u200dโ™‚๏ธ": {}, + "๐Ÿคท๐Ÿผ": {}, + "๐Ÿคท๐Ÿผ\u200dโ™€๏ธ": {}, + "๐Ÿคท๐Ÿผ\u200dโ™‚๏ธ": {}, + "๐Ÿคท๐Ÿฝ": {}, + "๐Ÿคท๐Ÿฝ\u200dโ™€๏ธ": {}, + "๐Ÿคท๐Ÿฝ\u200dโ™‚๏ธ": {}, + "๐Ÿคท๐Ÿพ": {}, + "๐Ÿคท๐Ÿพ\u200dโ™€๏ธ": {}, + "๐Ÿคท๐Ÿพ\u200dโ™‚๏ธ": {}, + "๐Ÿคท๐Ÿฟ": {}, + "๐Ÿคท๐Ÿฟ\u200dโ™€๏ธ": {}, + "๐Ÿคท๐Ÿฟ\u200dโ™‚๏ธ": {}, + "๐Ÿคธ": {}, + "๐Ÿคธ\u200dโ™€๏ธ": {}, + "๐Ÿคธ\u200dโ™‚๏ธ": {}, + "๐Ÿคธ๐Ÿป": {}, + "๐Ÿคธ๐Ÿป\u200dโ™€๏ธ": {}, + "๐Ÿคธ๐Ÿป\u200dโ™‚๏ธ": {}, + "๐Ÿคธ๐Ÿผ": {}, + "๐Ÿคธ๐Ÿผ\u200dโ™€๏ธ": {}, + "๐Ÿคธ๐Ÿผ\u200dโ™‚๏ธ": {}, + "๐Ÿคธ๐Ÿฝ": {}, + "๐Ÿคธ๐Ÿฝ\u200dโ™€๏ธ": {}, + "๐Ÿคธ๐Ÿฝ\u200dโ™‚๏ธ": {}, + "๐Ÿคธ๐Ÿพ": {}, + "๐Ÿคธ๐Ÿพ\u200dโ™€๏ธ": {}, + "๐Ÿคธ๐Ÿพ\u200dโ™‚๏ธ": {}, + "๐Ÿคธ๐Ÿฟ": {}, + "๐Ÿคธ๐Ÿฟ\u200dโ™€๏ธ": {}, + "๐Ÿคธ๐Ÿฟ\u200dโ™‚๏ธ": {}, + "๐Ÿคน": {}, + "๐Ÿคน\u200dโ™€๏ธ": {}, + "๐Ÿคน\u200dโ™‚๏ธ": {}, + "๐Ÿคน๐Ÿป": {}, + "๐Ÿคน๐Ÿป\u200dโ™€๏ธ": {}, + "๐Ÿคน๐Ÿป\u200dโ™‚๏ธ": {}, + "๐Ÿคน๐Ÿผ": {}, + "๐Ÿคน๐Ÿผ\u200dโ™€๏ธ": {}, + "๐Ÿคน๐Ÿผ\u200dโ™‚๏ธ": {}, + "๐Ÿคน๐Ÿฝ": {}, + "๐Ÿคน๐Ÿฝ\u200dโ™€๏ธ": {}, + "๐Ÿคน๐Ÿฝ\u200dโ™‚๏ธ": {}, + "๐Ÿคน๐Ÿพ": {}, + "๐Ÿคน๐Ÿพ\u200dโ™€๏ธ": {}, + "๐Ÿคน๐Ÿพ\u200dโ™‚๏ธ": {}, + "๐Ÿคน๐Ÿฟ": {}, + "๐Ÿคน๐Ÿฟ\u200dโ™€๏ธ": {}, + "๐Ÿคน๐Ÿฟ\u200dโ™‚๏ธ": {}, + "๐Ÿคบ": {}, + "๐Ÿคผ": {}, + "๐Ÿคผ\u200dโ™€๏ธ": {}, + "๐Ÿคผ\u200dโ™‚๏ธ": {}, + "๐Ÿคผ๐Ÿป": {}, + "๐Ÿคผ๐Ÿป\u200dโ™€๏ธ": {}, + "๐Ÿคผ๐Ÿป\u200dโ™‚๏ธ": {}, + "๐Ÿคผ๐Ÿผ": {}, + "๐Ÿคผ๐Ÿผ\u200dโ™€๏ธ": {}, + "๐Ÿคผ๐Ÿผ\u200dโ™‚๏ธ": {}, + "๐Ÿคผ๐Ÿฝ": {}, + "๐Ÿคผ๐Ÿฝ\u200dโ™€๏ธ": {}, + "๐Ÿคผ๐Ÿฝ\u200dโ™‚๏ธ": {}, + "๐Ÿคผ๐Ÿพ": {}, + "๐Ÿคผ๐Ÿพ\u200dโ™€๏ธ": {}, + "๐Ÿคผ๐Ÿพ\u200dโ™‚๏ธ": {}, + "๐Ÿคผ๐Ÿฟ": {}, + "๐Ÿคผ๐Ÿฟ\u200dโ™€๏ธ": {}, + "๐Ÿคผ๐Ÿฟ\u200dโ™‚๏ธ": {}, + "๐Ÿคฝ": {}, + "๐Ÿคฝ\u200dโ™€๏ธ": {}, + "๐Ÿคฝ\u200dโ™‚๏ธ": {}, + "๐Ÿคฝ๐Ÿป": {}, + "๐Ÿคฝ๐Ÿป\u200dโ™€๏ธ": {}, + "๐Ÿคฝ๐Ÿป\u200dโ™‚๏ธ": {}, + "๐Ÿคฝ๐Ÿผ": {}, + "๐Ÿคฝ๐Ÿผ\u200dโ™€๏ธ": {}, + "๐Ÿคฝ๐Ÿผ\u200dโ™‚๏ธ": {}, + "๐Ÿคฝ๐Ÿฝ": {}, + "๐Ÿคฝ๐Ÿฝ\u200dโ™€๏ธ": {}, + "๐Ÿคฝ๐Ÿฝ\u200dโ™‚๏ธ": {}, + "๐Ÿคฝ๐Ÿพ": {}, + "๐Ÿคฝ๐Ÿพ\u200dโ™€๏ธ": {}, + "๐Ÿคฝ๐Ÿพ\u200dโ™‚๏ธ": {}, + "๐Ÿคฝ๐Ÿฟ": {}, + "๐Ÿคฝ๐Ÿฟ\u200dโ™€๏ธ": {}, + "๐Ÿคฝ๐Ÿฟ\u200dโ™‚๏ธ": {}, + "๐Ÿคพ": {}, + "๐Ÿคพ\u200dโ™€๏ธ": {}, + "๐Ÿคพ\u200dโ™‚๏ธ": {}, + "๐Ÿคพ๐Ÿป": {}, + "๐Ÿคพ๐Ÿป\u200dโ™€๏ธ": {}, + "๐Ÿคพ๐Ÿป\u200dโ™‚๏ธ": {}, + "๐Ÿคพ๐Ÿผ": {}, + "๐Ÿคพ๐Ÿผ\u200dโ™€๏ธ": {}, + "๐Ÿคพ๐Ÿผ\u200dโ™‚๏ธ": {}, + "๐Ÿคพ๐Ÿฝ": {}, + "๐Ÿคพ๐Ÿฝ\u200dโ™€๏ธ": {}, + "๐Ÿคพ๐Ÿฝ\u200dโ™‚๏ธ": {}, + "๐Ÿคพ๐Ÿพ": {}, + "๐Ÿคพ๐Ÿพ\u200dโ™€๏ธ": {}, + "๐Ÿคพ๐Ÿพ\u200dโ™‚๏ธ": {}, + "๐Ÿคพ๐Ÿฟ": {}, + "๐Ÿคพ๐Ÿฟ\u200dโ™€๏ธ": {}, + "๐Ÿคพ๐Ÿฟ\u200dโ™‚๏ธ": {}, + "๐Ÿคฟ": {}, + "๐Ÿฅ€": {}, + "๐Ÿฅ": {}, + "๐Ÿฅ‚": {}, + "๐Ÿฅƒ": {}, + "๐Ÿฅ„": {}, + "๐Ÿฅ…": {}, + "๐Ÿฅ‡": {}, + "๐Ÿฅˆ": {}, + "๐Ÿฅ‰": {}, + "๐ŸฅŠ": {}, + "๐Ÿฅ‹": {}, + "๐ŸฅŒ": {}, + "๐Ÿฅ": {}, + "๐ŸฅŽ": {}, + "๐Ÿฅ": {}, + "๐Ÿฅ": {}, + "๐Ÿฅ‘": {}, + "๐Ÿฅ’": {}, + "๐Ÿฅ“": {}, + "๐Ÿฅ”": {}, + "๐Ÿฅ•": {}, + "๐Ÿฅ–": {}, + "๐Ÿฅ—": {}, + "๐Ÿฅ˜": {}, + "๐Ÿฅ™": {}, + "๐Ÿฅš": {}, + "๐Ÿฅ›": {}, + "๐Ÿฅœ": {}, + "๐Ÿฅ": {}, + "๐Ÿฅž": {}, + "๐ŸฅŸ": {}, + "๐Ÿฅ ": {}, + "๐Ÿฅก": {}, + "๐Ÿฅข": {}, + "๐Ÿฅฃ": {}, + "๐Ÿฅค": {}, + "๐Ÿฅฅ": {}, + "๐Ÿฅฆ": {}, + "๐Ÿฅง": {}, + "๐Ÿฅจ": {}, + "๐Ÿฅฉ": {}, + "๐Ÿฅช": {}, + "๐Ÿฅซ": {}, + "๐Ÿฅฌ": {}, + "๐Ÿฅญ": {}, + "๐Ÿฅฎ": {}, + "๐Ÿฅฏ": {}, + "๐Ÿฅฐ": {}, + "๐Ÿฅฑ": {}, + "๐Ÿฅฒ": {}, + "๐Ÿฅณ": {}, + "๐Ÿฅด": {}, + "๐Ÿฅต": {}, + "๐Ÿฅถ": {}, + "๐Ÿฅท": {}, + "๐Ÿฅท๐Ÿป": {}, + "๐Ÿฅท๐Ÿผ": {}, + "๐Ÿฅท๐Ÿฝ": {}, + "๐Ÿฅท๐Ÿพ": {}, + "๐Ÿฅท๐Ÿฟ": {}, + "๐Ÿฅธ": {}, + "๐Ÿฅน": {}, + "๐Ÿฅบ": {}, + "๐Ÿฅป": {}, + "๐Ÿฅผ": {}, + "๐Ÿฅฝ": {}, + "๐Ÿฅพ": {}, + "๐Ÿฅฟ": {}, + "๐Ÿฆ€": {}, + "๐Ÿฆ": {}, + "๐Ÿฆ‚": {}, + "๐Ÿฆƒ": {}, + "๐Ÿฆ„": {}, + "๐Ÿฆ…": {}, + "๐Ÿฆ†": {}, + "๐Ÿฆ‡": {}, + "๐Ÿฆˆ": {}, + "๐Ÿฆ‰": {}, + "๐ŸฆŠ": {}, + "๐Ÿฆ‹": {}, + "๐ŸฆŒ": {}, + "๐Ÿฆ": {}, + "๐ŸฆŽ": {}, + "๐Ÿฆ": {}, + "๐Ÿฆ": {}, + "๐Ÿฆ‘": {}, + "๐Ÿฆ’": {}, + "๐Ÿฆ“": {}, + "๐Ÿฆ”": {}, + "๐Ÿฆ•": {}, + "๐Ÿฆ–": {}, + "๐Ÿฆ—": {}, + "๐Ÿฆ˜": {}, + "๐Ÿฆ™": {}, + "๐Ÿฆš": {}, + "๐Ÿฆ›": {}, + "๐Ÿฆœ": {}, + "๐Ÿฆ": {}, + "๐Ÿฆž": {}, + "๐ŸฆŸ": {}, + "๐Ÿฆ ": {}, + "๐Ÿฆก": {}, + "๐Ÿฆข": {}, + "๐Ÿฆฃ": {}, + "๐Ÿฆค": {}, + "๐Ÿฆฅ": {}, + "๐Ÿฆฆ": {}, + "๐Ÿฆง": {}, + "๐Ÿฆจ": {}, + "๐Ÿฆฉ": {}, + "๐Ÿฆช": {}, + "๐Ÿฆซ": {}, + "๐Ÿฆฌ": {}, + "๐Ÿฆญ": {}, + "๐Ÿฆฎ": {}, + "๐Ÿฆฏ": {}, + "๐Ÿฆด": {}, + "๐Ÿฆต": {}, + "๐Ÿฆต๐Ÿป": {}, + "๐Ÿฆต๐Ÿผ": {}, + "๐Ÿฆต๐Ÿฝ": {}, + "๐Ÿฆต๐Ÿพ": {}, + "๐Ÿฆต๐Ÿฟ": {}, + "๐Ÿฆถ": {}, + "๐Ÿฆถ๐Ÿป": {}, + "๐Ÿฆถ๐Ÿผ": {}, + "๐Ÿฆถ๐Ÿฝ": {}, + "๐Ÿฆถ๐Ÿพ": {}, + "๐Ÿฆถ๐Ÿฟ": {}, + "๐Ÿฆท": {}, + "๐Ÿฆธ": {}, + "๐Ÿฆธ\u200dโ™€๏ธ": {}, + "๐Ÿฆธ\u200dโ™‚๏ธ": {}, + "๐Ÿฆธ๐Ÿป": {}, + "๐Ÿฆธ๐Ÿป\u200dโ™€๏ธ": {}, + "๐Ÿฆธ๐Ÿป\u200dโ™‚๏ธ": {}, + "๐Ÿฆธ๐Ÿผ": {}, + "๐Ÿฆธ๐Ÿผ\u200dโ™€๏ธ": {}, + "๐Ÿฆธ๐Ÿผ\u200dโ™‚๏ธ": {}, + "๐Ÿฆธ๐Ÿฝ": {}, + "๐Ÿฆธ๐Ÿฝ\u200dโ™€๏ธ": {}, + "๐Ÿฆธ๐Ÿฝ\u200dโ™‚๏ธ": {}, + "๐Ÿฆธ๐Ÿพ": {}, + "๐Ÿฆธ๐Ÿพ\u200dโ™€๏ธ": {}, + "๐Ÿฆธ๐Ÿพ\u200dโ™‚๏ธ": {}, + "๐Ÿฆธ๐Ÿฟ": {}, + "๐Ÿฆธ๐Ÿฟ\u200dโ™€๏ธ": {}, + "๐Ÿฆธ๐Ÿฟ\u200dโ™‚๏ธ": {}, + "๐Ÿฆน": {}, + "๐Ÿฆน\u200dโ™€๏ธ": {}, + "๐Ÿฆน\u200dโ™‚๏ธ": {}, + "๐Ÿฆน๐Ÿป": {}, + "๐Ÿฆน๐Ÿป\u200dโ™€๏ธ": {}, + "๐Ÿฆน๐Ÿป\u200dโ™‚๏ธ": {}, + "๐Ÿฆน๐Ÿผ": {}, + "๐Ÿฆน๐Ÿผ\u200dโ™€๏ธ": {}, + "๐Ÿฆน๐Ÿผ\u200dโ™‚๏ธ": {}, + "๐Ÿฆน๐Ÿฝ": {}, + "๐Ÿฆน๐Ÿฝ\u200dโ™€๏ธ": {}, + "๐Ÿฆน๐Ÿฝ\u200dโ™‚๏ธ": {}, + "๐Ÿฆน๐Ÿพ": {}, + "๐Ÿฆน๐Ÿพ\u200dโ™€๏ธ": {}, + "๐Ÿฆน๐Ÿพ\u200dโ™‚๏ธ": {}, + "๐Ÿฆน๐Ÿฟ": {}, + "๐Ÿฆน๐Ÿฟ\u200dโ™€๏ธ": {}, + "๐Ÿฆน๐Ÿฟ\u200dโ™‚๏ธ": {}, + "๐Ÿฆบ": {}, + "๐Ÿฆป": {}, + "๐Ÿฆป๐Ÿป": {}, + "๐Ÿฆป๐Ÿผ": {}, + "๐Ÿฆป๐Ÿฝ": {}, + "๐Ÿฆป๐Ÿพ": {}, + "๐Ÿฆป๐Ÿฟ": {}, + "๐Ÿฆผ": {}, + "๐Ÿฆฝ": {}, + "๐Ÿฆพ": {}, + "๐Ÿฆฟ": {}, + "๐Ÿง€": {}, + "๐Ÿง": {}, + "๐Ÿง‚": {}, + "๐Ÿงƒ": {}, + "๐Ÿง„": {}, + "๐Ÿง…": {}, + "๐Ÿง†": {}, + "๐Ÿง‡": {}, + "๐Ÿงˆ": {}, + "๐Ÿง‰": {}, + "๐ŸงŠ": {}, + "๐Ÿง‹": {}, + "๐ŸงŒ": {}, + "๐Ÿง": {}, + "๐Ÿง\u200dโ™€๏ธ": {}, + "๐Ÿง\u200dโ™‚๏ธ": {}, + "๐Ÿง๐Ÿป": {}, + "๐Ÿง๐Ÿป\u200dโ™€๏ธ": {}, + "๐Ÿง๐Ÿป\u200dโ™‚๏ธ": {}, + "๐Ÿง๐Ÿผ": {}, + "๐Ÿง๐Ÿผ\u200dโ™€๏ธ": {}, + "๐Ÿง๐Ÿผ\u200dโ™‚๏ธ": {}, + "๐Ÿง๐Ÿฝ": {}, + "๐Ÿง๐Ÿฝ\u200dโ™€๏ธ": {}, + "๐Ÿง๐Ÿฝ\u200dโ™‚๏ธ": {}, + "๐Ÿง๐Ÿพ": {}, + "๐Ÿง๐Ÿพ\u200dโ™€๏ธ": {}, + "๐Ÿง๐Ÿพ\u200dโ™‚๏ธ": {}, + "๐Ÿง๐Ÿฟ": {}, + "๐Ÿง๐Ÿฟ\u200dโ™€๏ธ": {}, + "๐Ÿง๐Ÿฟ\u200dโ™‚๏ธ": {}, + "๐ŸงŽ": {}, + "๐ŸงŽ\u200dโ™€๏ธ": {}, + "๐ŸงŽ\u200dโ™€๏ธ\u200dโžก๏ธ": {}, + "๐ŸงŽ\u200dโ™‚๏ธ": {}, + "๐ŸงŽ\u200dโ™‚๏ธ\u200dโžก๏ธ": {}, + "๐ŸงŽ\u200dโžก๏ธ": {}, + "๐ŸงŽ๐Ÿป": {}, + "๐ŸงŽ๐Ÿป\u200dโ™€๏ธ": {}, + "๐ŸงŽ๐Ÿป\u200dโ™€๏ธ\u200dโžก๏ธ": {}, + "๐ŸงŽ๐Ÿป\u200dโ™‚๏ธ": {}, + "๐ŸงŽ๐Ÿป\u200dโ™‚๏ธ\u200dโžก๏ธ": {}, + "๐ŸงŽ๐Ÿป\u200dโžก๏ธ": {}, + "๐ŸงŽ๐Ÿผ": {}, + "๐ŸงŽ๐Ÿผ\u200dโ™€๏ธ": {}, + "๐ŸงŽ๐Ÿผ\u200dโ™€๏ธ\u200dโžก๏ธ": {}, + "๐ŸงŽ๐Ÿผ\u200dโ™‚๏ธ": {}, + "๐ŸงŽ๐Ÿผ\u200dโ™‚๏ธ\u200dโžก๏ธ": {}, + "๐ŸงŽ๐Ÿผ\u200dโžก๏ธ": {}, + "๐ŸงŽ๐Ÿฝ": {}, + "๐ŸงŽ๐Ÿฝ\u200dโ™€๏ธ": {}, + "๐ŸงŽ๐Ÿฝ\u200dโ™€๏ธ\u200dโžก๏ธ": {}, + "๐ŸงŽ๐Ÿฝ\u200dโ™‚๏ธ": {}, + "๐ŸงŽ๐Ÿฝ\u200dโ™‚๏ธ\u200dโžก๏ธ": {}, + "๐ŸงŽ๐Ÿฝ\u200dโžก๏ธ": {}, + "๐ŸงŽ๐Ÿพ": {}, + "๐ŸงŽ๐Ÿพ\u200dโ™€๏ธ": {}, + "๐ŸงŽ๐Ÿพ\u200dโ™€๏ธ\u200dโžก๏ธ": {}, + "๐ŸงŽ๐Ÿพ\u200dโ™‚๏ธ": {}, + "๐ŸงŽ๐Ÿพ\u200dโ™‚๏ธ\u200dโžก๏ธ": {}, + "๐ŸงŽ๐Ÿพ\u200dโžก๏ธ": {}, + "๐ŸงŽ๐Ÿฟ": {}, + "๐ŸงŽ๐Ÿฟ\u200dโ™€๏ธ": {}, + "๐ŸงŽ๐Ÿฟ\u200dโ™€๏ธ\u200dโžก๏ธ": {}, + "๐ŸงŽ๐Ÿฟ\u200dโ™‚๏ธ": {}, + "๐ŸงŽ๐Ÿฟ\u200dโ™‚๏ธ\u200dโžก๏ธ": {}, + "๐ŸงŽ๐Ÿฟ\u200dโžก๏ธ": {}, + "๐Ÿง": {}, + "๐Ÿง\u200dโ™€๏ธ": {}, + "๐Ÿง\u200dโ™‚๏ธ": {}, + "๐Ÿง๐Ÿป": {}, + "๐Ÿง๐Ÿป\u200dโ™€๏ธ": {}, + "๐Ÿง๐Ÿป\u200dโ™‚๏ธ": {}, + "๐Ÿง๐Ÿผ": {}, + "๐Ÿง๐Ÿผ\u200dโ™€๏ธ": {}, + "๐Ÿง๐Ÿผ\u200dโ™‚๏ธ": {}, + "๐Ÿง๐Ÿฝ": {}, + "๐Ÿง๐Ÿฝ\u200dโ™€๏ธ": {}, + "๐Ÿง๐Ÿฝ\u200dโ™‚๏ธ": {}, + "๐Ÿง๐Ÿพ": {}, + "๐Ÿง๐Ÿพ\u200dโ™€๏ธ": {}, + "๐Ÿง๐Ÿพ\u200dโ™‚๏ธ": {}, + "๐Ÿง๐Ÿฟ": {}, + "๐Ÿง๐Ÿฟ\u200dโ™€๏ธ": {}, + "๐Ÿง๐Ÿฟ\u200dโ™‚๏ธ": {}, + "๐Ÿง": {}, + "๐Ÿง‘": {}, + "๐Ÿง‘\u200dโš•๏ธ": {}, + "๐Ÿง‘\u200dโš–๏ธ": {}, + "๐Ÿง‘\u200dโœˆ๏ธ": {}, + "๐Ÿง‘\u200d๐ŸŒพ": {}, + "๐Ÿง‘\u200d๐Ÿณ": {}, + "๐Ÿง‘\u200d๐Ÿผ": {}, + "๐Ÿง‘\u200d๐ŸŽ„": {}, + "๐Ÿง‘\u200d๐ŸŽ“": {}, + "๐Ÿง‘\u200d๐ŸŽค": {}, + "๐Ÿง‘\u200d๐ŸŽจ": {}, + "๐Ÿง‘\u200d๐Ÿซ": {}, + "๐Ÿง‘\u200d๐Ÿญ": {}, + "๐Ÿง‘\u200d๐Ÿ’ป": {}, + "๐Ÿง‘\u200d๐Ÿ’ผ": {}, + "๐Ÿง‘\u200d๐Ÿ”ง": {}, + "๐Ÿง‘\u200d๐Ÿ”ฌ": {}, + "๐Ÿง‘\u200d๐Ÿš€": {}, + "๐Ÿง‘\u200d๐Ÿš’": {}, + "๐Ÿง‘\u200d๐Ÿค\u200d๐Ÿง‘": {}, + "๐Ÿง‘\u200d๐Ÿฆฏ": {}, + "๐Ÿง‘\u200d๐Ÿฆฏ\u200dโžก๏ธ": {}, + "๐Ÿง‘\u200d๐Ÿฆฐ": {}, + "๐Ÿง‘\u200d๐Ÿฆฑ": {}, + "๐Ÿง‘\u200d๐Ÿฆฒ": {}, + "๐Ÿง‘\u200d๐Ÿฆณ": {}, + "๐Ÿง‘\u200d๐Ÿฆผ": {}, + "๐Ÿง‘\u200d๐Ÿฆผ\u200dโžก๏ธ": {}, + "๐Ÿง‘\u200d๐Ÿฆฝ": {}, + "๐Ÿง‘\u200d๐Ÿฆฝ\u200dโžก๏ธ": {}, + "๐Ÿง‘\u200d๐Ÿง‘\u200d๐Ÿง’": {}, + "๐Ÿง‘\u200d๐Ÿง‘\u200d๐Ÿง’\u200d๐Ÿง’": {}, + "๐Ÿง‘\u200d๐Ÿง’": {}, + "๐Ÿง‘\u200d๐Ÿง’\u200d๐Ÿง’": {}, + "๐Ÿง‘\u200d๐Ÿฉฐ": {}, + "๐Ÿง‘๐Ÿป": {}, + "๐Ÿง‘๐Ÿป\u200dโš•๏ธ": {}, + "๐Ÿง‘๐Ÿป\u200dโš–๏ธ": {}, + "๐Ÿง‘๐Ÿป\u200dโœˆ๏ธ": {}, + "๐Ÿง‘๐Ÿป\u200dโค๏ธ\u200d๐Ÿ’‹\u200d๐Ÿง‘๐Ÿผ": {}, + "๐Ÿง‘๐Ÿป\u200dโค๏ธ\u200d๐Ÿ’‹\u200d๐Ÿง‘๐Ÿฝ": {}, + "๐Ÿง‘๐Ÿป\u200dโค๏ธ\u200d๐Ÿ’‹\u200d๐Ÿง‘๐Ÿพ": {}, + "๐Ÿง‘๐Ÿป\u200dโค๏ธ\u200d๐Ÿ’‹\u200d๐Ÿง‘๐Ÿฟ": {}, + "๐Ÿง‘๐Ÿป\u200dโค๏ธ\u200d๐Ÿง‘๐Ÿผ": {}, + "๐Ÿง‘๐Ÿป\u200dโค๏ธ\u200d๐Ÿง‘๐Ÿฝ": {}, + "๐Ÿง‘๐Ÿป\u200dโค๏ธ\u200d๐Ÿง‘๐Ÿพ": {}, + "๐Ÿง‘๐Ÿป\u200dโค๏ธ\u200d๐Ÿง‘๐Ÿฟ": {}, + "๐Ÿง‘๐Ÿป\u200d๐ŸŒพ": {}, + "๐Ÿง‘๐Ÿป\u200d๐Ÿณ": {}, + "๐Ÿง‘๐Ÿป\u200d๐Ÿผ": {}, + "๐Ÿง‘๐Ÿป\u200d๐ŸŽ„": {}, + "๐Ÿง‘๐Ÿป\u200d๐ŸŽ“": {}, + "๐Ÿง‘๐Ÿป\u200d๐ŸŽค": {}, + "๐Ÿง‘๐Ÿป\u200d๐ŸŽจ": {}, + "๐Ÿง‘๐Ÿป\u200d๐Ÿซ": {}, + "๐Ÿง‘๐Ÿป\u200d๐Ÿญ": {}, + "๐Ÿง‘๐Ÿป\u200d๐Ÿฐ\u200d๐Ÿง‘๐Ÿผ": {}, + "๐Ÿง‘๐Ÿป\u200d๐Ÿฐ\u200d๐Ÿง‘๐Ÿฝ": {}, + "๐Ÿง‘๐Ÿป\u200d๐Ÿฐ\u200d๐Ÿง‘๐Ÿพ": {}, + "๐Ÿง‘๐Ÿป\u200d๐Ÿฐ\u200d๐Ÿง‘๐Ÿฟ": {}, + "๐Ÿง‘๐Ÿป\u200d๐Ÿ’ป": {}, + "๐Ÿง‘๐Ÿป\u200d๐Ÿ’ผ": {}, + "๐Ÿง‘๐Ÿป\u200d๐Ÿ”ง": {}, + "๐Ÿง‘๐Ÿป\u200d๐Ÿ”ฌ": {}, + "๐Ÿง‘๐Ÿป\u200d๐Ÿš€": {}, + "๐Ÿง‘๐Ÿป\u200d๐Ÿš’": {}, + "๐Ÿง‘๐Ÿป\u200d๐Ÿค\u200d๐Ÿง‘๐Ÿป": {}, + "๐Ÿง‘๐Ÿป\u200d๐Ÿค\u200d๐Ÿง‘๐Ÿผ": {}, + "๐Ÿง‘๐Ÿป\u200d๐Ÿค\u200d๐Ÿง‘๐Ÿฝ": {}, + "๐Ÿง‘๐Ÿป\u200d๐Ÿค\u200d๐Ÿง‘๐Ÿพ": {}, + "๐Ÿง‘๐Ÿป\u200d๐Ÿค\u200d๐Ÿง‘๐Ÿฟ": {}, + "๐Ÿง‘๐Ÿป\u200d๐Ÿฆฏ": {}, + "๐Ÿง‘๐Ÿป\u200d๐Ÿฆฏ\u200dโžก๏ธ": {}, + "๐Ÿง‘๐Ÿป\u200d๐Ÿฆฐ": {}, + "๐Ÿง‘๐Ÿป\u200d๐Ÿฆฑ": {}, + "๐Ÿง‘๐Ÿป\u200d๐Ÿฆฒ": {}, + "๐Ÿง‘๐Ÿป\u200d๐Ÿฆณ": {}, + "๐Ÿง‘๐Ÿป\u200d๐Ÿฆผ": {}, + "๐Ÿง‘๐Ÿป\u200d๐Ÿฆผ\u200dโžก๏ธ": {}, + "๐Ÿง‘๐Ÿป\u200d๐Ÿฆฝ": {}, + "๐Ÿง‘๐Ÿป\u200d๐Ÿฆฝ\u200dโžก๏ธ": {}, + "๐Ÿง‘๐Ÿป\u200d๐Ÿฉฐ": {}, + "๐Ÿง‘๐Ÿป\u200d\U0001faef\u200d๐Ÿง‘๐Ÿผ": {}, + "๐Ÿง‘๐Ÿป\u200d\U0001faef\u200d๐Ÿง‘๐Ÿฝ": {}, + "๐Ÿง‘๐Ÿป\u200d\U0001faef\u200d๐Ÿง‘๐Ÿพ": {}, + "๐Ÿง‘๐Ÿป\u200d\U0001faef\u200d๐Ÿง‘๐Ÿฟ": {}, + "๐Ÿง‘๐Ÿผ": {}, + "๐Ÿง‘๐Ÿผ\u200dโš•๏ธ": {}, + "๐Ÿง‘๐Ÿผ\u200dโš–๏ธ": {}, + "๐Ÿง‘๐Ÿผ\u200dโœˆ๏ธ": {}, + "๐Ÿง‘๐Ÿผ\u200dโค๏ธ\u200d๐Ÿ’‹\u200d๐Ÿง‘๐Ÿป": {}, + "๐Ÿง‘๐Ÿผ\u200dโค๏ธ\u200d๐Ÿ’‹\u200d๐Ÿง‘๐Ÿฝ": {}, + "๐Ÿง‘๐Ÿผ\u200dโค๏ธ\u200d๐Ÿ’‹\u200d๐Ÿง‘๐Ÿพ": {}, + "๐Ÿง‘๐Ÿผ\u200dโค๏ธ\u200d๐Ÿ’‹\u200d๐Ÿง‘๐Ÿฟ": {}, + "๐Ÿง‘๐Ÿผ\u200dโค๏ธ\u200d๐Ÿง‘๐Ÿป": {}, + "๐Ÿง‘๐Ÿผ\u200dโค๏ธ\u200d๐Ÿง‘๐Ÿฝ": {}, + "๐Ÿง‘๐Ÿผ\u200dโค๏ธ\u200d๐Ÿง‘๐Ÿพ": {}, + "๐Ÿง‘๐Ÿผ\u200dโค๏ธ\u200d๐Ÿง‘๐Ÿฟ": {}, + "๐Ÿง‘๐Ÿผ\u200d๐ŸŒพ": {}, + "๐Ÿง‘๐Ÿผ\u200d๐Ÿณ": {}, + "๐Ÿง‘๐Ÿผ\u200d๐Ÿผ": {}, + "๐Ÿง‘๐Ÿผ\u200d๐ŸŽ„": {}, + "๐Ÿง‘๐Ÿผ\u200d๐ŸŽ“": {}, + "๐Ÿง‘๐Ÿผ\u200d๐ŸŽค": {}, + "๐Ÿง‘๐Ÿผ\u200d๐ŸŽจ": {}, + "๐Ÿง‘๐Ÿผ\u200d๐Ÿซ": {}, + "๐Ÿง‘๐Ÿผ\u200d๐Ÿญ": {}, + "๐Ÿง‘๐Ÿผ\u200d๐Ÿฐ\u200d๐Ÿง‘๐Ÿป": {}, + "๐Ÿง‘๐Ÿผ\u200d๐Ÿฐ\u200d๐Ÿง‘๐Ÿฝ": {}, + "๐Ÿง‘๐Ÿผ\u200d๐Ÿฐ\u200d๐Ÿง‘๐Ÿพ": {}, + "๐Ÿง‘๐Ÿผ\u200d๐Ÿฐ\u200d๐Ÿง‘๐Ÿฟ": {}, + "๐Ÿง‘๐Ÿผ\u200d๐Ÿ’ป": {}, + "๐Ÿง‘๐Ÿผ\u200d๐Ÿ’ผ": {}, + "๐Ÿง‘๐Ÿผ\u200d๐Ÿ”ง": {}, + "๐Ÿง‘๐Ÿผ\u200d๐Ÿ”ฌ": {}, + "๐Ÿง‘๐Ÿผ\u200d๐Ÿš€": {}, + "๐Ÿง‘๐Ÿผ\u200d๐Ÿš’": {}, + "๐Ÿง‘๐Ÿผ\u200d๐Ÿค\u200d๐Ÿง‘๐Ÿป": {}, + "๐Ÿง‘๐Ÿผ\u200d๐Ÿค\u200d๐Ÿง‘๐Ÿผ": {}, + "๐Ÿง‘๐Ÿผ\u200d๐Ÿค\u200d๐Ÿง‘๐Ÿฝ": {}, + "๐Ÿง‘๐Ÿผ\u200d๐Ÿค\u200d๐Ÿง‘๐Ÿพ": {}, + "๐Ÿง‘๐Ÿผ\u200d๐Ÿค\u200d๐Ÿง‘๐Ÿฟ": {}, + "๐Ÿง‘๐Ÿผ\u200d๐Ÿฆฏ": {}, + "๐Ÿง‘๐Ÿผ\u200d๐Ÿฆฏ\u200dโžก๏ธ": {}, + "๐Ÿง‘๐Ÿผ\u200d๐Ÿฆฐ": {}, + "๐Ÿง‘๐Ÿผ\u200d๐Ÿฆฑ": {}, + "๐Ÿง‘๐Ÿผ\u200d๐Ÿฆฒ": {}, + "๐Ÿง‘๐Ÿผ\u200d๐Ÿฆณ": {}, + "๐Ÿง‘๐Ÿผ\u200d๐Ÿฆผ": {}, + "๐Ÿง‘๐Ÿผ\u200d๐Ÿฆผ\u200dโžก๏ธ": {}, + "๐Ÿง‘๐Ÿผ\u200d๐Ÿฆฝ": {}, + "๐Ÿง‘๐Ÿผ\u200d๐Ÿฆฝ\u200dโžก๏ธ": {}, + "๐Ÿง‘๐Ÿผ\u200d๐Ÿฉฐ": {}, + "๐Ÿง‘๐Ÿผ\u200d\U0001faef\u200d๐Ÿง‘๐Ÿป": {}, + "๐Ÿง‘๐Ÿผ\u200d\U0001faef\u200d๐Ÿง‘๐Ÿฝ": {}, + "๐Ÿง‘๐Ÿผ\u200d\U0001faef\u200d๐Ÿง‘๐Ÿพ": {}, + "๐Ÿง‘๐Ÿผ\u200d\U0001faef\u200d๐Ÿง‘๐Ÿฟ": {}, + "๐Ÿง‘๐Ÿฝ": {}, + "๐Ÿง‘๐Ÿฝ\u200dโš•๏ธ": {}, + "๐Ÿง‘๐Ÿฝ\u200dโš–๏ธ": {}, + "๐Ÿง‘๐Ÿฝ\u200dโœˆ๏ธ": {}, + "๐Ÿง‘๐Ÿฝ\u200dโค๏ธ\u200d๐Ÿ’‹\u200d๐Ÿง‘๐Ÿป": {}, + "๐Ÿง‘๐Ÿฝ\u200dโค๏ธ\u200d๐Ÿ’‹\u200d๐Ÿง‘๐Ÿผ": {}, + "๐Ÿง‘๐Ÿฝ\u200dโค๏ธ\u200d๐Ÿ’‹\u200d๐Ÿง‘๐Ÿพ": {}, + "๐Ÿง‘๐Ÿฝ\u200dโค๏ธ\u200d๐Ÿ’‹\u200d๐Ÿง‘๐Ÿฟ": {}, + "๐Ÿง‘๐Ÿฝ\u200dโค๏ธ\u200d๐Ÿง‘๐Ÿป": {}, + "๐Ÿง‘๐Ÿฝ\u200dโค๏ธ\u200d๐Ÿง‘๐Ÿผ": {}, + "๐Ÿง‘๐Ÿฝ\u200dโค๏ธ\u200d๐Ÿง‘๐Ÿพ": {}, + "๐Ÿง‘๐Ÿฝ\u200dโค๏ธ\u200d๐Ÿง‘๐Ÿฟ": {}, + "๐Ÿง‘๐Ÿฝ\u200d๐ŸŒพ": {}, + "๐Ÿง‘๐Ÿฝ\u200d๐Ÿณ": {}, + "๐Ÿง‘๐Ÿฝ\u200d๐Ÿผ": {}, + "๐Ÿง‘๐Ÿฝ\u200d๐ŸŽ„": {}, + "๐Ÿง‘๐Ÿฝ\u200d๐ŸŽ“": {}, + "๐Ÿง‘๐Ÿฝ\u200d๐ŸŽค": {}, + "๐Ÿง‘๐Ÿฝ\u200d๐ŸŽจ": {}, + "๐Ÿง‘๐Ÿฝ\u200d๐Ÿซ": {}, + "๐Ÿง‘๐Ÿฝ\u200d๐Ÿญ": {}, + "๐Ÿง‘๐Ÿฝ\u200d๐Ÿฐ\u200d๐Ÿง‘๐Ÿป": {}, + "๐Ÿง‘๐Ÿฝ\u200d๐Ÿฐ\u200d๐Ÿง‘๐Ÿผ": {}, + "๐Ÿง‘๐Ÿฝ\u200d๐Ÿฐ\u200d๐Ÿง‘๐Ÿพ": {}, + "๐Ÿง‘๐Ÿฝ\u200d๐Ÿฐ\u200d๐Ÿง‘๐Ÿฟ": {}, + "๐Ÿง‘๐Ÿฝ\u200d๐Ÿ’ป": {}, + "๐Ÿง‘๐Ÿฝ\u200d๐Ÿ’ผ": {}, + "๐Ÿง‘๐Ÿฝ\u200d๐Ÿ”ง": {}, + "๐Ÿง‘๐Ÿฝ\u200d๐Ÿ”ฌ": {}, + "๐Ÿง‘๐Ÿฝ\u200d๐Ÿš€": {}, + "๐Ÿง‘๐Ÿฝ\u200d๐Ÿš’": {}, + "๐Ÿง‘๐Ÿฝ\u200d๐Ÿค\u200d๐Ÿง‘๐Ÿป": {}, + "๐Ÿง‘๐Ÿฝ\u200d๐Ÿค\u200d๐Ÿง‘๐Ÿผ": {}, + "๐Ÿง‘๐Ÿฝ\u200d๐Ÿค\u200d๐Ÿง‘๐Ÿฝ": {}, + "๐Ÿง‘๐Ÿฝ\u200d๐Ÿค\u200d๐Ÿง‘๐Ÿพ": {}, + "๐Ÿง‘๐Ÿฝ\u200d๐Ÿค\u200d๐Ÿง‘๐Ÿฟ": {}, + "๐Ÿง‘๐Ÿฝ\u200d๐Ÿฆฏ": {}, + "๐Ÿง‘๐Ÿฝ\u200d๐Ÿฆฏ\u200dโžก๏ธ": {}, + "๐Ÿง‘๐Ÿฝ\u200d๐Ÿฆฐ": {}, + "๐Ÿง‘๐Ÿฝ\u200d๐Ÿฆฑ": {}, + "๐Ÿง‘๐Ÿฝ\u200d๐Ÿฆฒ": {}, + "๐Ÿง‘๐Ÿฝ\u200d๐Ÿฆณ": {}, + "๐Ÿง‘๐Ÿฝ\u200d๐Ÿฆผ": {}, + "๐Ÿง‘๐Ÿฝ\u200d๐Ÿฆผ\u200dโžก๏ธ": {}, + "๐Ÿง‘๐Ÿฝ\u200d๐Ÿฆฝ": {}, + "๐Ÿง‘๐Ÿฝ\u200d๐Ÿฆฝ\u200dโžก๏ธ": {}, + "๐Ÿง‘๐Ÿฝ\u200d๐Ÿฉฐ": {}, + "๐Ÿง‘๐Ÿฝ\u200d\U0001faef\u200d๐Ÿง‘๐Ÿป": {}, + "๐Ÿง‘๐Ÿฝ\u200d\U0001faef\u200d๐Ÿง‘๐Ÿผ": {}, + "๐Ÿง‘๐Ÿฝ\u200d\U0001faef\u200d๐Ÿง‘๐Ÿพ": {}, + "๐Ÿง‘๐Ÿฝ\u200d\U0001faef\u200d๐Ÿง‘๐Ÿฟ": {}, + "๐Ÿง‘๐Ÿพ": {}, + "๐Ÿง‘๐Ÿพ\u200dโš•๏ธ": {}, + "๐Ÿง‘๐Ÿพ\u200dโš–๏ธ": {}, + "๐Ÿง‘๐Ÿพ\u200dโœˆ๏ธ": {}, + "๐Ÿง‘๐Ÿพ\u200dโค๏ธ\u200d๐Ÿ’‹\u200d๐Ÿง‘๐Ÿป": {}, + "๐Ÿง‘๐Ÿพ\u200dโค๏ธ\u200d๐Ÿ’‹\u200d๐Ÿง‘๐Ÿผ": {}, + "๐Ÿง‘๐Ÿพ\u200dโค๏ธ\u200d๐Ÿ’‹\u200d๐Ÿง‘๐Ÿฝ": {}, + "๐Ÿง‘๐Ÿพ\u200dโค๏ธ\u200d๐Ÿ’‹\u200d๐Ÿง‘๐Ÿฟ": {}, + "๐Ÿง‘๐Ÿพ\u200dโค๏ธ\u200d๐Ÿง‘๐Ÿป": {}, + "๐Ÿง‘๐Ÿพ\u200dโค๏ธ\u200d๐Ÿง‘๐Ÿผ": {}, + "๐Ÿง‘๐Ÿพ\u200dโค๏ธ\u200d๐Ÿง‘๐Ÿฝ": {}, + "๐Ÿง‘๐Ÿพ\u200dโค๏ธ\u200d๐Ÿง‘๐Ÿฟ": {}, + "๐Ÿง‘๐Ÿพ\u200d๐ŸŒพ": {}, + "๐Ÿง‘๐Ÿพ\u200d๐Ÿณ": {}, + "๐Ÿง‘๐Ÿพ\u200d๐Ÿผ": {}, + "๐Ÿง‘๐Ÿพ\u200d๐ŸŽ„": {}, + "๐Ÿง‘๐Ÿพ\u200d๐ŸŽ“": {}, + "๐Ÿง‘๐Ÿพ\u200d๐ŸŽค": {}, + "๐Ÿง‘๐Ÿพ\u200d๐ŸŽจ": {}, + "๐Ÿง‘๐Ÿพ\u200d๐Ÿซ": {}, + "๐Ÿง‘๐Ÿพ\u200d๐Ÿญ": {}, + "๐Ÿง‘๐Ÿพ\u200d๐Ÿฐ\u200d๐Ÿง‘๐Ÿป": {}, + "๐Ÿง‘๐Ÿพ\u200d๐Ÿฐ\u200d๐Ÿง‘๐Ÿผ": {}, + "๐Ÿง‘๐Ÿพ\u200d๐Ÿฐ\u200d๐Ÿง‘๐Ÿฝ": {}, + "๐Ÿง‘๐Ÿพ\u200d๐Ÿฐ\u200d๐Ÿง‘๐Ÿฟ": {}, + "๐Ÿง‘๐Ÿพ\u200d๐Ÿ’ป": {}, + "๐Ÿง‘๐Ÿพ\u200d๐Ÿ’ผ": {}, + "๐Ÿง‘๐Ÿพ\u200d๐Ÿ”ง": {}, + "๐Ÿง‘๐Ÿพ\u200d๐Ÿ”ฌ": {}, + "๐Ÿง‘๐Ÿพ\u200d๐Ÿš€": {}, + "๐Ÿง‘๐Ÿพ\u200d๐Ÿš’": {}, + "๐Ÿง‘๐Ÿพ\u200d๐Ÿค\u200d๐Ÿง‘๐Ÿป": {}, + "๐Ÿง‘๐Ÿพ\u200d๐Ÿค\u200d๐Ÿง‘๐Ÿผ": {}, + "๐Ÿง‘๐Ÿพ\u200d๐Ÿค\u200d๐Ÿง‘๐Ÿฝ": {}, + "๐Ÿง‘๐Ÿพ\u200d๐Ÿค\u200d๐Ÿง‘๐Ÿพ": {}, + "๐Ÿง‘๐Ÿพ\u200d๐Ÿค\u200d๐Ÿง‘๐Ÿฟ": {}, + "๐Ÿง‘๐Ÿพ\u200d๐Ÿฆฏ": {}, + "๐Ÿง‘๐Ÿพ\u200d๐Ÿฆฏ\u200dโžก๏ธ": {}, + "๐Ÿง‘๐Ÿพ\u200d๐Ÿฆฐ": {}, + "๐Ÿง‘๐Ÿพ\u200d๐Ÿฆฑ": {}, + "๐Ÿง‘๐Ÿพ\u200d๐Ÿฆฒ": {}, + "๐Ÿง‘๐Ÿพ\u200d๐Ÿฆณ": {}, + "๐Ÿง‘๐Ÿพ\u200d๐Ÿฆผ": {}, + "๐Ÿง‘๐Ÿพ\u200d๐Ÿฆผ\u200dโžก๏ธ": {}, + "๐Ÿง‘๐Ÿพ\u200d๐Ÿฆฝ": {}, + "๐Ÿง‘๐Ÿพ\u200d๐Ÿฆฝ\u200dโžก๏ธ": {}, + "๐Ÿง‘๐Ÿพ\u200d๐Ÿฉฐ": {}, + "๐Ÿง‘๐Ÿพ\u200d\U0001faef\u200d๐Ÿง‘๐Ÿป": {}, + "๐Ÿง‘๐Ÿพ\u200d\U0001faef\u200d๐Ÿง‘๐Ÿผ": {}, + "๐Ÿง‘๐Ÿพ\u200d\U0001faef\u200d๐Ÿง‘๐Ÿฝ": {}, + "๐Ÿง‘๐Ÿพ\u200d\U0001faef\u200d๐Ÿง‘๐Ÿฟ": {}, + "๐Ÿง‘๐Ÿฟ": {}, + "๐Ÿง‘๐Ÿฟ\u200dโš•๏ธ": {}, + "๐Ÿง‘๐Ÿฟ\u200dโš–๏ธ": {}, + "๐Ÿง‘๐Ÿฟ\u200dโœˆ๏ธ": {}, + "๐Ÿง‘๐Ÿฟ\u200dโค๏ธ\u200d๐Ÿ’‹\u200d๐Ÿง‘๐Ÿป": {}, + "๐Ÿง‘๐Ÿฟ\u200dโค๏ธ\u200d๐Ÿ’‹\u200d๐Ÿง‘๐Ÿผ": {}, + "๐Ÿง‘๐Ÿฟ\u200dโค๏ธ\u200d๐Ÿ’‹\u200d๐Ÿง‘๐Ÿฝ": {}, + "๐Ÿง‘๐Ÿฟ\u200dโค๏ธ\u200d๐Ÿ’‹\u200d๐Ÿง‘๐Ÿพ": {}, + "๐Ÿง‘๐Ÿฟ\u200dโค๏ธ\u200d๐Ÿง‘๐Ÿป": {}, + "๐Ÿง‘๐Ÿฟ\u200dโค๏ธ\u200d๐Ÿง‘๐Ÿผ": {}, + "๐Ÿง‘๐Ÿฟ\u200dโค๏ธ\u200d๐Ÿง‘๐Ÿฝ": {}, + "๐Ÿง‘๐Ÿฟ\u200dโค๏ธ\u200d๐Ÿง‘๐Ÿพ": {}, + "๐Ÿง‘๐Ÿฟ\u200d๐ŸŒพ": {}, + "๐Ÿง‘๐Ÿฟ\u200d๐Ÿณ": {}, + "๐Ÿง‘๐Ÿฟ\u200d๐Ÿผ": {}, + "๐Ÿง‘๐Ÿฟ\u200d๐ŸŽ„": {}, + "๐Ÿง‘๐Ÿฟ\u200d๐ŸŽ“": {}, + "๐Ÿง‘๐Ÿฟ\u200d๐ŸŽค": {}, + "๐Ÿง‘๐Ÿฟ\u200d๐ŸŽจ": {}, + "๐Ÿง‘๐Ÿฟ\u200d๐Ÿซ": {}, + "๐Ÿง‘๐Ÿฟ\u200d๐Ÿญ": {}, + "๐Ÿง‘๐Ÿฟ\u200d๐Ÿฐ\u200d๐Ÿง‘๐Ÿป": {}, + "๐Ÿง‘๐Ÿฟ\u200d๐Ÿฐ\u200d๐Ÿง‘๐Ÿผ": {}, + "๐Ÿง‘๐Ÿฟ\u200d๐Ÿฐ\u200d๐Ÿง‘๐Ÿฝ": {}, + "๐Ÿง‘๐Ÿฟ\u200d๐Ÿฐ\u200d๐Ÿง‘๐Ÿพ": {}, + "๐Ÿง‘๐Ÿฟ\u200d๐Ÿ’ป": {}, + "๐Ÿง‘๐Ÿฟ\u200d๐Ÿ’ผ": {}, + "๐Ÿง‘๐Ÿฟ\u200d๐Ÿ”ง": {}, + "๐Ÿง‘๐Ÿฟ\u200d๐Ÿ”ฌ": {}, + "๐Ÿง‘๐Ÿฟ\u200d๐Ÿš€": {}, + "๐Ÿง‘๐Ÿฟ\u200d๐Ÿš’": {}, + "๐Ÿง‘๐Ÿฟ\u200d๐Ÿค\u200d๐Ÿง‘๐Ÿป": {}, + "๐Ÿง‘๐Ÿฟ\u200d๐Ÿค\u200d๐Ÿง‘๐Ÿผ": {}, + "๐Ÿง‘๐Ÿฟ\u200d๐Ÿค\u200d๐Ÿง‘๐Ÿฝ": {}, + "๐Ÿง‘๐Ÿฟ\u200d๐Ÿค\u200d๐Ÿง‘๐Ÿพ": {}, + "๐Ÿง‘๐Ÿฟ\u200d๐Ÿค\u200d๐Ÿง‘๐Ÿฟ": {}, + "๐Ÿง‘๐Ÿฟ\u200d๐Ÿฆฏ": {}, + "๐Ÿง‘๐Ÿฟ\u200d๐Ÿฆฏ\u200dโžก๏ธ": {}, + "๐Ÿง‘๐Ÿฟ\u200d๐Ÿฆฐ": {}, + "๐Ÿง‘๐Ÿฟ\u200d๐Ÿฆฑ": {}, + "๐Ÿง‘๐Ÿฟ\u200d๐Ÿฆฒ": {}, + "๐Ÿง‘๐Ÿฟ\u200d๐Ÿฆณ": {}, + "๐Ÿง‘๐Ÿฟ\u200d๐Ÿฆผ": {}, + "๐Ÿง‘๐Ÿฟ\u200d๐Ÿฆผ\u200dโžก๏ธ": {}, + "๐Ÿง‘๐Ÿฟ\u200d๐Ÿฆฝ": {}, + "๐Ÿง‘๐Ÿฟ\u200d๐Ÿฆฝ\u200dโžก๏ธ": {}, + "๐Ÿง‘๐Ÿฟ\u200d๐Ÿฉฐ": {}, + "๐Ÿง‘๐Ÿฟ\u200d\U0001faef\u200d๐Ÿง‘๐Ÿป": {}, + "๐Ÿง‘๐Ÿฟ\u200d\U0001faef\u200d๐Ÿง‘๐Ÿผ": {}, + "๐Ÿง‘๐Ÿฟ\u200d\U0001faef\u200d๐Ÿง‘๐Ÿฝ": {}, + "๐Ÿง‘๐Ÿฟ\u200d\U0001faef\u200d๐Ÿง‘๐Ÿพ": {}, + "๐Ÿง’": {}, + "๐Ÿง’๐Ÿป": {}, + "๐Ÿง’๐Ÿผ": {}, + "๐Ÿง’๐Ÿฝ": {}, + "๐Ÿง’๐Ÿพ": {}, + "๐Ÿง’๐Ÿฟ": {}, + "๐Ÿง“": {}, + "๐Ÿง“๐Ÿป": {}, + "๐Ÿง“๐Ÿผ": {}, + "๐Ÿง“๐Ÿฝ": {}, + "๐Ÿง“๐Ÿพ": {}, + "๐Ÿง“๐Ÿฟ": {}, + "๐Ÿง”": {}, + "๐Ÿง”\u200dโ™€๏ธ": {}, + "๐Ÿง”\u200dโ™‚๏ธ": {}, + "๐Ÿง”๐Ÿป": {}, + "๐Ÿง”๐Ÿป\u200dโ™€๏ธ": {}, + "๐Ÿง”๐Ÿป\u200dโ™‚๏ธ": {}, + "๐Ÿง”๐Ÿผ": {}, + "๐Ÿง”๐Ÿผ\u200dโ™€๏ธ": {}, + "๐Ÿง”๐Ÿผ\u200dโ™‚๏ธ": {}, + "๐Ÿง”๐Ÿฝ": {}, + "๐Ÿง”๐Ÿฝ\u200dโ™€๏ธ": {}, + "๐Ÿง”๐Ÿฝ\u200dโ™‚๏ธ": {}, + "๐Ÿง”๐Ÿพ": {}, + "๐Ÿง”๐Ÿพ\u200dโ™€๏ธ": {}, + "๐Ÿง”๐Ÿพ\u200dโ™‚๏ธ": {}, + "๐Ÿง”๐Ÿฟ": {}, + "๐Ÿง”๐Ÿฟ\u200dโ™€๏ธ": {}, + "๐Ÿง”๐Ÿฟ\u200dโ™‚๏ธ": {}, + "๐Ÿง•": {}, + "๐Ÿง•๐Ÿป": {}, + "๐Ÿง•๐Ÿผ": {}, + "๐Ÿง•๐Ÿฝ": {}, + "๐Ÿง•๐Ÿพ": {}, + "๐Ÿง•๐Ÿฟ": {}, + "๐Ÿง–": {}, + "๐Ÿง–\u200dโ™€๏ธ": {}, + "๐Ÿง–\u200dโ™‚๏ธ": {}, + "๐Ÿง–๐Ÿป": {}, + "๐Ÿง–๐Ÿป\u200dโ™€๏ธ": {}, + "๐Ÿง–๐Ÿป\u200dโ™‚๏ธ": {}, + "๐Ÿง–๐Ÿผ": {}, + "๐Ÿง–๐Ÿผ\u200dโ™€๏ธ": {}, + "๐Ÿง–๐Ÿผ\u200dโ™‚๏ธ": {}, + "๐Ÿง–๐Ÿฝ": {}, + "๐Ÿง–๐Ÿฝ\u200dโ™€๏ธ": {}, + "๐Ÿง–๐Ÿฝ\u200dโ™‚๏ธ": {}, + "๐Ÿง–๐Ÿพ": {}, + "๐Ÿง–๐Ÿพ\u200dโ™€๏ธ": {}, + "๐Ÿง–๐Ÿพ\u200dโ™‚๏ธ": {}, + "๐Ÿง–๐Ÿฟ": {}, + "๐Ÿง–๐Ÿฟ\u200dโ™€๏ธ": {}, + "๐Ÿง–๐Ÿฟ\u200dโ™‚๏ธ": {}, + "๐Ÿง—": {}, + "๐Ÿง—\u200dโ™€๏ธ": {}, + "๐Ÿง—\u200dโ™‚๏ธ": {}, + "๐Ÿง—๐Ÿป": {}, + "๐Ÿง—๐Ÿป\u200dโ™€๏ธ": {}, + "๐Ÿง—๐Ÿป\u200dโ™‚๏ธ": {}, + "๐Ÿง—๐Ÿผ": {}, + "๐Ÿง—๐Ÿผ\u200dโ™€๏ธ": {}, + "๐Ÿง—๐Ÿผ\u200dโ™‚๏ธ": {}, + "๐Ÿง—๐Ÿฝ": {}, + "๐Ÿง—๐Ÿฝ\u200dโ™€๏ธ": {}, + "๐Ÿง—๐Ÿฝ\u200dโ™‚๏ธ": {}, + "๐Ÿง—๐Ÿพ": {}, + "๐Ÿง—๐Ÿพ\u200dโ™€๏ธ": {}, + "๐Ÿง—๐Ÿพ\u200dโ™‚๏ธ": {}, + "๐Ÿง—๐Ÿฟ": {}, + "๐Ÿง—๐Ÿฟ\u200dโ™€๏ธ": {}, + "๐Ÿง—๐Ÿฟ\u200dโ™‚๏ธ": {}, + "๐Ÿง˜": {}, + "๐Ÿง˜\u200dโ™€๏ธ": {}, + "๐Ÿง˜\u200dโ™‚๏ธ": {}, + "๐Ÿง˜๐Ÿป": {}, + "๐Ÿง˜๐Ÿป\u200dโ™€๏ธ": {}, + "๐Ÿง˜๐Ÿป\u200dโ™‚๏ธ": {}, + "๐Ÿง˜๐Ÿผ": {}, + "๐Ÿง˜๐Ÿผ\u200dโ™€๏ธ": {}, + "๐Ÿง˜๐Ÿผ\u200dโ™‚๏ธ": {}, + "๐Ÿง˜๐Ÿฝ": {}, + "๐Ÿง˜๐Ÿฝ\u200dโ™€๏ธ": {}, + "๐Ÿง˜๐Ÿฝ\u200dโ™‚๏ธ": {}, + "๐Ÿง˜๐Ÿพ": {}, + "๐Ÿง˜๐Ÿพ\u200dโ™€๏ธ": {}, + "๐Ÿง˜๐Ÿพ\u200dโ™‚๏ธ": {}, + "๐Ÿง˜๐Ÿฟ": {}, + "๐Ÿง˜๐Ÿฟ\u200dโ™€๏ธ": {}, + "๐Ÿง˜๐Ÿฟ\u200dโ™‚๏ธ": {}, + "๐Ÿง™": {}, + "๐Ÿง™\u200dโ™€๏ธ": {}, + "๐Ÿง™\u200dโ™‚๏ธ": {}, + "๐Ÿง™๐Ÿป": {}, + "๐Ÿง™๐Ÿป\u200dโ™€๏ธ": {}, + "๐Ÿง™๐Ÿป\u200dโ™‚๏ธ": {}, + "๐Ÿง™๐Ÿผ": {}, + "๐Ÿง™๐Ÿผ\u200dโ™€๏ธ": {}, + "๐Ÿง™๐Ÿผ\u200dโ™‚๏ธ": {}, + "๐Ÿง™๐Ÿฝ": {}, + "๐Ÿง™๐Ÿฝ\u200dโ™€๏ธ": {}, + "๐Ÿง™๐Ÿฝ\u200dโ™‚๏ธ": {}, + "๐Ÿง™๐Ÿพ": {}, + "๐Ÿง™๐Ÿพ\u200dโ™€๏ธ": {}, + "๐Ÿง™๐Ÿพ\u200dโ™‚๏ธ": {}, + "๐Ÿง™๐Ÿฟ": {}, + "๐Ÿง™๐Ÿฟ\u200dโ™€๏ธ": {}, + "๐Ÿง™๐Ÿฟ\u200dโ™‚๏ธ": {}, + "๐Ÿงš": {}, + "๐Ÿงš\u200dโ™€๏ธ": {}, + "๐Ÿงš\u200dโ™‚๏ธ": {}, + "๐Ÿงš๐Ÿป": {}, + "๐Ÿงš๐Ÿป\u200dโ™€๏ธ": {}, + "๐Ÿงš๐Ÿป\u200dโ™‚๏ธ": {}, + "๐Ÿงš๐Ÿผ": {}, + "๐Ÿงš๐Ÿผ\u200dโ™€๏ธ": {}, + "๐Ÿงš๐Ÿผ\u200dโ™‚๏ธ": {}, + "๐Ÿงš๐Ÿฝ": {}, + "๐Ÿงš๐Ÿฝ\u200dโ™€๏ธ": {}, + "๐Ÿงš๐Ÿฝ\u200dโ™‚๏ธ": {}, + "๐Ÿงš๐Ÿพ": {}, + "๐Ÿงš๐Ÿพ\u200dโ™€๏ธ": {}, + "๐Ÿงš๐Ÿพ\u200dโ™‚๏ธ": {}, + "๐Ÿงš๐Ÿฟ": {}, + "๐Ÿงš๐Ÿฟ\u200dโ™€๏ธ": {}, + "๐Ÿงš๐Ÿฟ\u200dโ™‚๏ธ": {}, + "๐Ÿง›": {}, + "๐Ÿง›\u200dโ™€๏ธ": {}, + "๐Ÿง›\u200dโ™‚๏ธ": {}, + "๐Ÿง›๐Ÿป": {}, + "๐Ÿง›๐Ÿป\u200dโ™€๏ธ": {}, + "๐Ÿง›๐Ÿป\u200dโ™‚๏ธ": {}, + "๐Ÿง›๐Ÿผ": {}, + "๐Ÿง›๐Ÿผ\u200dโ™€๏ธ": {}, + "๐Ÿง›๐Ÿผ\u200dโ™‚๏ธ": {}, + "๐Ÿง›๐Ÿฝ": {}, + "๐Ÿง›๐Ÿฝ\u200dโ™€๏ธ": {}, + "๐Ÿง›๐Ÿฝ\u200dโ™‚๏ธ": {}, + "๐Ÿง›๐Ÿพ": {}, + "๐Ÿง›๐Ÿพ\u200dโ™€๏ธ": {}, + "๐Ÿง›๐Ÿพ\u200dโ™‚๏ธ": {}, + "๐Ÿง›๐Ÿฟ": {}, + "๐Ÿง›๐Ÿฟ\u200dโ™€๏ธ": {}, + "๐Ÿง›๐Ÿฟ\u200dโ™‚๏ธ": {}, + "๐Ÿงœ": {}, + "๐Ÿงœ\u200dโ™€๏ธ": {}, + "๐Ÿงœ\u200dโ™‚๏ธ": {}, + "๐Ÿงœ๐Ÿป": {}, + "๐Ÿงœ๐Ÿป\u200dโ™€๏ธ": {}, + "๐Ÿงœ๐Ÿป\u200dโ™‚๏ธ": {}, + "๐Ÿงœ๐Ÿผ": {}, + "๐Ÿงœ๐Ÿผ\u200dโ™€๏ธ": {}, + "๐Ÿงœ๐Ÿผ\u200dโ™‚๏ธ": {}, + "๐Ÿงœ๐Ÿฝ": {}, + "๐Ÿงœ๐Ÿฝ\u200dโ™€๏ธ": {}, + "๐Ÿงœ๐Ÿฝ\u200dโ™‚๏ธ": {}, + "๐Ÿงœ๐Ÿพ": {}, + "๐Ÿงœ๐Ÿพ\u200dโ™€๏ธ": {}, + "๐Ÿงœ๐Ÿพ\u200dโ™‚๏ธ": {}, + "๐Ÿงœ๐Ÿฟ": {}, + "๐Ÿงœ๐Ÿฟ\u200dโ™€๏ธ": {}, + "๐Ÿงœ๐Ÿฟ\u200dโ™‚๏ธ": {}, + "๐Ÿง": {}, + "๐Ÿง\u200dโ™€๏ธ": {}, + "๐Ÿง\u200dโ™‚๏ธ": {}, + "๐Ÿง๐Ÿป": {}, + "๐Ÿง๐Ÿป\u200dโ™€๏ธ": {}, + "๐Ÿง๐Ÿป\u200dโ™‚๏ธ": {}, + "๐Ÿง๐Ÿผ": {}, + "๐Ÿง๐Ÿผ\u200dโ™€๏ธ": {}, + "๐Ÿง๐Ÿผ\u200dโ™‚๏ธ": {}, + "๐Ÿง๐Ÿฝ": {}, + "๐Ÿง๐Ÿฝ\u200dโ™€๏ธ": {}, + "๐Ÿง๐Ÿฝ\u200dโ™‚๏ธ": {}, + "๐Ÿง๐Ÿพ": {}, + "๐Ÿง๐Ÿพ\u200dโ™€๏ธ": {}, + "๐Ÿง๐Ÿพ\u200dโ™‚๏ธ": {}, + "๐Ÿง๐Ÿฟ": {}, + "๐Ÿง๐Ÿฟ\u200dโ™€๏ธ": {}, + "๐Ÿง๐Ÿฟ\u200dโ™‚๏ธ": {}, + "๐Ÿงž": {}, + "๐Ÿงž\u200dโ™€๏ธ": {}, + "๐Ÿงž\u200dโ™‚๏ธ": {}, + "๐ŸงŸ": {}, + "๐ŸงŸ\u200dโ™€๏ธ": {}, + "๐ŸงŸ\u200dโ™‚๏ธ": {}, + "๐Ÿง ": {}, + "๐Ÿงก": {}, + "๐Ÿงข": {}, + "๐Ÿงฃ": {}, + "๐Ÿงค": {}, + "๐Ÿงฅ": {}, + "๐Ÿงฆ": {}, + "๐Ÿงง": {}, + "๐Ÿงจ": {}, + "๐Ÿงฉ": {}, + "๐Ÿงช": {}, + "๐Ÿงซ": {}, + "๐Ÿงฌ": {}, + "๐Ÿงญ": {}, + "๐Ÿงฎ": {}, + "๐Ÿงฏ": {}, + "๐Ÿงฐ": {}, + "๐Ÿงฑ": {}, + "๐Ÿงฒ": {}, + "๐Ÿงณ": {}, + "๐Ÿงด": {}, + "๐Ÿงต": {}, + "๐Ÿงถ": {}, + "๐Ÿงท": {}, + "๐Ÿงธ": {}, + "๐Ÿงน": {}, + "๐Ÿงบ": {}, + "๐Ÿงป": {}, + "๐Ÿงผ": {}, + "๐Ÿงฝ": {}, + "๐Ÿงพ": {}, + "๐Ÿงฟ": {}, + "๐Ÿฉฐ": {}, + "๐Ÿฉฑ": {}, + "๐Ÿฉฒ": {}, + "๐Ÿฉณ": {}, + "๐Ÿฉด": {}, + "๐Ÿฉต": {}, + "๐Ÿฉถ": {}, + "๐Ÿฉท": {}, + "๐Ÿฉธ": {}, + "๐Ÿฉน": {}, + "๐Ÿฉบ": {}, + "๐Ÿฉป": {}, + "๐Ÿฉผ": {}, + "๐Ÿช€": {}, + "๐Ÿช": {}, + "๐Ÿช‚": {}, + "๐Ÿชƒ": {}, + "๐Ÿช„": {}, + "๐Ÿช…": {}, + "๐Ÿช†": {}, + "๐Ÿช‡": {}, + "๐Ÿชˆ": {}, + "\U0001fa89": {}, + "\U0001fa8a": {}, + "\U0001fa8e": {}, + "\U0001fa8f": {}, + "๐Ÿช": {}, + "๐Ÿช‘": {}, + "๐Ÿช’": {}, + "๐Ÿช“": {}, + "๐Ÿช”": {}, + "๐Ÿช•": {}, + "๐Ÿช–": {}, + "๐Ÿช—": {}, + "๐Ÿช˜": {}, + "๐Ÿช™": {}, + "๐Ÿชš": {}, + "๐Ÿช›": {}, + "๐Ÿชœ": {}, + "๐Ÿช": {}, + "๐Ÿชž": {}, + "๐ŸชŸ": {}, + "๐Ÿช ": {}, + "๐Ÿชก": {}, + "๐Ÿชข": {}, + "๐Ÿชฃ": {}, + "๐Ÿชค": {}, + "๐Ÿชฅ": {}, + "๐Ÿชฆ": {}, + "๐Ÿชง": {}, + "๐Ÿชจ": {}, + "๐Ÿชฉ": {}, + "๐Ÿชช": {}, + "๐Ÿชซ": {}, + "๐Ÿชฌ": {}, + "๐Ÿชญ": {}, + "๐Ÿชฎ": {}, + "๐Ÿชฏ": {}, + "๐Ÿชฐ": {}, + "๐Ÿชฑ": {}, + "๐Ÿชฒ": {}, + "๐Ÿชณ": {}, + "๐Ÿชด": {}, + "๐Ÿชต": {}, + "๐Ÿชถ": {}, + "๐Ÿชท": {}, + "๐Ÿชธ": {}, + "๐Ÿชน": {}, + "๐Ÿชบ": {}, + "๐Ÿชป": {}, + "๐Ÿชผ": {}, + "๐Ÿชฝ": {}, + "\U0001fabe": {}, + "๐Ÿชฟ": {}, + "๐Ÿซ€": {}, + "๐Ÿซ": {}, + "๐Ÿซ‚": {}, + "๐Ÿซƒ": {}, + "๐Ÿซƒ๐Ÿป": {}, + "๐Ÿซƒ๐Ÿผ": {}, + "๐Ÿซƒ๐Ÿฝ": {}, + "๐Ÿซƒ๐Ÿพ": {}, + "๐Ÿซƒ๐Ÿฟ": {}, + "๐Ÿซ„": {}, + "๐Ÿซ„๐Ÿป": {}, + "๐Ÿซ„๐Ÿผ": {}, + "๐Ÿซ„๐Ÿฝ": {}, + "๐Ÿซ„๐Ÿพ": {}, + "๐Ÿซ„๐Ÿฟ": {}, + "๐Ÿซ…": {}, + "๐Ÿซ…๐Ÿป": {}, + "๐Ÿซ…๐Ÿผ": {}, + "๐Ÿซ…๐Ÿฝ": {}, + "๐Ÿซ…๐Ÿพ": {}, + "๐Ÿซ…๐Ÿฟ": {}, + "\U0001fac6": {}, + "\U0001fac8": {}, + "\U0001facd": {}, + "๐ŸซŽ": {}, + "๐Ÿซ": {}, + "๐Ÿซ": {}, + "๐Ÿซ‘": {}, + "๐Ÿซ’": {}, + "๐Ÿซ“": {}, + "๐Ÿซ”": {}, + "๐Ÿซ•": {}, + "๐Ÿซ–": {}, + "๐Ÿซ—": {}, + "๐Ÿซ˜": {}, + "๐Ÿซ™": {}, + "๐Ÿซš": {}, + "๐Ÿซ›": {}, + "\U0001fadc": {}, + "\U0001fadf": {}, + "๐Ÿซ ": {}, + "๐Ÿซก": {}, + "๐Ÿซข": {}, + "๐Ÿซฃ": {}, + "๐Ÿซค": {}, + "๐Ÿซฅ": {}, + "๐Ÿซฆ": {}, + "๐Ÿซง": {}, + "๐Ÿซจ": {}, + "\U0001fae9": {}, + "\U0001faea": {}, + "\U0001faef": {}, + "๐Ÿซฐ": {}, + "๐Ÿซฐ๐Ÿป": {}, + "๐Ÿซฐ๐Ÿผ": {}, + "๐Ÿซฐ๐Ÿฝ": {}, + "๐Ÿซฐ๐Ÿพ": {}, + "๐Ÿซฐ๐Ÿฟ": {}, + "๐Ÿซฑ": {}, + "๐Ÿซฑ๐Ÿป": {}, + "๐Ÿซฑ๐Ÿป\u200d๐Ÿซฒ๐Ÿผ": {}, + "๐Ÿซฑ๐Ÿป\u200d๐Ÿซฒ๐Ÿฝ": {}, + "๐Ÿซฑ๐Ÿป\u200d๐Ÿซฒ๐Ÿพ": {}, + "๐Ÿซฑ๐Ÿป\u200d๐Ÿซฒ๐Ÿฟ": {}, + "๐Ÿซฑ๐Ÿผ": {}, + "๐Ÿซฑ๐Ÿผ\u200d๐Ÿซฒ๐Ÿป": {}, + "๐Ÿซฑ๐Ÿผ\u200d๐Ÿซฒ๐Ÿฝ": {}, + "๐Ÿซฑ๐Ÿผ\u200d๐Ÿซฒ๐Ÿพ": {}, + "๐Ÿซฑ๐Ÿผ\u200d๐Ÿซฒ๐Ÿฟ": {}, + "๐Ÿซฑ๐Ÿฝ": {}, + "๐Ÿซฑ๐Ÿฝ\u200d๐Ÿซฒ๐Ÿป": {}, + "๐Ÿซฑ๐Ÿฝ\u200d๐Ÿซฒ๐Ÿผ": {}, + "๐Ÿซฑ๐Ÿฝ\u200d๐Ÿซฒ๐Ÿพ": {}, + "๐Ÿซฑ๐Ÿฝ\u200d๐Ÿซฒ๐Ÿฟ": {}, + "๐Ÿซฑ๐Ÿพ": {}, + "๐Ÿซฑ๐Ÿพ\u200d๐Ÿซฒ๐Ÿป": {}, + "๐Ÿซฑ๐Ÿพ\u200d๐Ÿซฒ๐Ÿผ": {}, + "๐Ÿซฑ๐Ÿพ\u200d๐Ÿซฒ๐Ÿฝ": {}, + "๐Ÿซฑ๐Ÿพ\u200d๐Ÿซฒ๐Ÿฟ": {}, + "๐Ÿซฑ๐Ÿฟ": {}, + "๐Ÿซฑ๐Ÿฟ\u200d๐Ÿซฒ๐Ÿป": {}, + "๐Ÿซฑ๐Ÿฟ\u200d๐Ÿซฒ๐Ÿผ": {}, + "๐Ÿซฑ๐Ÿฟ\u200d๐Ÿซฒ๐Ÿฝ": {}, + "๐Ÿซฑ๐Ÿฟ\u200d๐Ÿซฒ๐Ÿพ": {}, + "๐Ÿซฒ": {}, + "๐Ÿซฒ๐Ÿป": {}, + "๐Ÿซฒ๐Ÿผ": {}, + "๐Ÿซฒ๐Ÿฝ": {}, + "๐Ÿซฒ๐Ÿพ": {}, + "๐Ÿซฒ๐Ÿฟ": {}, + "๐Ÿซณ": {}, + "๐Ÿซณ๐Ÿป": {}, + "๐Ÿซณ๐Ÿผ": {}, + "๐Ÿซณ๐Ÿฝ": {}, + "๐Ÿซณ๐Ÿพ": {}, + "๐Ÿซณ๐Ÿฟ": {}, + "๐Ÿซด": {}, + "๐Ÿซด๐Ÿป": {}, + "๐Ÿซด๐Ÿผ": {}, + "๐Ÿซด๐Ÿฝ": {}, + "๐Ÿซด๐Ÿพ": {}, + "๐Ÿซด๐Ÿฟ": {}, + "๐Ÿซต": {}, + "๐Ÿซต๐Ÿป": {}, + "๐Ÿซต๐Ÿผ": {}, + "๐Ÿซต๐Ÿฝ": {}, + "๐Ÿซต๐Ÿพ": {}, + "๐Ÿซต๐Ÿฟ": {}, + "๐Ÿซถ": {}, + "๐Ÿซถ๐Ÿป": {}, + "๐Ÿซถ๐Ÿผ": {}, + "๐Ÿซถ๐Ÿฝ": {}, + "๐Ÿซถ๐Ÿพ": {}, + "๐Ÿซถ๐Ÿฟ": {}, + "๐Ÿซท": {}, + "๐Ÿซท๐Ÿป": {}, + "๐Ÿซท๐Ÿผ": {}, + "๐Ÿซท๐Ÿฝ": {}, + "๐Ÿซท๐Ÿพ": {}, + "๐Ÿซท๐Ÿฟ": {}, + "๐Ÿซธ": {}, + "๐Ÿซธ๐Ÿป": {}, + "๐Ÿซธ๐Ÿผ": {}, + "๐Ÿซธ๐Ÿฝ": {}, + "๐Ÿซธ๐Ÿพ": {}, + "๐Ÿซธ๐Ÿฟ": {}, +} + +// propEmoji is the Emoji property. +var propEmoji = &unicode.RangeTable{ + R16: []unicode.Range16{ + {0x0023, 0x0023, 1}, + {0x002A, 0x002A, 1}, + {0x0030, 0x0039, 1}, + {0x00A9, 0x00A9, 1}, + {0x00AE, 0x00AE, 1}, + {0x203C, 0x203C, 1}, + {0x2049, 0x2049, 1}, + {0x2122, 0x2122, 1}, + {0x2139, 0x2139, 1}, + {0x2194, 0x2199, 1}, + {0x21A9, 0x21AA, 1}, + {0x231A, 0x231B, 1}, + {0x2328, 0x2328, 1}, + {0x23CF, 0x23CF, 1}, + {0x23E9, 0x23F3, 1}, + {0x23F8, 0x23FA, 1}, + {0x24C2, 0x24C2, 1}, + {0x25AA, 0x25AB, 1}, + {0x25B6, 0x25B6, 1}, + {0x25C0, 0x25C0, 1}, + {0x25FB, 0x25FE, 1}, + {0x2600, 0x2604, 1}, + {0x260E, 0x260E, 1}, + {0x2611, 0x2611, 1}, + {0x2614, 0x2615, 1}, + {0x2618, 0x2618, 1}, + {0x261D, 0x261D, 1}, + {0x2620, 0x2620, 1}, + {0x2622, 0x2623, 1}, + {0x2626, 0x2626, 1}, + {0x262A, 0x262A, 1}, + {0x262E, 0x262F, 1}, + {0x2638, 0x263A, 1}, + {0x2640, 0x2640, 1}, + {0x2642, 0x2642, 1}, + {0x2648, 0x2653, 1}, + {0x265F, 0x2660, 1}, + {0x2663, 0x2663, 1}, + {0x2665, 0x2666, 1}, + {0x2668, 0x2668, 1}, + {0x267B, 0x267B, 1}, + {0x267E, 0x267F, 1}, + {0x2692, 0x2697, 1}, + {0x2699, 0x2699, 1}, + {0x269B, 0x269C, 1}, + {0x26A0, 0x26A1, 1}, + {0x26A7, 0x26A7, 1}, + {0x26AA, 0x26AB, 1}, + {0x26B0, 0x26B1, 1}, + {0x26BD, 0x26BE, 1}, + {0x26C4, 0x26C5, 1}, + {0x26C8, 0x26C8, 1}, + {0x26CE, 0x26CF, 1}, + {0x26D1, 0x26D1, 1}, + {0x26D3, 0x26D4, 1}, + {0x26E9, 0x26EA, 1}, + {0x26F0, 0x26F5, 1}, + {0x26F7, 0x26FA, 1}, + {0x26FD, 0x26FD, 1}, + {0x2702, 0x2702, 1}, + {0x2705, 0x2705, 1}, + {0x2708, 0x270D, 1}, + {0x270F, 0x270F, 1}, + {0x2712, 0x2712, 1}, + {0x2714, 0x2714, 1}, + {0x2716, 0x2716, 1}, + {0x271D, 0x271D, 1}, + {0x2721, 0x2721, 1}, + {0x2728, 0x2728, 1}, + {0x2733, 0x2734, 1}, + {0x2744, 0x2744, 1}, + {0x2747, 0x2747, 1}, + {0x274C, 0x274C, 1}, + {0x274E, 0x274E, 1}, + {0x2753, 0x2755, 1}, + {0x2757, 0x2757, 1}, + {0x2763, 0x2764, 1}, + {0x2795, 0x2797, 1}, + {0x27A1, 0x27A1, 1}, + {0x27B0, 0x27B0, 1}, + {0x27BF, 0x27BF, 1}, + {0x2934, 0x2935, 1}, + {0x2B05, 0x2B07, 1}, + {0x2B1B, 0x2B1C, 1}, + {0x2B50, 0x2B50, 1}, + {0x2B55, 0x2B55, 1}, + {0x3030, 0x3030, 1}, + {0x303D, 0x303D, 1}, + {0x3297, 0x3297, 1}, + {0x3299, 0x3299, 1}, + }, + R32: []unicode.Range32{ + {0x1F004, 0x1F004, 1}, + {0x1F0CF, 0x1F0CF, 1}, + {0x1F170, 0x1F171, 1}, + {0x1F17E, 0x1F17F, 1}, + {0x1F18E, 0x1F18E, 1}, + {0x1F191, 0x1F19A, 1}, + {0x1F1E6, 0x1F1FF, 1}, + {0x1F201, 0x1F202, 1}, + {0x1F21A, 0x1F21A, 1}, + {0x1F22F, 0x1F22F, 1}, + {0x1F232, 0x1F23A, 1}, + {0x1F250, 0x1F251, 1}, + {0x1F300, 0x1F321, 1}, + {0x1F324, 0x1F393, 1}, + {0x1F396, 0x1F397, 1}, + {0x1F399, 0x1F39B, 1}, + {0x1F39E, 0x1F3F0, 1}, + {0x1F3F3, 0x1F3F5, 1}, + {0x1F3F7, 0x1F4FD, 1}, + {0x1F4FF, 0x1F53D, 1}, + {0x1F549, 0x1F54E, 1}, + {0x1F550, 0x1F567, 1}, + {0x1F56F, 0x1F570, 1}, + {0x1F573, 0x1F57A, 1}, + {0x1F587, 0x1F587, 1}, + {0x1F58A, 0x1F58D, 1}, + {0x1F590, 0x1F590, 1}, + {0x1F595, 0x1F596, 1}, + {0x1F5A4, 0x1F5A5, 1}, + {0x1F5A8, 0x1F5A8, 1}, + {0x1F5B1, 0x1F5B2, 1}, + {0x1F5BC, 0x1F5BC, 1}, + {0x1F5C2, 0x1F5C4, 1}, + {0x1F5D1, 0x1F5D3, 1}, + {0x1F5DC, 0x1F5DE, 1}, + {0x1F5E1, 0x1F5E1, 1}, + {0x1F5E3, 0x1F5E3, 1}, + {0x1F5E8, 0x1F5E8, 1}, + {0x1F5EF, 0x1F5EF, 1}, + {0x1F5F3, 0x1F5F3, 1}, + {0x1F5FA, 0x1F64F, 1}, + {0x1F680, 0x1F6C5, 1}, + {0x1F6CB, 0x1F6D2, 1}, + {0x1F6D5, 0x1F6D8, 1}, + {0x1F6DC, 0x1F6E5, 1}, + {0x1F6E9, 0x1F6E9, 1}, + {0x1F6EB, 0x1F6EC, 1}, + {0x1F6F0, 0x1F6F0, 1}, + {0x1F6F3, 0x1F6FC, 1}, + {0x1F7E0, 0x1F7EB, 1}, + {0x1F7F0, 0x1F7F0, 1}, + {0x1F90C, 0x1F93A, 1}, + {0x1F93C, 0x1F945, 1}, + {0x1F947, 0x1F9FF, 1}, + {0x1FA70, 0x1FA7C, 1}, + {0x1FA80, 0x1FA8A, 1}, + {0x1FA8E, 0x1FAC6, 1}, + {0x1FAC8, 0x1FAC8, 1}, + {0x1FACD, 0x1FADC, 1}, + {0x1FADF, 0x1FAEA, 1}, + {0x1FAEF, 0x1FAF8, 1}, + }, +} + +// propEmojiPresentation is the Emoji_Presentation property. +var propEmojiPresentation = &unicode.RangeTable{ + R16: []unicode.Range16{ + {0x231A, 0x231B, 1}, + {0x23E9, 0x23EC, 1}, + {0x23F0, 0x23F0, 1}, + {0x23F3, 0x23F3, 1}, + {0x25FD, 0x25FE, 1}, + {0x2614, 0x2615, 1}, + {0x2648, 0x2653, 1}, + {0x267F, 0x267F, 1}, + {0x2693, 0x2693, 1}, + {0x26A1, 0x26A1, 1}, + {0x26AA, 0x26AB, 1}, + {0x26BD, 0x26BE, 1}, + {0x26C4, 0x26C5, 1}, + {0x26CE, 0x26CE, 1}, + {0x26D4, 0x26D4, 1}, + {0x26EA, 0x26EA, 1}, + {0x26F2, 0x26F3, 1}, + {0x26F5, 0x26F5, 1}, + {0x26FA, 0x26FA, 1}, + {0x26FD, 0x26FD, 1}, + {0x2705, 0x2705, 1}, + {0x270A, 0x270B, 1}, + {0x2728, 0x2728, 1}, + {0x274C, 0x274C, 1}, + {0x274E, 0x274E, 1}, + {0x2753, 0x2755, 1}, + {0x2757, 0x2757, 1}, + {0x2795, 0x2797, 1}, + {0x27B0, 0x27B0, 1}, + {0x27BF, 0x27BF, 1}, + {0x2B1B, 0x2B1C, 1}, + {0x2B50, 0x2B50, 1}, + {0x2B55, 0x2B55, 1}, + }, + R32: []unicode.Range32{ + {0x1F004, 0x1F004, 1}, + {0x1F0CF, 0x1F0CF, 1}, + {0x1F18E, 0x1F18E, 1}, + {0x1F191, 0x1F19A, 1}, + {0x1F1E6, 0x1F1FF, 1}, + {0x1F201, 0x1F201, 1}, + {0x1F21A, 0x1F21A, 1}, + {0x1F22F, 0x1F22F, 1}, + {0x1F232, 0x1F236, 1}, + {0x1F238, 0x1F23A, 1}, + {0x1F250, 0x1F251, 1}, + {0x1F300, 0x1F320, 1}, + {0x1F32D, 0x1F335, 1}, + {0x1F337, 0x1F37C, 1}, + {0x1F37E, 0x1F393, 1}, + {0x1F3A0, 0x1F3CA, 1}, + {0x1F3CF, 0x1F3D3, 1}, + {0x1F3E0, 0x1F3F0, 1}, + {0x1F3F4, 0x1F3F4, 1}, + {0x1F3F8, 0x1F43E, 1}, + {0x1F440, 0x1F440, 1}, + {0x1F442, 0x1F4FC, 1}, + {0x1F4FF, 0x1F53D, 1}, + {0x1F54B, 0x1F54E, 1}, + {0x1F550, 0x1F567, 1}, + {0x1F57A, 0x1F57A, 1}, + {0x1F595, 0x1F596, 1}, + {0x1F5A4, 0x1F5A4, 1}, + {0x1F5FB, 0x1F64F, 1}, + {0x1F680, 0x1F6C5, 1}, + {0x1F6CC, 0x1F6CC, 1}, + {0x1F6D0, 0x1F6D2, 1}, + {0x1F6D5, 0x1F6D8, 1}, + {0x1F6DC, 0x1F6DF, 1}, + {0x1F6EB, 0x1F6EC, 1}, + {0x1F6F4, 0x1F6FC, 1}, + {0x1F7E0, 0x1F7EB, 1}, + {0x1F7F0, 0x1F7F0, 1}, + {0x1F90C, 0x1F93A, 1}, + {0x1F93C, 0x1F945, 1}, + {0x1F947, 0x1F9FF, 1}, + {0x1FA70, 0x1FA7C, 1}, + {0x1FA80, 0x1FA8A, 1}, + {0x1FA8E, 0x1FAC6, 1}, + {0x1FAC8, 0x1FAC8, 1}, + {0x1FACD, 0x1FADC, 1}, + {0x1FADF, 0x1FAEA, 1}, + {0x1FAEF, 0x1FAF8, 1}, + }, +} + +// propEmojiModifier is the Emoji_Modifier property. +var propEmojiModifier = &unicode.RangeTable{ + R16: []unicode.Range16{}, + R32: []unicode.Range32{ + {0x1F3FB, 0x1F3FF, 1}, + }, +} + +// propEmojiModifierBase is the Emoji_Modifier_Base property. +var propEmojiModifierBase = &unicode.RangeTable{ + R16: []unicode.Range16{ + {0x261D, 0x261D, 1}, + {0x26F9, 0x26F9, 1}, + {0x270A, 0x270D, 1}, + }, + R32: []unicode.Range32{ + {0x1F385, 0x1F385, 1}, + {0x1F3C2, 0x1F3C4, 1}, + {0x1F3C7, 0x1F3C7, 1}, + {0x1F3CA, 0x1F3CC, 1}, + {0x1F442, 0x1F443, 1}, + {0x1F446, 0x1F450, 1}, + {0x1F466, 0x1F478, 1}, + {0x1F47C, 0x1F47C, 1}, + {0x1F481, 0x1F483, 1}, + {0x1F485, 0x1F487, 1}, + {0x1F48F, 0x1F48F, 1}, + {0x1F491, 0x1F491, 1}, + {0x1F4AA, 0x1F4AA, 1}, + {0x1F574, 0x1F575, 1}, + {0x1F57A, 0x1F57A, 1}, + {0x1F590, 0x1F590, 1}, + {0x1F595, 0x1F596, 1}, + {0x1F645, 0x1F647, 1}, + {0x1F64B, 0x1F64F, 1}, + {0x1F6A3, 0x1F6A3, 1}, + {0x1F6B4, 0x1F6B6, 1}, + {0x1F6C0, 0x1F6C0, 1}, + {0x1F6CC, 0x1F6CC, 1}, + {0x1F90C, 0x1F90C, 1}, + {0x1F90F, 0x1F90F, 1}, + {0x1F918, 0x1F91F, 1}, + {0x1F926, 0x1F926, 1}, + {0x1F930, 0x1F939, 1}, + {0x1F93C, 0x1F93E, 1}, + {0x1F977, 0x1F977, 1}, + {0x1F9B5, 0x1F9B6, 1}, + {0x1F9B8, 0x1F9B9, 1}, + {0x1F9BB, 0x1F9BB, 1}, + {0x1F9CD, 0x1F9CF, 1}, + {0x1F9D1, 0x1F9DD, 1}, + {0x1FAC3, 0x1FAC5, 1}, + {0x1FAF0, 0x1FAF8, 1}, + }, +} + +// propEmojiComponent is the Emoji_Component property. +var propEmojiComponent = &unicode.RangeTable{ + R16: []unicode.Range16{ + {0x0023, 0x0023, 1}, + {0x002A, 0x002A, 1}, + {0x0030, 0x0039, 1}, + {0x200D, 0x200D, 1}, + {0x20E3, 0x20E3, 1}, + {0xFE0F, 0xFE0F, 1}, + }, + R32: []unicode.Range32{ + {0x1F1E6, 0x1F1FF, 1}, + {0x1F3FB, 0x1F3FF, 1}, + {0x1F9B0, 0x1F9B3, 1}, + {0xE0020, 0xE007F, 1}, + }, +} diff --git a/internal/handlers/hub.go b/internal/handlers/hub.go index 5fa4eb6..aab1f22 100644 --- a/internal/handlers/hub.go +++ b/internal/handlers/hub.go @@ -18,6 +18,7 @@ const ( eventNewMsg = "new_msg" eventDelivered = "delivered" eventRecipientsAdded = "recipients_added" + eventReaction = "reaction" ) // wsEnvelope is the JSON shape of every frame pushed over a WebSocket. The @@ -42,6 +43,12 @@ type Hub struct { // delivered even when the recipient has no live WebSocket. notifyPush func(ctx context.Context, msgID int64, addr string) + // reactionSubject, when non-nil, reports the subject message of msgID + // when msgID is an FMSG-005 reaction. A reaction is pushed to its + // recipients as a reaction event carrying the refreshed subject, never + // as new_msg. + reactionSubject func(ctx context.Context, msgID int64) (int64, bool) + mu sync.RWMutex // registry maps a lower-cased user address to the set of that user's // currently connected clients (a user may have several connections). @@ -57,8 +64,9 @@ func (h *Hub) SetPushNotifier(fn func(ctx context.Context, msgID int64, addr str // NewHub creates a Hub that builds pushed message payloads via msgs. func NewHub(msgs *MessageHandler) *Hub { return &Hub{ - buildItem: msgs.messageItemFor, - registry: make(map[string]map[*wsClient]struct{}), + buildItem: msgs.messageItemFor, + reactionSubject: msgs.reactionSubject, + registry: make(map[string]map[*wsClient]struct{}), } } @@ -147,6 +155,14 @@ func (h *Hub) listen(ctx context.Context, onConnected func()) error { } switch n.Channel { case "new_msg": + if h.reactionSubject != nil { + if subject, ok := h.reactionSubject(ctx, msgID); ok { + // FMSG-005: a reaction is a low-priority event on its + // subject, not a new message. No Web Push is sent. + h.dispatch(ctx, subject, addr, eventReaction) + continue + } + } // Web Push runs in its own goroutine: it is network I/O to many // endpoints and must not stall the single listener. It is // dispatched here, alongside (not inside) dispatch, so a push is diff --git a/internal/handlers/messages.go b/internal/handlers/messages.go index f32e789..8bff835 100644 --- a/internal/handlers/messages.go +++ b/internal/handlers/messages.go @@ -66,6 +66,7 @@ type messageListItem struct { Important bool `json:"important"` NoReply bool `json:"no_reply"` Deflate bool `json:"deflate"` + Terminal bool `json:"terminal"` PID *int64 `json:"pid"` From string `json:"from"` To []string `json:"to"` @@ -79,6 +80,10 @@ type messageListItem struct { Read bool `json:"read"` TimeRead *float64 `json:"time_read"` Attachments []models.Attachment `json:"attachments"` + Reaction *string `json:"reaction"` + Reactions []models.Reaction `json:"reactions"` + + dataPath string // stored body path, for reaction recognition; never serialised } // formatDeliveredISO converts a nullable Unix-epoch-seconds timestamp (as @@ -286,7 +291,7 @@ func (h *MessageHandler) List(c *gin.Context) { ctx := c.Request.Context() rows, err := h.DB.Pool.Query(ctx, - `SELECT m.id, m.version, m.pid, m.no_reply, m.is_important, m.is_deflate, m.time_sent, m.from_addr, m.topic, m.type, m.size, m.filepath, + `SELECT m.id, m.version, m.pid, m.no_reply, m.is_important, m.is_deflate, m.is_terminal, m.time_sent, m.from_addr, m.topic, m.type, m.size, m.filepath, COALESCE( (SELECT mt.time_read FROM msg_to mt WHERE mt.msg_id = m.id AND mt.addr = ANY($1)), (SELECT mat.time_read FROM msg_add_to mat WHERE mat.msg_id = m.id AND mat.addr = ANY($1)) @@ -310,13 +315,14 @@ func (h *MessageHandler) List(c *gin.Context) { for rows.Next() { var m messageListItem var dataPath string - if err := rows.Scan(&m.ID, &m.Version, &m.PID, &m.NoReply, &m.Important, &m.Deflate, &m.Time, &m.From, &m.Topic, &m.Type, &m.Size, &dataPath, &m.TimeRead); err != nil { + if err := rows.Scan(&m.ID, &m.Version, &m.PID, &m.NoReply, &m.Important, &m.Deflate, &m.Terminal, &m.Time, &m.From, &m.Topic, &m.Type, &m.Size, &dataPath, &m.TimeRead); err != nil { log.Printf("list messages scan: %v", err) c.JSON(http.StatusInternalServerError, gin.H{"error": "failed to list messages"}) return } m.HasPid = m.PID != nil m.Read = m.TimeRead != nil + m.dataPath = dataPath m.ShortText = h.extractShortText(dataPath, m.Type) messages = append(messages, m) msgIDs = append(msgIDs, m.ID) @@ -361,6 +367,8 @@ func (h *MessageHandler) List(c *gin.Context) { } } + h.populateListReactions(ctx, messages) + c.JSON(http.StatusOK, messages) } @@ -387,7 +395,7 @@ func (h *MessageHandler) Sent(c *gin.Context) { ctx := c.Request.Context() rows, err := h.DB.Pool.Query(ctx, - `SELECT m.id, m.version, m.pid, m.no_reply, m.is_important, m.is_deflate, m.time_sent, m.from_addr, m.topic, m.type, m.size, m.filepath + `SELECT m.id, m.version, m.pid, m.no_reply, m.is_important, m.is_deflate, m.is_terminal, m.time_sent, m.from_addr, m.topic, m.type, m.size, m.filepath FROM msg m WHERE m.from_addr = ANY($1) ORDER BY m.id DESC @@ -406,12 +414,13 @@ func (h *MessageHandler) Sent(c *gin.Context) { for rows.Next() { var m messageListItem var dataPath string - if err := rows.Scan(&m.ID, &m.Version, &m.PID, &m.NoReply, &m.Important, &m.Deflate, &m.Time, &m.From, &m.Topic, &m.Type, &m.Size, &dataPath); err != nil { + if err := rows.Scan(&m.ID, &m.Version, &m.PID, &m.NoReply, &m.Important, &m.Deflate, &m.Terminal, &m.Time, &m.From, &m.Topic, &m.Type, &m.Size, &dataPath); err != nil { log.Printf("list sent messages scan: %v", err) c.JSON(http.StatusInternalServerError, gin.H{"error": "failed to list sent messages"}) return } m.HasPid = m.PID != nil + m.dataPath = dataPath m.ShortText = h.extractShortText(dataPath, m.Type) messages = append(messages, m) msgIDs = append(msgIDs, m.ID) @@ -456,6 +465,8 @@ func (h *MessageHandler) Sent(c *gin.Context) { } } + h.populateListReactions(ctx, messages) + c.JSON(http.StatusOK, messages) } @@ -497,19 +508,9 @@ func (h *MessageHandler) Create(c *gin.Context) { ctx := c.Request.Context() - // Validate PID references an existing message. - if msg.PID != nil { - var exists bool - err := h.DB.Pool.QueryRow(ctx, "SELECT EXISTS(SELECT 1 FROM msg WHERE id = $1)", *msg.PID).Scan(&exists) - if err != nil { - log.Printf("create message: validate pid: %v", err) - c.JSON(http.StatusInternalServerError, gin.H{"error": "failed to validate pid"}) - return - } - if !exists { - c.JSON(http.StatusBadRequest, gin.H{"error": fmt.Sprintf("PID %d not found", *msg.PID)}) - return - } + // Validate PID references an existing, non-terminal message. + if !h.validateParent(c, msg.PID) { + return } // Detect zip (deflate) content by checking for the zip magic bytes. @@ -522,10 +523,10 @@ func (h *MessageHandler) Create(c *gin.Context) { dataSize := len(msg.Data) var msgID int64 err := h.DB.Pool.QueryRow(ctx, - `INSERT INTO msg (version, pid, no_reply, is_important, is_deflate, from_addr, topic, type, size, filepath, time_sent) - VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, '', NULL) + `INSERT INTO msg (version, pid, no_reply, is_important, is_deflate, is_terminal, from_addr, topic, type, size, filepath, time_sent) + VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, '', NULL) RETURNING id`, - msg.Version, msg.PID, msg.NoReply, msg.Important, msg.Deflate, msg.From, msg.Topic, msg.Type, dataSize, + msg.Version, msg.PID, msg.NoReply, msg.Important, msg.Deflate, msg.Terminal, msg.From, msg.Topic, msg.Type, dataSize, ).Scan(&msgID) if err != nil { log.Printf("create message: insert: %v", err) @@ -595,6 +596,11 @@ func (h *MessageHandler) Get(c *gin.Context) { // Compute ShortText only after authorization has been confirmed. msg.ShortText = h.extractShortText(dataPath, msg.Type) + msg.Reaction = h.reactionOf(msg.HasPid, msg.NoReply, msg.Terminal, msg.Important, msg.HasAddTo, msg.Type, msg.Size, len(msg.Attachments), dataPath) + msg.Reactions = h.loadReactions(ctx, []int64{msgID})[msgID] + if msg.Reactions == nil { + msg.Reactions = []models.Reaction{} + } // Populate per-recipient read state for the calling user. The sender // has no read state of their own. @@ -727,6 +733,10 @@ func (h *MessageHandler) Update(c *gin.Context) { return } + if !h.validateParent(c, msg.PID) { + return + } + if int64(len(msg.Data)) > h.MaxDataSize { c.JSON(http.StatusRequestEntityTooLarge, gin.H{"error": "message data exceeds maximum size"}) return @@ -758,8 +768,8 @@ func (h *MessageHandler) Update(c *gin.Context) { } _, err = h.DB.Pool.Exec(ctx, - `UPDATE msg SET version=$1, pid=$2, no_reply=$3, is_important=$4, is_deflate=$5, topic=$6, type=$7, size=$8, filepath=$9 WHERE id=$10`, - msg.Version, msg.PID, msg.NoReply, msg.Important, msg.Deflate, msg.Topic, msg.Type, len(msg.Data), dataPath, msgID, + `UPDATE msg SET version=$1, pid=$2, no_reply=$3, is_important=$4, is_deflate=$5, is_terminal=$6, topic=$7, type=$8, size=$9, filepath=$10 WHERE id=$11`, + msg.Version, msg.PID, msg.NoReply, msg.Important, msg.Deflate, msg.Terminal, msg.Topic, msg.Type, len(msg.Data), dataPath, msgID, ) if err != nil { log.Printf("update message %d: %v", msgID, err) @@ -1030,9 +1040,10 @@ func (h *MessageHandler) AddRecipients(c *gin.Context) { // own pid is irrelevant here and need not be looked up. var fromAddr string var timeSent *float64 + var terminal bool err := h.DB.Pool.QueryRow(ctx, - "SELECT from_addr, time_sent FROM msg WHERE id = $1", msgID, - ).Scan(&fromAddr, &timeSent) + "SELECT from_addr, time_sent, is_terminal FROM msg WHERE id = $1", msgID, + ).Scan(&fromAddr, &timeSent, &terminal) if err != nil { if errors.Is(err, pgx.ErrNoRows) { c.JSON(http.StatusNotFound, gin.H{"error": "message not found"}) @@ -1042,6 +1053,12 @@ func (h *MessageHandler) AddRecipients(c *gin.Context) { } return } + // A terminal message is a leaf: recipients cannot be added to it (fmsg + // Specification v0.6.0 ยง12). + if terminal { + c.JSON(http.StatusConflict, gin.H{"error": "message is terminal; recipients cannot be added to it"}) + return + } // Verify the requester is an existing participant (from or msg_to). if fromAddr != identity { @@ -1270,7 +1287,7 @@ func (h *MessageHandler) loadAddToBatches(ctx context.Context, msgIDs []int64) m // after performing their own authorization checks. func (h *MessageHandler) fetchMessage(ctx context.Context, msgID int64) (*models.Message, string, error) { row := h.DB.Pool.QueryRow(ctx, - `SELECT version, pid, no_reply, is_important, is_deflate, time_sent, from_addr, topic, type, size, filepath FROM msg WHERE id = $1`, + `SELECT version, pid, no_reply, is_important, is_deflate, is_terminal, time_sent, from_addr, topic, type, size, filepath FROM msg WHERE id = $1`, msgID, ) @@ -1278,7 +1295,7 @@ func (h *MessageHandler) fetchMessage(ctx context.Context, msgID int64) (*models var pid *int64 var timeSent *float64 var dataPath string - if err := row.Scan(&msg.Version, &pid, &msg.NoReply, &msg.Important, &msg.Deflate, &timeSent, &msg.From, &msg.Topic, &msg.Type, &msg.Size, &dataPath); err != nil { + if err := row.Scan(&msg.Version, &pid, &msg.NoReply, &msg.Important, &msg.Deflate, &msg.Terminal, &timeSent, &msg.From, &msg.Topic, &msg.Type, &msg.Size, &dataPath); err != nil { return nil, "", err } msg.PID = pid @@ -1327,6 +1344,7 @@ func (h *MessageHandler) messageItemFor(ctx context.Context, msgID int64, recipi Important: msg.Important, NoReply: msg.NoReply, Deflate: msg.Deflate, + Terminal: msg.Terminal, PID: msg.PID, From: msg.From, To: msg.To, @@ -1338,6 +1356,12 @@ func (h *MessageHandler) messageItemFor(ctx context.Context, msgID int64, recipi Size: msg.Size, ShortText: h.extractShortText(dataPath, msg.Type), Attachments: msg.Attachments, + dataPath: dataPath, + } + item.Reaction = h.reactionOf(item.HasPid, item.NoReply, item.Terminal, item.Important, item.HasAddTo, item.Type, item.Size, len(item.Attachments), dataPath) + item.Reactions = h.loadReactions(ctx, []int64{msgID})[msgID] + if item.Reactions == nil { + item.Reactions = []models.Reaction{} } // Populate the recipient's per-recipient read state, mirroring Get. @@ -1607,6 +1631,33 @@ func validatePidRelations(pid *int64, topic string) error { return nil } +// validateParent checks a draft's pid, when set, references an existing +// message that is not terminal, writing the error response and returning +// false otherwise. A terminal message is a leaf: no message may reference it +// via pid (fmsg Specification v0.6.0 ยง3), and the database refuses such a row +// too; checking here gives the caller a clear answer instead. +func (h *MessageHandler) validateParent(c *gin.Context, pid *int64) bool { + if pid == nil { + return true + } + var terminal bool + err := h.DB.Pool.QueryRow(c.Request.Context(), "SELECT is_terminal FROM msg WHERE id = $1", *pid).Scan(&terminal) + if errors.Is(err, pgx.ErrNoRows) { + c.JSON(http.StatusBadRequest, gin.H{"error": fmt.Sprintf("PID %d not found", *pid)}) + return false + } + if err != nil { + log.Printf("validate pid %d: %v", *pid, err) + c.JSON(http.StatusInternalServerError, gin.H{"error": "failed to validate pid"}) + return false + } + if terminal { + c.JSON(http.StatusConflict, gin.H{"error": fmt.Sprintf("PID %d is terminal; it cannot be replied to", *pid)}) + return false + } + return true +} + // checkDistinctRecipients returns an error if any address in to or addTo // appears more than once (case-insensitive). func checkDistinctRecipients(to, addTo []string) error { diff --git a/internal/handlers/push.go b/internal/handlers/push.go index 1c9a7bf..2d2bb8e 100644 --- a/internal/handlers/push.go +++ b/internal/handlers/push.go @@ -178,6 +178,9 @@ func (h *PushHandler) NotifyNewMsg(_ context.Context, msgID int64, addr string) log.Printf("push notify: build message %d for %s: %v", msgID, addr, err) return } + if item.Reaction != nil { + return // FMSG-005: a reaction does not warrant a notification + } payload, err := json.Marshal(buildPushPayload(item, rootID, h.iconURL)) if err != nil { diff --git a/internal/handlers/reactions.go b/internal/handlers/reactions.go new file mode 100644 index 0000000..525b617 --- /dev/null +++ b/internal/handlers/reactions.go @@ -0,0 +1,434 @@ +package handlers + +import ( + "bytes" + "context" + "errors" + "io" + "log" + "net/http" + "os" + "sort" + "strings" + "time" + + "github.com/gin-gonic/gin" + "github.com/jackc/pgx/v5" + "github.com/markmnl/fmsg-webapi/internal/emoji" + "github.com/markmnl/fmsg-webapi/internal/middleware" + "github.com/markmnl/fmsg-webapi/internal/models" +) + +// FMSG-005 Reactions. A reaction is an ordinary message recognised by its +// shape: a reply (pid set) with no reply and terminal set, not important, with +// no add-to batch, body type text/plain;charset=UTF-8 (Common Media Type 56), +// no attachments, and data that is a single emoji or empty to clear. A +// reactor's effective reaction on a subject is their latest reaction message +// by time, ties broken by the greater message hash. + +const ( + // reactionMediaType is Common Media Type 56, the body type of a reaction. + reactionMediaType = "text/plain;charset=UTF-8" + // maxReactionBytes bounds reaction data (FMSG-005 Fields). + maxReactionBytes = 64 +) + +// isReactionMediaType reports whether a stored type string is the reaction +// media type, tolerating case and whitespace differences in the parameter. +func isReactionMediaType(mediaType string) bool { + return strings.EqualFold(strings.ReplaceAll(mediaType, " ", ""), reactionMediaType) +} + +// reactionShape reports whether a message's metadata has the shape of a +// reaction, before its data is examined. +func reactionShape(hasPid, noReply, terminal, important, hasAddTo bool, mediaType string, size, attachments int) bool { + return hasPid && noReply && terminal && !important && !hasAddTo && + size >= 0 && size <= maxReactionBytes && attachments == 0 && + isReactionMediaType(mediaType) +} + +// readReactionData reads a shape-matching message's body and returns the emoji +// it carries ("" clears) and whether the body is a valid reaction body. +func (h *MessageHandler) readReactionData(dataPath string, size int) (string, bool) { + if size == 0 { + return "", true + } + cleanPath, ok := safeDataPath(dataPath, h.DataDir) + if !ok { + return "", false + } + f, err := os.Open(cleanPath) + if err != nil { + if !errors.Is(err, os.ErrNotExist) { + log.Printf("reaction data: open %s: %v", cleanPath, err) + } + return "", false + } + defer f.Close() + buf := make([]byte, maxReactionBytes+1) + n, err := io.ReadFull(f, buf) + if err != nil && !errors.Is(err, io.EOF) && !errors.Is(err, io.ErrUnexpectedEOF) { + log.Printf("reaction data: read %s: %v", cleanPath, err) + return "", false + } + s := string(buf[:n]) + if !emoji.IsSingle(s) { + return "", false + } + return s, true +} + +// reactionOf returns the reaction a message carries, or nil when the message +// is not a reaction. +func (h *MessageHandler) reactionOf(hasPid, noReply, terminal, important, hasAddTo bool, mediaType string, size, attachments int, dataPath string) *string { + if !reactionShape(hasPid, noReply, terminal, important, hasAddTo, mediaType, size, attachments) { + return nil + } + s, ok := h.readReactionData(dataPath, size) + if !ok { + return nil + } + return &s +} + +// reactionSubject reports the subject of msgID when msgID is a reaction. Used +// by the WebSocket hub to route an arriving reaction as a reaction event. +func (h *MessageHandler) reactionSubject(ctx context.Context, msgID int64) (int64, bool) { + var pid *int64 + var noReply, terminal, important, hasAddTo bool + var mediaType, dataPath string + var size, attachments int + err := h.DB.Pool.QueryRow(ctx, ` + SELECT m.pid, m.no_reply, m.is_terminal, m.is_important, m.type, m.size, m.filepath, + (SELECT COUNT(*) FROM msg_attachment a WHERE a.msg_id = m.id), + EXISTS (SELECT 1 FROM msg_add_to_batch b WHERE b.msg_id = m.id) + FROM msg m WHERE m.id = $1`, msgID, + ).Scan(&pid, &noReply, &terminal, &important, &mediaType, &size, &dataPath, &attachments, &hasAddTo) + if err != nil { + if !errors.Is(err, pgx.ErrNoRows) { + log.Printf("reaction subject of %d: %v", msgID, err) + } + return 0, false + } + if pid == nil || h.reactionOf(true, noReply, terminal, important, hasAddTo, mediaType, size, attachments, dataPath) == nil { + return 0, false + } + return *pid, true +} + +// reactionRow is one stored reaction message on a subject. +type reactionRow struct { + subjectID int64 + msgID int64 + from string + time float64 + hash []byte // message hash; nil until the host has computed it + emoji string // "" clears +} + +// newerReaction reports whether a supersedes b as a reactor's effective +// reaction: later time wins, ties broken by the greater message hash. +func newerReaction(a, b reactionRow) bool { + if a.time != b.time { + return a.time > b.time + } + return bytes.Compare(a.hash, b.hash) > 0 +} + +// effectiveReactions reduces reaction rows to each subject's effective +// reactions: one per reactor, grouped by emoji in order of first reaction, +// reactors within a group in time order. A reactor whose effective reaction is +// empty has none and is omitted. +func effectiveReactions(rows []reactionRow) map[int64][]models.Reaction { + bySubject := make(map[int64]map[string]reactionRow) + for _, r := range rows { + reactors := bySubject[r.subjectID] + if reactors == nil { + reactors = make(map[string]reactionRow) + bySubject[r.subjectID] = reactors + } + key := strings.ToLower(r.from) + if cur, ok := reactors[key]; !ok || newerReaction(r, cur) { + reactors[key] = r + } + } + + result := make(map[int64][]models.Reaction, len(bySubject)) + for subject, reactors := range bySubject { + var eff []reactionRow + for _, r := range reactors { + if r.emoji != "" { + eff = append(eff, r) + } + } + sort.Slice(eff, func(i, j int) bool { + if eff[i].time != eff[j].time { + return eff[i].time < eff[j].time + } + return eff[i].msgID < eff[j].msgID + }) + var groups []models.Reaction + idx := make(map[string]int) + for _, r := range eff { + i, ok := idx[r.emoji] + if !ok { + groups = append(groups, models.Reaction{Emoji: r.emoji}) + i = len(groups) - 1 + idx[r.emoji] = i + } + groups[i].From = append(groups[i].From, r.from) + } + if len(groups) > 0 { + result[subject] = groups + } + } + return result +} + +// loadReactionRows loads every sent reaction on the given subjects, or only +// those from one reactor when from is non-empty. Rows whose data is not a +// valid reaction body are ordinary messages and are skipped. +func (h *MessageHandler) loadReactionRows(ctx context.Context, subjectIDs []int64, from string) ([]reactionRow, error) { + if len(subjectIDs) == 0 { + return nil, nil + } + rows, err := h.DB.Pool.Query(ctx, ` + SELECT r.pid, r.id, r.from_addr, r.time_sent, r.sha256, r.size, r.filepath + FROM msg r + WHERE r.pid = ANY($1) + AND r.time_sent IS NOT NULL + AND r.is_terminal AND r.no_reply AND NOT r.is_important + AND r.size <= $2 + AND lower(replace(r.type, ' ', '')) = $3 + AND ($4 = '' OR lower(r.from_addr) = lower($4)) + AND NOT EXISTS (SELECT 1 FROM msg_attachment a WHERE a.msg_id = r.id) + AND NOT EXISTS (SELECT 1 FROM msg_add_to_batch b WHERE b.msg_id = r.id) + ORDER BY r.pid, r.time_sent, r.id`, + subjectIDs, maxReactionBytes, strings.ToLower(reactionMediaType), from, + ) + if err != nil { + return nil, err + } + defer rows.Close() + var out []reactionRow + for rows.Next() { + var r reactionRow + var size int + var dataPath string + if err := rows.Scan(&r.subjectID, &r.msgID, &r.from, &r.time, &r.hash, &size, &dataPath); err != nil { + return nil, err + } + e, ok := h.readReactionData(dataPath, size) + if !ok { + continue + } + r.emoji = e + out = append(out, r) + } + return out, rows.Err() +} + +// loadReactions returns the effective reactions on each of the given subjects. +func (h *MessageHandler) loadReactions(ctx context.Context, subjectIDs []int64) map[int64][]models.Reaction { + rows, err := h.loadReactionRows(ctx, subjectIDs, "") + if err != nil { + log.Printf("load reactions: %v", err) + return nil + } + return effectiveReactions(rows) +} + +// populateListReactions fills Reaction and Reactions on every list item. +func (h *MessageHandler) populateListReactions(ctx context.Context, items []messageListItem) { + ids := make([]int64, len(items)) + for i := range items { + it := &items[i] + it.Reaction = h.reactionOf(it.HasPid, it.NoReply, it.Terminal, it.Important, it.HasAddTo, it.Type, it.Size, len(it.Attachments), it.dataPath) + ids[i] = it.ID + } + reactions := h.loadReactions(ctx, ids) + for i := range items { + items[i].Reactions = reactions[items[i].ID] + if items[i].Reactions == nil { + items[i].Reactions = []models.Reaction{} + } + } +} + +// reactionRecipients returns a subject's participants other than the reactor, +// in message order and deduplicated case-insensitively: the to list of a +// reaction (FMSG-005 Recipients). +func reactionRecipients(subject *models.Message, reactor string) []string { + seen := map[string]bool{strings.ToLower(reactor): true} + var out []string + add := func(addr string) { + key := strings.ToLower(addr) + if seen[key] { + return + } + seen[key] = true + out = append(out, addr) + } + add(subject.From) + for _, a := range subject.To { + add(a) + } + for _, b := range subject.AddTo { + add(b.AddToFrom) + for _, a := range b.To { + add(a) + } + } + return out +} + +// reactInput is the request body of POST /fmsg/:id/react. +type reactInput struct { + Emoji *string `json:"emoji"` // a single emoji; null or "" clears the caller's reaction +} + +// React handles POST /fmsg/:id/react โ€” sets or clears the caller's reaction on +// a message by sending a reaction message (FMSG-005) to every other +// participant. Sending an identical reaction to the current effective one is +// idempotent and sends nothing. +func (h *MessageHandler) React(c *gin.Context) { + identity := middleware.GetIdentity(c) + msgID, ok := parseID(c) + if !ok { + return + } + + var in reactInput + if err := c.ShouldBindJSON(&in); err != nil { + c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()}) + return + } + want := "" + if in.Emoji != nil { + want = *in.Emoji + } + if want != "" && !emoji.IsSingle(want) { + c.JSON(http.StatusBadRequest, gin.H{"error": "emoji must be a single emoji, or empty to clear"}) + return + } + + ctx := c.Request.Context() + subject, _, err := h.fetchMessage(ctx, msgID) + if err != nil { + if errors.Is(err, pgx.ErrNoRows) { + c.JSON(http.StatusNotFound, gin.H{"error": "message not found"}) + } else { + log.Printf("react to %d: fetch: %v", msgID, err) + c.JSON(http.StatusInternalServerError, gin.H{"error": "failed to retrieve message"}) + } + return + } + + // Only a participant of the subject may react to it (the host enforces + // the same rule on the wire). + if !strings.EqualFold(subject.From, identity) && !isRecipient(subject.To, identity) && !addToContains(subject.AddTo, identity) { + c.JSON(http.StatusForbidden, gin.H{"error": "only participants may react to a message"}) + return + } + if subject.Time == nil { + c.JSON(http.StatusConflict, gin.H{"error": "cannot react to a draft"}) + return + } + if subject.Terminal { + c.JSON(http.StatusConflict, gin.H{"error": "message is terminal; it cannot be reacted to"}) + return + } + + recipients := reactionRecipients(subject, identity) + if len(recipients) == 0 { + c.JSON(http.StatusConflict, gin.H{"error": "message has no other participants to send a reaction to"}) + return + } + + // Idempotency: the caller's current effective reaction. + mine, err := h.loadReactionRows(ctx, []int64{msgID}, identity) + if err != nil { + log.Printf("react to %d: load reactions: %v", msgID, err) + c.JSON(http.StatusInternalServerError, gin.H{"error": "failed to load reactions"}) + return + } + var current *reactionRow + for i := range mine { + if current == nil || newerReaction(mine[i], *current) { + current = &mine[i] + } + } + switch { + case current != nil && current.emoji == want: + c.JSON(http.StatusOK, gin.H{"id": current.msgID, "time": current.time}) + return + case current == nil && want == "": + c.JSON(http.StatusOK, gin.H{"id": nil, "time": nil}) + return + } + + // As for any reply, refuse when a remote recipient host can never accept + // it because it does not hold the subject (SPEC ยง10.3, code 6). + if replyDomains := remoteRecipientDomains(&models.Message{To: recipients}, h.LocalDomain); len(replyDomains) > 0 { + parentFromDomain, byDomain, derr := h.parentDeliveryByDomain(ctx, msgID) + if derr != nil { + log.Printf("react to %d: verify delivery: %v", msgID, derr) + c.JSON(http.StatusInternalServerError, gin.H{"error": "failed to verify parent delivery"}) + return + } + if blocked := undeliverableReplyDomains(replyDomains, parentFromDomain, byDomain); len(blocked) > 0 { + c.JSON(http.StatusConflict, gin.H{"error": "reaction cannot be accepted by recipient host(s): " + strings.Join(blocked, "; ")}) + return + } + } + + now := float64(time.Now().UnixMicro()) / 1e6 + tx, err := h.DB.Pool.Begin(ctx) + if err != nil { + log.Printf("react to %d: begin: %v", msgID, err) + c.JSON(http.StatusInternalServerError, gin.H{"error": "failed to send reaction"}) + return + } + defer tx.Rollback(ctx) + + var reactionID int64 + if err := tx.QueryRow(ctx, + `INSERT INTO msg (version, pid, no_reply, is_important, is_deflate, is_terminal, from_addr, topic, type, size, filepath, time_sent) + VALUES (1, $1, true, false, false, true, $2, '', $3, $4, '', $5) + RETURNING id`, + msgID, identity, reactionMediaType, len(want), now, + ).Scan(&reactionID); err != nil { + log.Printf("react to %d: insert: %v", msgID, err) + c.JSON(http.StatusInternalServerError, gin.H{"error": "failed to send reaction"}) + return + } + dataPath, err := h.saveMessageData(identity, reactionID, mimeToExt(reactionMediaType), want) + if err != nil { + log.Printf("react to %d: save data: %v", msgID, err) + c.JSON(http.StatusInternalServerError, gin.H{"error": "failed to save reaction"}) + return + } + if _, err := tx.Exec(ctx, "UPDATE msg SET filepath = $1 WHERE id = $2", dataPath, reactionID); err != nil { + log.Printf("react to %d: update filepath: %v", msgID, err) + c.JSON(http.StatusInternalServerError, gin.H{"error": "failed to send reaction"}) + return + } + for _, addr := range recipients { + if _, err := tx.Exec(ctx, "INSERT INTO msg_to (msg_id, addr) VALUES ($1, $2)", reactionID, addr); err != nil { + log.Printf("react to %d: insert recipient %s: %v", msgID, addr, err) + c.JSON(http.StatusInternalServerError, gin.H{"error": "failed to send reaction"}) + return + } + } + if err := tx.Commit(ctx); err != nil { + log.Printf("react to %d: commit: %v", msgID, err) + c.JSON(http.StatusInternalServerError, gin.H{"error": "failed to send reaction"}) + return + } + + // fmsgd's outbound sender skips the local domain, so local recipients + // have their delivery resolved here, as Send does. + h.resolveLocalDelivery(ctx, "msg_to", reactionID, h.LocalDomain, recipients) + + c.JSON(http.StatusCreated, gin.H{"id": reactionID, "time": now}) +} diff --git a/internal/handlers/reactions_test.go b/internal/handlers/reactions_test.go new file mode 100644 index 0000000..8e2478c --- /dev/null +++ b/internal/handlers/reactions_test.go @@ -0,0 +1,190 @@ +package handlers + +import ( + "context" + "encoding/json" + "os" + "path/filepath" + "reflect" + "testing" + + "github.com/markmnl/fmsg-webapi/internal/models" +) + +func TestIsReactionMediaType(t *testing.T) { + for _, s := range []string{"text/plain;charset=UTF-8", "text/plain; charset=utf-8", "TEXT/PLAIN;CHARSET=UTF-8"} { + if !isReactionMediaType(s) { + t.Errorf("isReactionMediaType(%q) = false", s) + } + } + for _, s := range []string{"text/plain", "text/markdown;charset=UTF-8", "application/octet-stream", ""} { + if isReactionMediaType(s) { + t.Errorf("isReactionMediaType(%q) = true", s) + } + } +} + +func TestReactionShape(t *testing.T) { + ok := func(hasPid, noReply, terminal, important, hasAddTo bool, typ string, size, att int) bool { + return reactionShape(hasPid, noReply, terminal, important, hasAddTo, typ, size, att) + } + if !ok(true, true, true, false, false, reactionMediaType, 4, 0) { + t.Error("canonical reaction shape rejected") + } + if !ok(true, true, true, false, false, reactionMediaType, 0, 0) { + t.Error("clearing reaction shape rejected") + } + cases := map[string]bool{ + "no pid": ok(false, true, true, false, false, reactionMediaType, 4, 0), + "no no-reply": ok(true, false, true, false, false, reactionMediaType, 4, 0), + "not terminal": ok(true, true, false, false, false, reactionMediaType, 4, 0), + "important": ok(true, true, true, true, false, reactionMediaType, 4, 0), + "add-to": ok(true, true, true, false, true, reactionMediaType, 4, 0), + "wrong type": ok(true, true, true, false, false, "text/markdown", 4, 0), + "too big": ok(true, true, true, false, false, reactionMediaType, maxReactionBytes+1, 0), + "attachment": ok(true, true, true, false, false, reactionMediaType, 4, 1), + "negative size": ok(true, true, true, false, false, reactionMediaType, -1, 0), + } + for name, got := range cases { + if got { + t.Errorf("%s: shape accepted", name) + } + } +} + +func TestReactionOfReadsData(t *testing.T) { + dir := t.TempDir() + h := &MessageHandler{DataDir: dir} + write := func(name, data string) string { + p := filepath.Join(dir, name) + if err := os.WriteFile(p, []byte(data), 0o600); err != nil { + t.Fatal(err) + } + return p + } + thumbs := write("thumbs", "๐Ÿ‘") + text := write("text", "ok ๐Ÿ‘") + empty := write("empty", "") + + if r := h.reactionOf(true, true, true, false, false, reactionMediaType, 4, 0, thumbs); r == nil || *r != "๐Ÿ‘" { + t.Errorf("reactionOf(thumbs) = %v, want ๐Ÿ‘", r) + } + if r := h.reactionOf(true, true, true, false, false, reactionMediaType, 6, 0, text); r != nil { + t.Errorf("reactionOf(text) = %q, want nil", *r) + } + if r := h.reactionOf(true, true, true, false, false, reactionMediaType, 0, 0, empty); r == nil || *r != "" { + t.Errorf("reactionOf(empty) = %v, want \"\"", r) + } + if r := h.reactionOf(true, true, true, false, false, reactionMediaType, 4, 0, filepath.Join(dir, "missing")); r != nil { + t.Errorf("reactionOf(missing file) = %q, want nil", *r) + } + if r := h.reactionOf(true, true, true, false, false, reactionMediaType, 4, 0, "/etc/passwd"); r != nil { + t.Errorf("reactionOf(outside data dir) = %q, want nil", *r) + } + if r := h.reactionOf(true, false, true, false, false, reactionMediaType, 4, 0, thumbs); r != nil { + t.Errorf("reactionOf(wrong shape) = %q, want nil", *r) + } +} + +func TestEffectiveReactions(t *testing.T) { + rows := []reactionRow{ + {subjectID: 1, msgID: 10, from: "@bob@example.com", time: 100, emoji: "๐Ÿ‘"}, + {subjectID: 1, msgID: 11, from: "@carol@example.edu", time: 101, emoji: "๐Ÿ‘"}, + {subjectID: 1, msgID: 12, from: "@Bob@example.com", time: 102, emoji: "โค๏ธ"}, // bob changes, case-insensitive + {subjectID: 1, msgID: 13, from: "@dave@example.com", time: 103, emoji: "๐Ÿ‘"}, + {subjectID: 1, msgID: 14, from: "@dave@example.com", time: 104, emoji: ""}, // dave clears + {subjectID: 2, msgID: 20, from: "@bob@example.com", time: 100, emoji: "๐ŸŽ‰"}, + {subjectID: 3, msgID: 30, from: "@bob@example.com", time: 100, emoji: ""}, // only a clear + } + got := effectiveReactions(rows) + want := map[int64][]models.Reaction{ + 1: { + {Emoji: "๐Ÿ‘", From: []string{"@carol@example.edu"}}, + {Emoji: "โค๏ธ", From: []string{"@Bob@example.com"}}, + }, + 2: {{Emoji: "๐ŸŽ‰", From: []string{"@bob@example.com"}}}, + } + if !reflect.DeepEqual(got, want) { + gj, _ := json.Marshal(got) + wj, _ := json.Marshal(want) + t.Errorf("effectiveReactions = %s, want %s", gj, wj) + } +} + +func TestEffectiveReactionsTieBreaksOnHash(t *testing.T) { + rows := []reactionRow{ + {subjectID: 1, msgID: 10, from: "@bob@example.com", time: 100, hash: []byte{0x01}, emoji: "๐Ÿ‘"}, + {subjectID: 1, msgID: 11, from: "@bob@example.com", time: 100, hash: []byte{0x02}, emoji: "โค๏ธ"}, + } + got := effectiveReactions(rows) + if len(got[1]) != 1 || got[1][0].Emoji != "โค๏ธ" { + t.Errorf("tie at equal time should pick the greater hash, got %+v", got[1]) + } + // Order independence. + got = effectiveReactions([]reactionRow{rows[1], rows[0]}) + if len(got[1]) != 1 || got[1][0].Emoji != "โค๏ธ" { + t.Errorf("tie-break must not depend on row order, got %+v", got[1]) + } +} + +func TestReactionRecipients(t *testing.T) { + subject := &models.Message{ + From: "@alice@example.com", + To: []string{"@bob@example.com", "@carol@example.edu"}, + AddTo: []models.AddToBatch{ + {AddToFrom: "@bob@example.com", To: []string{"@dave@example.org", "@Carol@example.edu"}}, + }, + } + got := reactionRecipients(subject, "@BOB@example.com") + want := []string{"@alice@example.com", "@carol@example.edu", "@dave@example.org"} + if !reflect.DeepEqual(got, want) { + t.Errorf("reactionRecipients = %v, want %v", got, want) + } + if got := reactionRecipients(&models.Message{From: "@alice@example.com", To: []string{"@alice@example.com"}}, "@alice@example.com"); len(got) != 0 { + t.Errorf("self-only message should have no recipients, got %v", got) + } +} + +// A reaction arriving as new_msg is routed to its subject as a reaction event. +func TestHubDispatch_ReactionRoutesToSubject(t *testing.T) { + var built []int64 + hub := &Hub{ + buildItem: func(_ context.Context, msgID int64, _ string) (*messageListItem, error) { + built = append(built, msgID) + return &messageListItem{ID: msgID}, nil + }, + reactionSubject: func(_ context.Context, msgID int64) (int64, bool) { + if msgID == 42 { + return 7, true + } + return 0, false + }, + registry: make(map[string]map[*wsClient]struct{}), + } + c := &wsClient{addr: "@bob@example.com", send: make(chan []byte, 4)} + hub.Register(c) + + subject, ok := hub.reactionSubject(context.Background(), 42) + if !ok || subject != 7 { + t.Fatalf("reactionSubject(42) = %d,%v", subject, ok) + } + hub.dispatch(context.Background(), subject, "@bob@example.com", eventReaction) + select { + case frame := <-c.send: + var env struct { + Type string `json:"type"` + Data messageListItem `json:"data"` + } + if err := json.Unmarshal(frame, &env); err != nil { + t.Fatal(err) + } + if env.Type != eventReaction || env.Data.ID != 7 { + t.Errorf("got %s for %d, want %s for 7", env.Type, env.Data.ID, eventReaction) + } + default: + t.Fatal("no frame pushed") + } + if len(built) != 1 || built[0] != 7 { + t.Errorf("built %v, want [7] (the subject, not the reaction)", built) + } +} diff --git a/internal/handlers/thread.go b/internal/handlers/thread.go index 7a164d8..c0b99aa 100644 --- a/internal/handlers/thread.go +++ b/internal/handlers/thread.go @@ -52,6 +52,7 @@ type threadMessage struct { NoReply bool `json:"no_reply,omitempty"` Important bool `json:"important,omitempty"` Deflate bool `json:"deflate,omitempty"` + Terminal bool `json:"terminal,omitempty"` From string `json:"from,omitempty"` To []string `json:"to,omitempty"` AddTo []models.AddToBatch `json:"add_to,omitempty"` @@ -377,18 +378,18 @@ func (h *MessageHandler) ThreadMessages(c *gin.Context) { rows, err := tx.Query(ctx, ` WITH RECURSIVE chain AS ( - SELECT id, version, pid, no_reply, is_important, is_deflate, time_sent, + SELECT id, version, pid, no_reply, is_important, is_deflate, is_terminal, time_sent, from_addr, topic, type, size, filepath, sha256, 0 AS depth FROM msg WHERE id = $1 UNION ALL SELECT m.id, m.version, m.pid, m.no_reply, m.is_important, m.is_deflate, - m.time_sent, m.from_addr, m.topic, m.type, m.size, m.filepath, + m.is_terminal, m.time_sent, m.from_addr, m.topic, m.type, m.size, m.filepath, m.sha256, c.depth + 1 FROM msg m JOIN chain c ON m.id = c.pid WHERE c.depth + 1 < $3 ) SELECT c.id, c.version, c.pid, c.no_reply, c.is_important, c.is_deflate, - c.time_sent, c.from_addr, c.topic, c.type, c.size, c.filepath, + c.is_terminal, c.time_sent, c.from_addr, c.topic, c.type, c.size, c.filepath, encode(c.sha256, 'hex'), (c.from_addr = ANY($2) OR EXISTS (SELECT 1 FROM msg_to t WHERE t.msg_id = c.id AND t.addr = ANY($2)) @@ -404,7 +405,7 @@ func (h *MessageHandler) ThreadMessages(c *gin.Context) { var m threadMessage var hash *string if err = rows.Scan(&m.ID, &m.Version, &m.PID, &m.NoReply, &m.Important, - &m.Deflate, &m.Time, &m.From, &m.Topic, &m.Type, &m.Size, &m.dataPath, + &m.Deflate, &m.Terminal, &m.Time, &m.From, &m.Topic, &m.Type, &m.Size, &m.dataPath, &hash, &m.Visible); err != nil { rows.Close() c.JSON(http.StatusInternalServerError, gin.H{"error": "failed to retrieve thread"}) diff --git a/internal/models/models.go b/internal/models/models.go index defda21..c8f3118 100644 --- a/internal/models/models.go +++ b/internal/models/models.go @@ -33,6 +33,7 @@ type Message struct { Important bool `json:"important"` NoReply bool `json:"no_reply"` Deflate bool `json:"deflate"` + Terminal bool `json:"terminal"` PID *int64 `json:"pid"` From string `json:"from"` To []string `json:"to"` @@ -46,4 +47,13 @@ type Message struct { Read bool `json:"read"` TimeRead *float64 `json:"time_read"` Attachments []Attachment `json:"attachments"` + Reaction *string `json:"reaction"` // FMSG-005: the emoji this message carries when it is a reaction ("" clears); nil otherwise + Reactions []Reaction `json:"reactions"` // FMSG-005: effective reactions on this message +} + +// Reaction is one emoji currently reacted on a message and the participants +// whose effective reaction it is (FMSG-005). +type Reaction struct { + Emoji string `json:"emoji"` + From []string `json:"from"` }