diff --git a/Podfile.lock b/Podfile.lock
index 4a101f497..3ca93e031 100644
--- a/Podfile.lock
+++ b/Podfile.lock
@@ -13,15 +13,18 @@ PODS:
     - DifferenceKit/Core
   - GRDB.swift/SQLCipher (6.13.0):
     - SQLCipher (>= 3.4.2)
-  - libwebp (1.2.1):
-    - libwebp/demux (= 1.2.1)
-    - libwebp/mux (= 1.2.1)
-    - libwebp/webp (= 1.2.1)
-  - libwebp/demux (1.2.1):
+  - libwebp (1.3.2):
+    - libwebp/demux (= 1.3.2)
+    - libwebp/mux (= 1.3.2)
+    - libwebp/sharpyuv (= 1.3.2)
+    - libwebp/webp (= 1.3.2)
+  - libwebp/demux (1.3.2):
     - libwebp/webp
-  - libwebp/mux (1.2.1):
+  - libwebp/mux (1.3.2):
     - libwebp/demux
-  - libwebp/webp (1.2.1)
+  - libwebp/sharpyuv (1.3.2)
+  - libwebp/webp (1.3.2):
+    - libwebp/sharpyuv
   - Nimble (10.0.0)
   - NVActivityIndicatorView (5.1.1):
     - NVActivityIndicatorView/Base (= 5.1.1)
@@ -134,7 +137,6 @@ SPEC REPOS:
     - CocoaLumberjack
     - DifferenceKit
     - GRDB.swift
-    - libwebp
     - Nimble
     - NVActivityIndicatorView
     - OpenSSL-Universal
@@ -146,6 +148,7 @@ SPEC REPOS:
     - SwiftProtobuf
     - WebRTC-lib
   trunk:
+    - libwebp
     - xcbeautify
 
 EXTERNAL SOURCES:
@@ -186,7 +189,7 @@ SPEC CHECKSUMS:
   Curve25519Kit: e63f9859ede02438ae3defc5e1a87e09d1ec7ee6
   DifferenceKit: ab185c4d7f9cef8af3fcf593e5b387fb81e999ca
   GRDB.swift: fe420b1af49ec519c7e96e07887ee44f5dfa2b78
-  libwebp: 98a37e597e40bfdb4c911fc98f2c53d0b12d05fc
+  libwebp: 1786c9f4ff8a279e4dac1e8f385004d5fc253009
   Nimble: 5316ef81a170ce87baf72dd961f22f89a602ff84
   NVActivityIndicatorView: 1f6c5687f1171810aa27a3296814dc2d7dec3667
   OpenSSL-Universal: e7311447fd2419f57420c79524b641537387eff2
diff --git a/Scripts/EmojiGenerator.swift b/Scripts/EmojiGenerator.swift
index 44f906cc1..58e1cda55 100755
--- a/Scripts/EmojiGenerator.swift
+++ b/Scripts/EmojiGenerator.swift
@@ -263,26 +263,43 @@ extension EmojiGenerator {
         }
     }
 
-    static func writeStringConversionsFile(from emojiModel: EmojiModel) {
-        // Inline helpers:
-        var firstItem = true
-        func conditionalCheckForEmojiItem(_ item: EmojiModel.EmojiDefinition.Emoji) -> String {
-            let isFirst = (firstItem == true)
-            firstItem = false
-
-            let prefix = isFirst ? "" : "} else "
-            let suffix = "if rawValue == \"\(item.emojiChar)\" {"
-            return prefix + suffix
-        }
-        func conversionForEmojiItem(_ item: EmojiModel.EmojiDefinition.Emoji, definition: EmojiModel.EmojiDefinition) -> String {
-            let skinToneString: String
-            if item.skintoneSequence.isEmpty {
-                skinToneString = "nil"
-            } else {
-                skinToneString = "[\(item.skintoneSequence.map { ".\($0)" }.joined(separator: ", "))]"
+    indirect enum Structure {
+        enum ChunkType {
+            case firstScalar
+            case scalarSum
+            
+            func chunk(_ character: Character, into size: UInt32) -> UInt32 {
+                guard size > 0 else { return 0 }
+                
+                let scalarValues: [UInt32] = character.unicodeScalars.map { $0.value }
+                
+                switch self {
+                    case .firstScalar: return (scalarValues.first.map { $0 / size } ?? 0)
+                    case .scalarSum: return (scalarValues.reduce(0, +) / size)
+                }
+            }
+            
+            func switchString(with variableName: String = "rawValue") -> String {
+                switch self {
+                    case .firstScalar: return "rawValue.unicodeScalars.map({ $0.value }).first"
+                    case .scalarSum: return "rawValue.unicodeScalars.map({ $0.value }).reduce(0, +)"
+                }
             }
-            return "self.init(baseEmoji: .\(definition.enumName), skinTones: \(skinToneString))"
         }
+        
+        case ifElse                                 // XCode 15 taking over 10 min with M1 Pro (gave up)
+        case switchStatement                        // XCode 15 taking over 10 min with M1 Pro (gave up)
+        case directLookup                           // XCode 15 taking 93 sec with M1 Pro
+        case chunked(UInt32, Structure, ChunkType)  // XCode 15 taking <10 sec with M1 Pro (chunk by 100)
+    }
+    typealias ChunkedEmojiInfo = (
+        variant: EmojiModel.EmojiDefinition.Emoji,
+        baseName: String
+    )
+    
+    static func writeStringConversionsFile(from emojiModel: EmojiModel) {
+        // This combination seems to have the smallest compile time (~2.2 sec out of all of the combinations)
+        let desiredStructure: Structure = .chunked(100, .directLookup, .scalarSum)
 
         // Conversion from String: Creates an initializer mapping a single character emoji string to an EmojiWithSkinTones
         // e.g.
@@ -291,30 +308,131 @@ extension EmojiGenerator {
         writeBlock(fileName: "EmojiWithSkinTones+String.swift") { fileHandle in
             fileHandle.writeLine("extension EmojiWithSkinTones {")
             fileHandle.indent {
-                fileHandle.writeLine("init?(rawValue: String) {")
-                fileHandle.indent {
-                    fileHandle.writeLine("guard rawValue.isSingleEmoji else { return nil }")
-
-                    emojiModel.definitions.forEach { definition in
-                        definition.variants.forEach { emoji in
-                            fileHandle.writeLine(conditionalCheckForEmojiItem(emoji))
-                            fileHandle.indent {
-                                fileHandle.writeLine(conversionForEmojiItem(emoji, definition: definition))
+                switch desiredStructure {
+                    case .chunked(let chunkSize, let childStructure, let chunkType):
+                        let chunkedEmojiInfo = emojiModel.definitions
+                            .reduce(into: [UInt32: [ChunkedEmojiInfo]]()) { result, next in
+                                next.variants.forEach { emoji in
+                                    let chunk: UInt32 = chunkType.chunk(emoji.emojiChar, into: chunkSize)
+                                    result[chunk] = ((result[chunk] ?? []) + [(emoji, next.enumName)])
+                                        .sorted { lhs, rhs in lhs.variant < rhs.variant }
+                                }
                             }
+                            .sorted { lhs, rhs in lhs.key < rhs.key } 
+                        
+                        fileHandle.writeLine("init?(rawValue: String) {")
+                        fileHandle.indent {
+                            fileHandle.writeLine("guard rawValue.isSingleEmoji else { return nil }")
+                            fileHandle.writeLine("switch \(chunkType.switchString()) {")
+                            fileHandle.indent {
+                                chunkedEmojiInfo.forEach { chunk, _ in
+                                    fileHandle.writeLine("case \(chunk): self = EmojiWithSkinTones.emojiFrom\(chunk)(rawValue)")
+                                }
+                                fileHandle.writeLine("default: self = EmojiWithSkinTones(unsupportedValue: rawValue)")
+                            }
+                            fileHandle.writeLine("}")
                         }
-                    }
-
-                    fileHandle.writeLine("} else {")
-                    fileHandle.indent {
-                        fileHandle.writeLine("self.init(unsupportedValue: rawValue)")
-                    }
-                    fileHandle.writeLine("}")
+                        fileHandle.writeLine("}")
+                        
+                        chunkedEmojiInfo.forEach { chunk, emojiInfo in
+                            fileHandle.writeLine("")
+                            fileHandle.writeLine("private static func emojiFrom\(chunk)(_ rawValue: String) -> EmojiWithSkinTones {")
+                            fileHandle.indent {
+                                switch emojiInfo.count {
+                                    case 0:
+                                        fileHandle.writeLine("return EmojiWithSkinTones(unsupportedValue: rawValue)")
+                                        
+                                    default:
+                                        writeStructure(
+                                            childStructure,
+                                            for: emojiInfo,
+                                            using: fileHandle,
+                                            assignmentPrefix: "return "
+                                        )
+                                }
+                            }
+                            
+                            fileHandle.writeLine("}")
+                        }
+                        
+                    default:
+                        fileHandle.writeLine("init?(rawValue: String) {")
+                        fileHandle.indent {
+                            fileHandle.writeLine("guard rawValue.isSingleEmoji else { return nil }")
+                            writeStructure(
+                                desiredStructure,
+                                for: emojiModel.definitions
+                                    .flatMap { definition in
+                                        definition.variants.map { ($0, definition.enumName) }
+                                    },
+                                using: fileHandle
+                            )
+                        }
+                        fileHandle.writeLine("}")
                 }
-                fileHandle.writeLine("}")
             }
             fileHandle.writeLine("}")
         }
     }
+    
+    private static func writeStructure(
+        _ structure: Structure,
+        for emojiInfo: [ChunkedEmojiInfo],
+        using fileHandle: WriteHandle,
+        assignmentPrefix: String = "self = "
+    ) {
+        func initItem(_ info: ChunkedEmojiInfo) -> String {
+            let skinToneString: String = {
+                guard !info.variant.skintoneSequence.isEmpty else { return "nil" }
+                return "[\(info.variant.skintoneSequence.map { ".\($0)" }.joined(separator: ", "))]"
+            }()
+            
+            return "EmojiWithSkinTones(baseEmoji: .\(info.baseName), skinTones: \(skinToneString))"
+        }
+
+        switch structure {
+            case .ifElse:
+                emojiInfo.enumerated().forEach { index, info in
+                    switch index {
+                        case 0: fileHandle.writeLine("if rawValue == \"\(info.variant.emojiChar)\" {")
+                        default: fileHandle.writeLine("} else if rawValue == \"\(info.variant.emojiChar)\" {")
+                    }
+                    
+                    fileHandle.indent {
+                        fileHandle.writeLine("\(assignmentPrefix)\(initItem(info))")
+                    }
+                }
+                
+                fileHandle.writeLine("} else {")
+                fileHandle.indent {
+                    fileHandle.writeLine("\(assignmentPrefix)EmojiWithSkinTones(unsupportedValue: rawValue)")
+                }
+                fileHandle.writeLine("}")
+                
+            case .switchStatement:
+                fileHandle.writeLine("switch rawValue {")
+                fileHandle.indent {
+                    emojiInfo.forEach { info in
+                        fileHandle.writeLine("case \"\(info.variant.emojiChar)\": \(assignmentPrefix)\(initItem(info))")
+                    }
+                    fileHandle.writeLine("default: \(assignmentPrefix)EmojiWithSkinTones(unsupportedValue: rawValue)")
+                }
+                fileHandle.writeLine("}")
+                
+            case .directLookup:
+                fileHandle.writeLine("let lookup: [String: EmojiWithSkinTones] = [")
+                fileHandle.indent {
+                    emojiInfo.enumerated().forEach { index, info in
+                        let isLast: Bool = (index == (emojiInfo.count - 1))
+                        fileHandle.writeLine("\"\(info.variant.emojiChar)\": \(initItem(info))\(isLast ? "" : ",")")
+                    }
+                }
+                fileHandle.writeLine("]")
+                fileHandle.writeLine("\(assignmentPrefix)(lookup[rawValue] ?? EmojiWithSkinTones(unsupportedValue: rawValue))")
+                
+            case .chunked: break // Provide one of the other types
+        }
+    }
 
     static func writeSkinToneLookupFile(from emojiModel: EmojiModel) {
         writeBlock(fileName: "Emoji+SkinTones.swift") { fileHandle in
@@ -514,7 +632,7 @@ extension EmojiGenerator {
                 fileHandle.indent {
                     fileHandle.writeLine("switch self {")
                     emojiModel.definitions.forEach {
-                        fileHandle.writeLine("case .\($0.enumName): return \"\($0.shortNames.joined(separator:", "))\"")
+                        fileHandle.writeLine("case .\($0.enumName): return \"\($0.shortNames.sorted().joined(separator:", "))\"")
                     }
                     fileHandle.writeLine("}")
                 }
diff --git a/Scripts/ProtoWrappers.py b/Scripts/ProtoWrappers.py
index b346d1b1f..23b71451b 100755
--- a/Scripts/ProtoWrappers.py
+++ b/Scripts/ProtoWrappers.py
@@ -572,7 +572,7 @@ public func serializedData() throws -> Data {
             # if self.can_field_be_optional(field):
                 writer.add('guard proto.%s else {' % field.has_accessor_name() )
                 writer.push_indent()
-                writer.add('throw %s.invalidProtobuf(description: "\(logTag) missing required field: %s")' % ( writer.invalid_protobuf_error_name, field.name_swift, ) )   
+                writer.add('throw %s.invalidProtobuf(description: "\(String(describing: logTag)) missing required field: %s")' % ( writer.invalid_protobuf_error_name, field.name_swift, ) )   
                 writer.pop_indent()
                 writer.add('}')
             
diff --git a/Session.xcodeproj/project.pbxproj b/Session.xcodeproj/project.pbxproj
index 48ee04b36..1d057de96 100644
--- a/Session.xcodeproj/project.pbxproj
+++ b/Session.xcodeproj/project.pbxproj
@@ -1924,6 +1924,7 @@
 		FDC438CA27BB7DB100C60D73 /* UpdateMessageRequest.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = UpdateMessageRequest.swift; sourceTree = "<group>"; };
 		FDC438CC27BC641200C60D73 /* Set+Utilities.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = "Set+Utilities.swift"; sourceTree = "<group>"; };
 		FDC6D75F2862B3F600B04575 /* Dependencies.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = Dependencies.swift; sourceTree = "<group>"; };
+		FDCCC6E82ABA7402002BBEF5 /* EmojiGenerator.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = EmojiGenerator.swift; sourceTree = "<group>"; };
 		FDCD2E022A41294E00964D6A /* LegacyGroupOnlyRequest.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = LegacyGroupOnlyRequest.swift; sourceTree = "<group>"; };
 		FDCDB8DD2810F73B00352A0C /* Differentiable+Utilities.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = "Differentiable+Utilities.swift"; sourceTree = "<group>"; };
 		FDCDB8DF2811007F00352A0C /* HomeViewModel.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = HomeViewModel.swift; sourceTree = "<group>"; };
@@ -4315,6 +4316,7 @@
 			isa = PBXGroup;
 			children = (
 				FDE7214F287E50D50093DF33 /* ProtoWrappers.py */,
+				FDCCC6E82ABA7402002BBEF5 /* EmojiGenerator.swift */,
 				FDE72150287E50D50093DF33 /* LintLocalizableStrings.swift */,
 				FD5CE3442A3C5D96001A6DE3 /* DecryptExportedKey.swift */,
 			);
diff --git a/Session/Conversations/Message Cells/Content Views/QuoteView.swift b/Session/Conversations/Message Cells/Content Views/QuoteView.swift
index 141395d1d..176e13560 100644
--- a/Session/Conversations/Message Cells/Content Views/QuoteView.swift	
+++ b/Session/Conversations/Message Cells/Content Views/QuoteView.swift	
@@ -105,7 +105,6 @@ final class QuoteView: UIView {
             availableWidth -= cancelButtonSize
         }
         
-        let availableSpace = CGSize(width: availableWidth, height: .greatestFiniteMagnitude)
         var body: String? = quotedText
         
         // Main stack view
diff --git a/Session/Conversations/Message Cells/Content Views/VoiceMessageView.swift b/Session/Conversations/Message Cells/Content Views/VoiceMessageView.swift
index af2f386f8..5a3531a28 100644
--- a/Session/Conversations/Message Cells/Content Views/VoiceMessageView.swift	
+++ b/Session/Conversations/Message Cells/Content Views/VoiceMessageView.swift	
@@ -112,7 +112,6 @@ public final class VoiceMessageView: UIView {
     }
 
     private func setUpViewHierarchy() {
-        let toggleContainerSize = VoiceMessageView.toggleContainerSize
         let inset = VoiceMessageView.inset
         
         // Width & height
diff --git a/Session/Emoji/Emoji+Category.swift b/Session/Emoji/Emoji+Category.swift
index 3b6b8275b..3ef0a93d3 100644
--- a/Session/Emoji/Emoji+Category.swift
+++ b/Session/Emoji/Emoji+Category.swift
@@ -86,6 +86,7 @@ extension Emoji {
                     .grimacing,
                     .faceExhaling,
                     .lyingFace,
+                    .shakingFace,
                     .relieved,
                     .pensive,
                     .sleepy,
@@ -163,7 +164,6 @@ extension Emoji {
                     .seeNoEvil,
                     .hearNoEvil,
                     .speakNoEvil,
-                    .kiss,
                     .loveLetter,
                     .cupid,
                     .giftHeart,
@@ -178,14 +178,18 @@ extension Emoji {
                     .heartOnFire,
                     .mendingHeart,
                     .heart,
+                    .pinkHeart,
                     .orangeHeart,
                     .yellowHeart,
                     .greenHeart,
                     .blueHeart,
+                    .lightBlueHeart,
                     .purpleHeart,
                     .brownHeart,
                     .blackHeart,
+                    .greyHeart,
                     .whiteHeart,
+                    .kiss,
                     .oneHundred,
                     .anger,
                     .boom,
@@ -193,7 +197,6 @@ extension Emoji {
                     .sweatDrops,
                     .dash,
                     .hole,
-                    .bomb,
                     .speechBalloon,
                     .eyeInSpeechBubble,
                     .leftSpeechBubble,
@@ -209,6 +212,8 @@ extension Emoji {
                     .leftwardsHand,
                     .palmDownHand,
                     .palmUpHand,
+                    .leftwardsPushingHand,
+                    .rightwardsPushingHand,
                     .okHand,
                     .pinchedFingers,
                     .pinchingHand,
@@ -584,6 +589,8 @@ extension Emoji {
                     .tiger2,
                     .leopard,
                     .horse,
+                    .moose,
+                    .donkey,
                     .racehorse,
                     .unicornFace,
                     .zebraFace,
@@ -646,6 +653,9 @@ extension Emoji {
                     .flamingo,
                     .peacock,
                     .parrot,
+                    .wing,
+                    .blackBird,
+                    .goose,
                     .frog,
                     .crocodile,
                     .turtle,
@@ -666,6 +676,7 @@ extension Emoji {
                     .octopus,
                     .shell,
                     .coral,
+                    .jellyfish,
                     .snail,
                     .butterfly,
                     .bug,
@@ -693,6 +704,7 @@ extension Emoji {
                     .sunflower,
                     .blossom,
                     .tulip,
+                    .hyacinth,
                     .seedling,
                     .pottedPlant,
                     .evergreenTree,
@@ -708,6 +720,7 @@ extension Emoji {
                     .leaves,
                     .emptyNest,
                     .nestWithEggs,
+                    .mushroom,
                 ]
             case .food:
                 return [
@@ -742,10 +755,11 @@ extension Emoji {
                     .broccoli,
                     .garlic,
                     .onion,
-                    .mushroom,
                     .peanuts,
                     .beans,
                     .chestnut,
+                    .gingerRoot,
+                    .peaPod,
                     .bread,
                     .croissant,
                     .baguetteBread,
@@ -903,11 +917,10 @@ extension Emoji {
                     .dart,
                     .yoYo,
                     .kite,
+                    .gun,
                     .eightBall,
                     .crystalBall,
                     .magicWand,
-                    .nazarAmulet,
-                    .hamsa,
                     .videoGame,
                     .joystick,
                     .slotMachine,
@@ -1176,6 +1189,7 @@ extension Emoji {
                     .shorts,
                     .bikini,
                     .womansClothes,
+                    .foldingHandFan,
                     .purse,
                     .handbag,
                     .pouch,
@@ -1190,6 +1204,7 @@ extension Emoji {
                     .sandal,
                     .balletShoes,
                     .boot,
+                    .hairPick,
                     .crown,
                     .womansHat,
                     .tophat,
@@ -1228,6 +1243,8 @@ extension Emoji {
                     .banjo,
                     .drumWithDrumsticks,
                     .longDrum,
+                    .maracas,
+                    .flute,
                     .iphone,
                     .calling,
                     .phone,
@@ -1347,7 +1364,7 @@ extension Emoji {
                     .hammerAndWrench,
                     .daggerKnife,
                     .crossedSwords,
-                    .gun,
+                    .bomb,
                     .boomerang,
                     .bowAndArrow,
                     .shield,
@@ -1408,6 +1425,8 @@ extension Emoji {
                     .coffin,
                     .headstone,
                     .funeralUrn,
+                    .nazarAmulet,
+                    .hamsa,
                     .moyai,
                     .placard,
                     .identificationCard,
@@ -1473,6 +1492,7 @@ extension Emoji {
                     .peaceSymbol,
                     .menorahWithNineBranches,
                     .sixPointedStar,
+                    .khanda,
                     .aries,
                     .taurus,
                     .gemini,
@@ -1508,6 +1528,7 @@ extension Emoji {
                     .lowBrightness,
                     .highBrightness,
                     .signalStrength,
+                    .wireless,
                     .vibrationMode,
                     .mobilePhoneOff,
                     .femaleSign,
@@ -1962,6 +1983,7 @@ extension Emoji {
         case .grimacing: return .smileysAndPeople
         case .faceExhaling: return .smileysAndPeople
         case .lyingFace: return .smileysAndPeople
+        case .shakingFace: return .smileysAndPeople
         case .relieved: return .smileysAndPeople
         case .pensive: return .smileysAndPeople
         case .sleepy: return .smileysAndPeople
@@ -2039,7 +2061,6 @@ extension Emoji {
         case .seeNoEvil: return .smileysAndPeople
         case .hearNoEvil: return .smileysAndPeople
         case .speakNoEvil: return .smileysAndPeople
-        case .kiss: return .smileysAndPeople
         case .loveLetter: return .smileysAndPeople
         case .cupid: return .smileysAndPeople
         case .giftHeart: return .smileysAndPeople
@@ -2054,14 +2075,18 @@ extension Emoji {
         case .heartOnFire: return .smileysAndPeople
         case .mendingHeart: return .smileysAndPeople
         case .heart: return .smileysAndPeople
+        case .pinkHeart: return .smileysAndPeople
         case .orangeHeart: return .smileysAndPeople
         case .yellowHeart: return .smileysAndPeople
         case .greenHeart: return .smileysAndPeople
         case .blueHeart: return .smileysAndPeople
+        case .lightBlueHeart: return .smileysAndPeople
         case .purpleHeart: return .smileysAndPeople
         case .brownHeart: return .smileysAndPeople
         case .blackHeart: return .smileysAndPeople
+        case .greyHeart: return .smileysAndPeople
         case .whiteHeart: return .smileysAndPeople
+        case .kiss: return .smileysAndPeople
         case .oneHundred: return .smileysAndPeople
         case .anger: return .smileysAndPeople
         case .boom: return .smileysAndPeople
@@ -2069,7 +2094,6 @@ extension Emoji {
         case .sweatDrops: return .smileysAndPeople
         case .dash: return .smileysAndPeople
         case .hole: return .smileysAndPeople
-        case .bomb: return .smileysAndPeople
         case .speechBalloon: return .smileysAndPeople
         case .eyeInSpeechBubble: return .smileysAndPeople
         case .leftSpeechBubble: return .smileysAndPeople
@@ -2085,6 +2109,8 @@ extension Emoji {
         case .leftwardsHand: return .smileysAndPeople
         case .palmDownHand: return .smileysAndPeople
         case .palmUpHand: return .smileysAndPeople
+        case .leftwardsPushingHand: return .smileysAndPeople
+        case .rightwardsPushingHand: return .smileysAndPeople
         case .okHand: return .smileysAndPeople
         case .pinchedFingers: return .smileysAndPeople
         case .pinchingHand: return .smileysAndPeople
@@ -2457,6 +2483,8 @@ extension Emoji {
         case .tiger2: return .animals
         case .leopard: return .animals
         case .horse: return .animals
+        case .moose: return .animals
+        case .donkey: return .animals
         case .racehorse: return .animals
         case .unicornFace: return .animals
         case .zebraFace: return .animals
@@ -2519,6 +2547,9 @@ extension Emoji {
         case .flamingo: return .animals
         case .peacock: return .animals
         case .parrot: return .animals
+        case .wing: return .animals
+        case .blackBird: return .animals
+        case .goose: return .animals
         case .frog: return .animals
         case .crocodile: return .animals
         case .turtle: return .animals
@@ -2539,6 +2570,7 @@ extension Emoji {
         case .octopus: return .animals
         case .shell: return .animals
         case .coral: return .animals
+        case .jellyfish: return .animals
         case .snail: return .animals
         case .butterfly: return .animals
         case .bug: return .animals
@@ -2566,6 +2598,7 @@ extension Emoji {
         case .sunflower: return .animals
         case .blossom: return .animals
         case .tulip: return .animals
+        case .hyacinth: return .animals
         case .seedling: return .animals
         case .pottedPlant: return .animals
         case .evergreenTree: return .animals
@@ -2581,6 +2614,7 @@ extension Emoji {
         case .leaves: return .animals
         case .emptyNest: return .animals
         case .nestWithEggs: return .animals
+        case .mushroom: return .animals
         case .grapes: return .food
         case .melon: return .food
         case .watermelon: return .food
@@ -2612,10 +2646,11 @@ extension Emoji {
         case .broccoli: return .food
         case .garlic: return .food
         case .onion: return .food
-        case .mushroom: return .food
         case .peanuts: return .food
         case .beans: return .food
         case .chestnut: return .food
+        case .gingerRoot: return .food
+        case .peaPod: return .food
         case .bread: return .food
         case .croissant: return .food
         case .baguetteBread: return .food
@@ -2988,11 +3023,10 @@ extension Emoji {
         case .dart: return .activities
         case .yoYo: return .activities
         case .kite: return .activities
+        case .gun: return .activities
         case .eightBall: return .activities
         case .crystalBall: return .activities
         case .magicWand: return .activities
-        case .nazarAmulet: return .activities
-        case .hamsa: return .activities
         case .videoGame: return .activities
         case .joystick: return .activities
         case .slotMachine: return .activities
@@ -3037,6 +3071,7 @@ extension Emoji {
         case .shorts: return .objects
         case .bikini: return .objects
         case .womansClothes: return .objects
+        case .foldingHandFan: return .objects
         case .purse: return .objects
         case .handbag: return .objects
         case .pouch: return .objects
@@ -3051,6 +3086,7 @@ extension Emoji {
         case .sandal: return .objects
         case .balletShoes: return .objects
         case .boot: return .objects
+        case .hairPick: return .objects
         case .crown: return .objects
         case .womansHat: return .objects
         case .tophat: return .objects
@@ -3089,6 +3125,8 @@ extension Emoji {
         case .banjo: return .objects
         case .drumWithDrumsticks: return .objects
         case .longDrum: return .objects
+        case .maracas: return .objects
+        case .flute: return .objects
         case .iphone: return .objects
         case .calling: return .objects
         case .phone: return .objects
@@ -3208,7 +3246,7 @@ extension Emoji {
         case .hammerAndWrench: return .objects
         case .daggerKnife: return .objects
         case .crossedSwords: return .objects
-        case .gun: return .objects
+        case .bomb: return .objects
         case .boomerang: return .objects
         case .bowAndArrow: return .objects
         case .shield: return .objects
@@ -3269,6 +3307,8 @@ extension Emoji {
         case .coffin: return .objects
         case .headstone: return .objects
         case .funeralUrn: return .objects
+        case .nazarAmulet: return .objects
+        case .hamsa: return .objects
         case .moyai: return .objects
         case .placard: return .objects
         case .identificationCard: return .objects
@@ -3331,6 +3371,7 @@ extension Emoji {
         case .peaceSymbol: return .symbols
         case .menorahWithNineBranches: return .symbols
         case .sixPointedStar: return .symbols
+        case .khanda: return .symbols
         case .aries: return .symbols
         case .taurus: return .symbols
         case .gemini: return .symbols
@@ -3366,6 +3407,7 @@ extension Emoji {
         case .lowBrightness: return .symbols
         case .highBrightness: return .symbols
         case .signalStrength: return .symbols
+        case .wireless: return .symbols
         case .vibrationMode: return .symbols
         case .mobilePhoneOff: return .symbols
         case .femaleSign: return .symbols
diff --git a/Session/Emoji/Emoji+Name.swift b/Session/Emoji/Emoji+Name.swift
index 6acfa85e2..123bac051 100644
--- a/Session/Emoji/Emoji+Name.swift
+++ b/Session/Emoji/Emoji+Name.swift
@@ -8,213 +8,218 @@ extension Emoji {
         case .smiley: return "smiley, smiling face with open mouth"
         case .smile: return "smile, smiling face with open mouth and smiling eyes"
         case .grin: return "grin, grinning face with smiling eyes"
-        case .laughing: return "smiling face with open mouth and tightly-closed eyes, laughing, satisfied"
-        case .sweatSmile: return "sweatsmile, sweat_smile, smiling face with open mouth and cold sweat"
-        case .rollingOnTheFloorLaughing: return "rolling_on_the_floor_laughing, rollingonthefloorlaughing, rolling on the floor laughing"
-        case .joy: return "joy, face with tears of joy"
-        case .slightlySmilingFace: return "slightly smiling face, slightlysmilingface, slightly_smiling_face"
-        case .upsideDownFace: return "upsidedownface, upside_down_face, upside-down face"
-        case .meltingFace: return "meltingface, melting_face, melting face"
+        case .laughing: return "laughing, satisfied, smiling face with open mouth and tightly-closed eyes"
+        case .sweatSmile: return "smiling face with open mouth and cold sweat, sweat_smile, sweatsmile"
+        case .rollingOnTheFloorLaughing: return "rolling on the floor laughing, rolling_on_the_floor_laughing, rollingonthefloorlaughing"
+        case .joy: return "face with tears of joy, joy"
+        case .slightlySmilingFace: return "slightly smiling face, slightly_smiling_face, slightlysmilingface"
+        case .upsideDownFace: return "upside-down face, upside_down_face, upsidedownface"
+        case .meltingFace: return "melting face, melting_face, meltingface"
         case .wink: return "wink, winking face"
         case .blush: return "blush, smiling face with smiling eyes"
         case .innocent: return "innocent, smiling face with halo"
         case .smilingFaceWith3Hearts: return "smiling face with smiling eyes and three hearts, smiling_face_with_3_hearts, smilingfacewith3hearts"
-        case .heartEyes: return "smiling face with heart-shaped eyes, hearteyes, heart_eyes"
-        case .starStruck: return "starstruck, grinning_face_with_star_eyes, star-struck, grinning face with star eyes"
-        case .kissingHeart: return "kissing_heart, face throwing a kiss, kissingheart"
-        case .kissing: return "kissing face, kissing"
-        case .relaxed: return "white smiling face, relaxed"
-        case .kissingClosedEyes: return "kissing_closed_eyes, kissing face with closed eyes, kissingclosedeyes"
+        case .heartEyes: return "heart_eyes, hearteyes, smiling face with heart-shaped eyes"
+        case .starStruck: return "grinning face with star eyes, grinning_face_with_star_eyes, star-struck, starstruck"
+        case .kissingHeart: return "face throwing a kiss, kissing_heart, kissingheart"
+        case .kissing: return "kissing, kissing face"
+        case .relaxed: return "relaxed, white smiling face"
+        case .kissingClosedEyes: return "kissing face with closed eyes, kissing_closed_eyes, kissingclosedeyes"
         case .kissingSmilingEyes: return "kissing face with smiling eyes, kissing_smiling_eyes, kissingsmilingeyes"
-        case .smilingFaceWithTear: return "smilingfacewithtear, smiling face with tear, smiling_face_with_tear"
-        case .yum: return "yum, face savouring delicious food"
-        case .stuckOutTongue: return "stuck_out_tongue, face with stuck-out tongue, stuckouttongue"
-        case .stuckOutTongueWinkingEye: return "stuckouttonguewinkingeye, stuck_out_tongue_winking_eye, face with stuck-out tongue and winking eye"
-        case .zanyFace: return "grinning_face_with_one_large_and_one_small_eye, zany_face, grinning face with one large and one small eye, zanyface"
-        case .stuckOutTongueClosedEyes: return "stuckouttongueclosedeyes, stuck_out_tongue_closed_eyes, face with stuck-out tongue and tightly-closed eyes"
-        case .moneyMouthFace: return "moneymouthface, money_mouth_face, money-mouth face"
-        case .huggingFace: return "huggingface, hugging_face, hugging face"
-        case .faceWithHandOverMouth: return "face_with_hand_over_mouth, smiling face with smiling eyes and hand covering mouth, smiling_face_with_smiling_eyes_and_hand_covering_mouth, facewithhandovermouth"
-        case .faceWithOpenEyesAndHandOverMouth: return "face with open eyes and hand over mouth, facewithopeneyesandhandovermouth, face_with_open_eyes_and_hand_over_mouth"
-        case .faceWithPeekingEye: return "face_with_peeking_eye, face with peeking eye, facewithpeekingeye"
-        case .shushingFace: return "shushing_face, face_with_finger_covering_closed_lips, shushingface, face with finger covering closed lips"
-        case .thinkingFace: return "thinkingface, thinking face, thinking_face"
-        case .salutingFace: return "saluting_face, saluting face, salutingface"
-        case .zipperMouthFace: return "zippermouthface, zipper-mouth face, zipper_mouth_face"
+        case .smilingFaceWithTear: return "smiling face with tear, smiling_face_with_tear, smilingfacewithtear"
+        case .yum: return "face savouring delicious food, yum"
+        case .stuckOutTongue: return "face with stuck-out tongue, stuck_out_tongue, stuckouttongue"
+        case .stuckOutTongueWinkingEye: return "face with stuck-out tongue and winking eye, stuck_out_tongue_winking_eye, stuckouttonguewinkingeye"
+        case .zanyFace: return "grinning face with one large and one small eye, grinning_face_with_one_large_and_one_small_eye, zany_face, zanyface"
+        case .stuckOutTongueClosedEyes: return "face with stuck-out tongue and tightly-closed eyes, stuck_out_tongue_closed_eyes, stuckouttongueclosedeyes"
+        case .moneyMouthFace: return "money-mouth face, money_mouth_face, moneymouthface"
+        case .huggingFace: return "hugging face, hugging_face, huggingface"
+        case .faceWithHandOverMouth: return "face_with_hand_over_mouth, facewithhandovermouth, smiling face with smiling eyes and hand covering mouth, smiling_face_with_smiling_eyes_and_hand_covering_mouth"
+        case .faceWithOpenEyesAndHandOverMouth: return "face with open eyes and hand over mouth, face_with_open_eyes_and_hand_over_mouth, facewithopeneyesandhandovermouth"
+        case .faceWithPeekingEye: return "face with peeking eye, face_with_peeking_eye, facewithpeekingeye"
+        case .shushingFace: return "face with finger covering closed lips, face_with_finger_covering_closed_lips, shushing_face, shushingface"
+        case .thinkingFace: return "thinking face, thinking_face, thinkingface"
+        case .salutingFace: return "saluting face, saluting_face, salutingface"
+        case .zipperMouthFace: return "zipper-mouth face, zipper_mouth_face, zippermouthface"
         case .faceWithRaisedEyebrow: return "face with one eyebrow raised, face_with_one_eyebrow_raised, face_with_raised_eyebrow, facewithraisedeyebrow"
-        case .neutralFace: return "neutralface, neutral_face, neutral face"
+        case .neutralFace: return "neutral face, neutral_face, neutralface"
         case .expressionless: return "expressionless, expressionless face"
-        case .noMouth: return "no_mouth, face without mouth, nomouth"
-        case .dottedLineFace: return "dotted_line_face, dotted line face, dottedlineface"
+        case .noMouth: return "face without mouth, no_mouth, nomouth"
+        case .dottedLineFace: return "dotted line face, dotted_line_face, dottedlineface"
         case .faceInClouds: return "face in clouds, face_in_clouds, faceinclouds"
         case .smirk: return "smirk, smirking face"
-        case .unamused: return "unamused face, unamused"
-        case .faceWithRollingEyes: return "face_with_rolling_eyes, face with rolling eyes, facewithrollingeyes"
+        case .unamused: return "unamused, unamused face"
+        case .faceWithRollingEyes: return "face with rolling eyes, face_with_rolling_eyes, facewithrollingeyes"
         case .grimacing: return "grimacing, grimacing face"
-        case .faceExhaling: return "face_exhaling, face exhaling, faceexhaling"
-        case .lyingFace: return "lying_face, lying face, lyingface"
+        case .faceExhaling: return "face exhaling, face_exhaling, faceexhaling"
+        case .lyingFace: return "lying face, lying_face, lyingface"
+        case .shakingFace: return "shaking face, shaking_face, shakingface"
         case .relieved: return "relieved, relieved face"
-        case .pensive: return "pensive face, pensive"
+        case .pensive: return "pensive, pensive face"
         case .sleepy: return "sleepy, sleepy face"
-        case .droolingFace: return "drooling_face, drooling face, droolingface"
+        case .droolingFace: return "drooling face, drooling_face, droolingface"
         case .sleeping: return "sleeping, sleeping face"
         case .mask: return "face with medical mask, mask"
         case .faceWithThermometer: return "face with thermometer, face_with_thermometer, facewiththermometer"
         case .faceWithHeadBandage: return "face with head-bandage, face_with_head_bandage, facewithheadbandage"
-        case .nauseatedFace: return "nauseatedface, nauseated face, nauseated_face"
-        case .faceVomiting: return "face_with_open_mouth_vomiting, face_vomiting, facevomiting, face with open mouth vomiting"
-        case .sneezingFace: return "sneezingface, sneezing face, sneezing_face"
-        case .hotFace: return "hot_face, overheated face, hotface"
-        case .coldFace: return "freezing face, cold_face, coldface"
-        case .woozyFace: return "woozy_face, face with uneven eyes and wavy mouth, woozyface"
-        case .dizzyFace: return "dizzy_face, dizzy face, dizzyface"
-        case .faceWithSpiralEyes: return "face with spiral eyes, facewithspiraleyes, face_with_spiral_eyes"
-        case .explodingHead: return "shocked_face_with_exploding_head, explodinghead, shocked face with exploding head, exploding_head"
-        case .faceWithCowboyHat: return "face_with_cowboy_hat, face with cowboy hat, facewithcowboyhat"
-        case .partyingFace: return "partyingface, partying_face, face with party horn and party hat"
-        case .disguisedFace: return "disguised_face, disguisedface, disguised face"
-        case .sunglasses: return "sunglasses, smiling face with sunglasses"
+        case .nauseatedFace: return "nauseated face, nauseated_face, nauseatedface"
+        case .faceVomiting: return "face with open mouth vomiting, face_vomiting, face_with_open_mouth_vomiting, facevomiting"
+        case .sneezingFace: return "sneezing face, sneezing_face, sneezingface"
+        case .hotFace: return "hot_face, hotface, overheated face"
+        case .coldFace: return "cold_face, coldface, freezing face"
+        case .woozyFace: return "face with uneven eyes and wavy mouth, woozy_face, woozyface"
+        case .dizzyFace: return "dizzy face, dizzy_face, dizzyface"
+        case .faceWithSpiralEyes: return "face with spiral eyes, face_with_spiral_eyes, facewithspiraleyes"
+        case .explodingHead: return "exploding_head, explodinghead, shocked face with exploding head, shocked_face_with_exploding_head"
+        case .faceWithCowboyHat: return "face with cowboy hat, face_with_cowboy_hat, facewithcowboyhat"
+        case .partyingFace: return "face with party horn and party hat, partying_face, partyingface"
+        case .disguisedFace: return "disguised face, disguised_face, disguisedface"
+        case .sunglasses: return "smiling face with sunglasses, sunglasses"
         case .nerdFace: return "nerd face, nerd_face, nerdface"
-        case .faceWithMonocle: return "face_with_monocle, face with monocle, facewithmonocle"
-        case .confused: return "confused face, confused"
-        case .faceWithDiagonalMouth: return "face with diagonal mouth, facewithdiagonalmouth, face_with_diagonal_mouth"
+        case .faceWithMonocle: return "face with monocle, face_with_monocle, facewithmonocle"
+        case .confused: return "confused, confused face"
+        case .faceWithDiagonalMouth: return "face with diagonal mouth, face_with_diagonal_mouth, facewithdiagonalmouth"
         case .worried: return "worried, worried face"
-        case .slightlyFrowningFace: return "slightly_frowning_face, slightlyfrowningface, slightly frowning face"
-        case .whiteFrowningFace: return "whitefrowningface, white_frowning_face, frowning face"
+        case .slightlyFrowningFace: return "slightly frowning face, slightly_frowning_face, slightlyfrowningface"
+        case .whiteFrowningFace: return "frowning face, white_frowning_face, whitefrowningface"
         case .openMouth: return "face with open mouth, open_mouth, openmouth"
-        case .hushed: return "hushed face, hushed"
-        case .astonished: return "astonished face, astonished"
+        case .hushed: return "hushed, hushed face"
+        case .astonished: return "astonished, astonished face"
         case .flushed: return "flushed, flushed face"
         case .pleadingFace: return "face with pleading eyes, pleading_face, pleadingface"
-        case .faceHoldingBackTears: return "faceholdingbacktears, face_holding_back_tears, face holding back tears"
-        case .frowning: return "frowning face with open mouth, frowning"
+        case .faceHoldingBackTears: return "face holding back tears, face_holding_back_tears, faceholdingbacktears"
+        case .frowning: return "frowning, frowning face with open mouth"
         case .anguished: return "anguished, anguished face"
         case .fearful: return "fearful, fearful face"
-        case .coldSweat: return "coldsweat, cold_sweat, face with open mouth and cold sweat"
-        case .disappointedRelieved: return "disappointed but relieved face, disappointedrelieved, disappointed_relieved"
-        case .cry: return "crying face, cry"
-        case .sob: return "sob, loudly crying face"
+        case .coldSweat: return "cold_sweat, coldsweat, face with open mouth and cold sweat"
+        case .disappointedRelieved: return "disappointed but relieved face, disappointed_relieved, disappointedrelieved"
+        case .cry: return "cry, crying face"
+        case .sob: return "loudly crying face, sob"
         case .scream: return "face screaming in fear, scream"
         case .confounded: return "confounded, confounded face"
         case .persevere: return "persevere, persevering face"
         case .disappointed: return "disappointed, disappointed face"
-        case .sweat: return "sweat, face with cold sweat"
+        case .sweat: return "face with cold sweat, sweat"
         case .weary: return "weary, weary face"
         case .tiredFace: return "tired face, tired_face, tiredface"
-        case .yawningFace: return "yawningface, yawning face, yawning_face"
+        case .yawningFace: return "yawning face, yawning_face, yawningface"
         case .triumph: return "face with look of triumph, triumph"
-        case .rage: return "rage, pouting face"
+        case .rage: return "pouting face, rage"
         case .angry: return "angry, angry face"
-        case .faceWithSymbolsOnMouth: return "serious_face_with_symbols_covering_mouth, serious face with symbols covering mouth, face_with_symbols_on_mouth, facewithsymbolsonmouth"
-        case .smilingImp: return "smilingimp, smiling face with horns, smiling_imp"
+        case .faceWithSymbolsOnMouth: return "face_with_symbols_on_mouth, facewithsymbolsonmouth, serious face with symbols covering mouth, serious_face_with_symbols_covering_mouth"
+        case .smilingImp: return "smiling face with horns, smiling_imp, smilingimp"
         case .imp: return "imp"
         case .skull: return "skull"
         case .skullAndCrossbones: return "skull and crossbones, skull_and_crossbones, skullandcrossbones"
-        case .hankey: return "pile of poo, shit, poop, hankey"
+        case .hankey: return "hankey, pile of poo, poop, shit"
         case .clownFace: return "clown face, clown_face, clownface"
-        case .japaneseOgre: return "japanese_ogre, japaneseogre, japanese ogre"
+        case .japaneseOgre: return "japanese ogre, japanese_ogre, japaneseogre"
         case .japaneseGoblin: return "japanese goblin, japanese_goblin, japanesegoblin"
         case .ghost: return "ghost"
         case .alien: return "alien, extraterrestrial alien"
-        case .spaceInvader: return "spaceinvader, alien monster, space_invader"
-        case .robotFace: return "robot_face, robot face, robotface"
+        case .spaceInvader: return "alien monster, space_invader, spaceinvader"
+        case .robotFace: return "robot face, robot_face, robotface"
         case .smileyCat: return "smiley_cat, smileycat, smiling cat face with open mouth"
-        case .smileCat: return "smilecat, grinning cat face with smiling eyes, smile_cat"
-        case .joyCat: return "joy_cat, joycat, cat face with tears of joy"
-        case .heartEyesCat: return "heart_eyes_cat, smiling cat face with heart-shaped eyes, hearteyescat"
-        case .smirkCat: return "smirk_cat, cat face with wry smile, smirkcat"
+        case .smileCat: return "grinning cat face with smiling eyes, smile_cat, smilecat"
+        case .joyCat: return "cat face with tears of joy, joy_cat, joycat"
+        case .heartEyesCat: return "heart_eyes_cat, hearteyescat, smiling cat face with heart-shaped eyes"
+        case .smirkCat: return "cat face with wry smile, smirk_cat, smirkcat"
         case .kissingCat: return "kissing cat face with closed eyes, kissing_cat, kissingcat"
-        case .screamCat: return "scream_cat, weary cat face, screamcat"
+        case .screamCat: return "scream_cat, screamcat, weary cat face"
         case .cryingCatFace: return "crying cat face, crying_cat_face, cryingcatface"
-        case .poutingCat: return "pouting_cat, poutingcat, pouting cat face"
-        case .seeNoEvil: return "see_no_evil, see-no-evil monkey, seenoevil"
-        case .hearNoEvil: return "hearnoevil, hear-no-evil monkey, hear_no_evil"
-        case .speakNoEvil: return "speak_no_evil, speaknoevil, speak-no-evil monkey"
-        case .kiss: return "kiss mark, kiss"
-        case .loveLetter: return "love letter, loveletter, love_letter"
-        case .cupid: return "heart with arrow, cupid"
-        case .giftHeart: return "heart with ribbon, gift_heart, giftheart"
-        case .sparklingHeart: return "sparklingheart, sparkling_heart, sparkling heart"
+        case .poutingCat: return "pouting cat face, pouting_cat, poutingcat"
+        case .seeNoEvil: return "see-no-evil monkey, see_no_evil, seenoevil"
+        case .hearNoEvil: return "hear-no-evil monkey, hear_no_evil, hearnoevil"
+        case .speakNoEvil: return "speak-no-evil monkey, speak_no_evil, speaknoevil"
+        case .loveLetter: return "love letter, love_letter, loveletter"
+        case .cupid: return "cupid, heart with arrow"
+        case .giftHeart: return "gift_heart, giftheart, heart with ribbon"
+        case .sparklingHeart: return "sparkling heart, sparkling_heart, sparklingheart"
         case .heartpulse: return "growing heart, heartpulse"
-        case .heartbeat: return "heartbeat, beating heart"
-        case .revolvingHearts: return "revolving hearts, revolvinghearts, revolving_hearts"
-        case .twoHearts: return "two hearts, twohearts, two_hearts"
-        case .heartDecoration: return "heart_decoration, heart decoration, heartdecoration"
-        case .heavyHeartExclamationMarkOrnament: return "heavy_heart_exclamation_mark_ornament, heart exclamation, heavyheartexclamationmarkornament"
-        case .brokenHeart: return "brokenheart, broken heart, broken_heart"
-        case .heartOnFire: return "heartonfire, heart on fire, heart_on_fire"
-        case .mendingHeart: return "mending_heart, mending heart, mendingheart"
-        case .heart: return "heavy black heart, heart"
-        case .orangeHeart: return "orange_heart, orangeheart, orange heart"
-        case .yellowHeart: return "yellow_heart, yellow heart, yellowheart"
-        case .greenHeart: return "greenheart, green heart, green_heart"
-        case .blueHeart: return "blue heart, blueheart, blue_heart"
-        case .purpleHeart: return "purpleheart, purple_heart, purple heart"
-        case .brownHeart: return "brown_heart, brownheart, brown heart"
-        case .blackHeart: return "blackheart, black_heart, black heart"
-        case .whiteHeart: return "white heart, whiteheart, white_heart"
-        case .oneHundred: return "hundred points symbol, 100, onehundred"
-        case .anger: return "anger symbol, anger"
-        case .boom: return "collision, boom, collision symbol"
+        case .heartbeat: return "beating heart, heartbeat"
+        case .revolvingHearts: return "revolving hearts, revolving_hearts, revolvinghearts"
+        case .twoHearts: return "two hearts, two_hearts, twohearts"
+        case .heartDecoration: return "heart decoration, heart_decoration, heartdecoration"
+        case .heavyHeartExclamationMarkOrnament: return "heart exclamation, heavy_heart_exclamation_mark_ornament, heavyheartexclamationmarkornament"
+        case .brokenHeart: return "broken heart, broken_heart, brokenheart"
+        case .heartOnFire: return "heart on fire, heart_on_fire, heartonfire"
+        case .mendingHeart: return "mending heart, mending_heart, mendingheart"
+        case .heart: return "heart, heavy black heart"
+        case .pinkHeart: return "pink heart, pink_heart, pinkheart"
+        case .orangeHeart: return "orange heart, orange_heart, orangeheart"
+        case .yellowHeart: return "yellow heart, yellow_heart, yellowheart"
+        case .greenHeart: return "green heart, green_heart, greenheart"
+        case .blueHeart: return "blue heart, blue_heart, blueheart"
+        case .lightBlueHeart: return "light blue heart, light_blue_heart, lightblueheart"
+        case .purpleHeart: return "purple heart, purple_heart, purpleheart"
+        case .brownHeart: return "brown heart, brown_heart, brownheart"
+        case .blackHeart: return "black heart, black_heart, blackheart"
+        case .greyHeart: return "grey heart, grey_heart, greyheart"
+        case .whiteHeart: return "white heart, white_heart, whiteheart"
+        case .kiss: return "kiss, kiss mark"
+        case .oneHundred: return "100, hundred points symbol, onehundred"
+        case .anger: return "anger, anger symbol"
+        case .boom: return "boom, collision, collision symbol"
         case .dizzy: return "dizzy, dizzy symbol"
-        case .sweatDrops: return "splashing sweat symbol, sweatdrops, sweat_drops"
-        case .dash: return "dash symbol, dash"
+        case .sweatDrops: return "splashing sweat symbol, sweat_drops, sweatdrops"
+        case .dash: return "dash, dash symbol"
         case .hole: return "hole"
-        case .bomb: return "bomb"
-        case .speechBalloon: return "speech_balloon, speech balloon, speechballoon"
-        case .eyeInSpeechBubble: return "eyeinspeechbubble, eye-in-speech-bubble, eye in speech bubble"
-        case .leftSpeechBubble: return "left_speech_bubble, left speech bubble, leftspeechbubble"
-        case .rightAngerBubble: return "right anger bubble, rightangerbubble, right_anger_bubble"
-        case .thoughtBalloon: return "thought_balloon, thoughtballoon, thought balloon"
-        case .zzz: return "zzz, sleeping symbol"
-        case .wave: return "waving hand sign, wave"
-        case .raisedBackOfHand: return "raised_back_of_hand, raised back of hand, raisedbackofhand"
-        case .raisedHandWithFingersSplayed: return "raisedhandwithfingerssplayed, hand with fingers splayed, raised_hand_with_fingers_splayed"
-        case .hand: return "raised_hand, raised hand, hand"
-        case .spockHand: return "raised hand with part between middle and ring fingers, spockhand, spock-hand"
-        case .rightwardsHand: return "rightwardshand, rightwards hand, rightwards_hand"
-        case .leftwardsHand: return "leftwards hand, leftwardshand, leftwards_hand"
-        case .palmDownHand: return "palmdownhand, palm_down_hand, palm down hand"
-        case .palmUpHand: return "palmuphand, palm_up_hand, palm up hand"
-        case .okHand: return "ok hand sign, okhand, ok_hand"
-        case .pinchedFingers: return "pinched_fingers, pinchedfingers, pinched fingers"
-        case .pinchingHand: return "pinching hand, pinchinghand, pinching_hand"
+        case .speechBalloon: return "speech balloon, speech_balloon, speechballoon"
+        case .eyeInSpeechBubble: return "eye in speech bubble, eye-in-speech-bubble, eyeinspeechbubble"
+        case .leftSpeechBubble: return "left speech bubble, left_speech_bubble, leftspeechbubble"
+        case .rightAngerBubble: return "right anger bubble, right_anger_bubble, rightangerbubble"
+        case .thoughtBalloon: return "thought balloon, thought_balloon, thoughtballoon"
+        case .zzz: return "sleeping symbol, zzz"
+        case .wave: return "wave, waving hand sign"
+        case .raisedBackOfHand: return "raised back of hand, raised_back_of_hand, raisedbackofhand"
+        case .raisedHandWithFingersSplayed: return "hand with fingers splayed, raised_hand_with_fingers_splayed, raisedhandwithfingerssplayed"
+        case .hand: return "hand, raised hand, raised_hand"
+        case .spockHand: return "raised hand with part between middle and ring fingers, spock-hand, spockhand"
+        case .rightwardsHand: return "rightwards hand, rightwards_hand, rightwardshand"
+        case .leftwardsHand: return "leftwards hand, leftwards_hand, leftwardshand"
+        case .palmDownHand: return "palm down hand, palm_down_hand, palmdownhand"
+        case .palmUpHand: return "palm up hand, palm_up_hand, palmuphand"
+        case .leftwardsPushingHand: return "leftwards pushing hand, leftwards_pushing_hand, leftwardspushinghand"
+        case .rightwardsPushingHand: return "rightwards pushing hand, rightwards_pushing_hand, rightwardspushinghand"
+        case .okHand: return "ok hand sign, ok_hand, okhand"
+        case .pinchedFingers: return "pinched fingers, pinched_fingers, pinchedfingers"
+        case .pinchingHand: return "pinching hand, pinching_hand, pinchinghand"
         case .v: return "v, victory hand"
-        case .crossedFingers: return "crossedfingers, hand_with_index_and_middle_fingers_crossed, hand with index and middle fingers crossed, crossed_fingers"
-        case .handWithIndexFingerAndThumbCrossed: return "hand_with_index_finger_and_thumb_crossed, handwithindexfingerandthumbcrossed, hand with index finger and thumb crossed"
-        case .iLoveYouHandSign: return "i_love_you_hand_sign, iloveyouhandsign, i love you hand sign"
-        case .theHorns: return "sign_of_the_horns, the_horns, thehorns, sign of the horns"
-        case .callMeHand: return "callmehand, call_me_hand, call me hand"
-        case .pointLeft: return "pointleft, point_left, white left pointing backhand index"
-        case .pointRight: return "white right pointing backhand index, point_right, pointright"
-        case .pointUp2: return "point_up_2, white up pointing backhand index, pointup2"
-        case .middleFinger: return "middle_finger, reversed_hand_with_middle_finger_extended, middlefinger, reversed hand with middle finger extended"
-        case .pointDown: return "point_down, white down pointing backhand index, pointdown"
-        case .pointUp: return "point_up, white up pointing index, pointup"
-        case .indexPointingAtTheViewer: return "index_pointing_at_the_viewer, indexpointingattheviewer, index pointing at the viewer"
-        case .plusOne: return "+1, thumbsup, thumbs up sign, plusone"
-        case .negativeOne: return "thumbsdown, -1, thumbs down sign, negativeone"
+        case .crossedFingers: return "crossed_fingers, crossedfingers, hand with index and middle fingers crossed, hand_with_index_and_middle_fingers_crossed"
+        case .handWithIndexFingerAndThumbCrossed: return "hand with index finger and thumb crossed, hand_with_index_finger_and_thumb_crossed, handwithindexfingerandthumbcrossed"
+        case .iLoveYouHandSign: return "i love you hand sign, i_love_you_hand_sign, iloveyouhandsign"
+        case .theHorns: return "sign of the horns, sign_of_the_horns, the_horns, thehorns"
+        case .callMeHand: return "call me hand, call_me_hand, callmehand"
+        case .pointLeft: return "point_left, pointleft, white left pointing backhand index"
+        case .pointRight: return "point_right, pointright, white right pointing backhand index"
+        case .pointUp2: return "point_up_2, pointup2, white up pointing backhand index"
+        case .middleFinger: return "middle_finger, middlefinger, reversed hand with middle finger extended, reversed_hand_with_middle_finger_extended"
+        case .pointDown: return "point_down, pointdown, white down pointing backhand index"
+        case .pointUp: return "point_up, pointup, white up pointing index"
+        case .indexPointingAtTheViewer: return "index pointing at the viewer, index_pointing_at_the_viewer, indexpointingattheviewer"
+        case .plusOne: return "+1, plusone, thumbs up sign, thumbsup"
+        case .negativeOne: return "-1, negativeone, thumbs down sign, thumbsdown"
         case .fist: return "fist, raised fist"
-        case .facepunch: return "punch, facepunch, fisted hand sign"
-        case .leftFacingFist: return "left-facing_fist, left-facing fist, leftfacingfist"
-        case .rightFacingFist: return "right-facing fist, rightfacingfist, right-facing_fist"
-        case .clap: return "clapping hands sign, clap"
+        case .facepunch: return "facepunch, fisted hand sign, punch"
+        case .leftFacingFist: return "left-facing fist, left-facing_fist, leftfacingfist"
+        case .rightFacingFist: return "right-facing fist, right-facing_fist, rightfacingfist"
+        case .clap: return "clap, clapping hands sign"
         case .raisedHands: return "person raising both hands in celebration, raised_hands, raisedhands"
-        case .heartHands: return "heart_hands, hearthands, heart hands"
+        case .heartHands: return "heart hands, heart_hands, hearthands"
         case .openHands: return "open hands sign, open_hands, openhands"
         case .palmsUpTogether: return "palms up together, palms_up_together, palmsuptogether"
         case .handshake: return "handshake"
-        case .pray: return "pray, person with folded hands"
+        case .pray: return "person with folded hands, pray"
         case .writingHand: return "writing hand, writing_hand, writinghand"
-        case .nailCare: return "nailcare, nail polish, nail_care"
+        case .nailCare: return "nail polish, nail_care, nailcare"
         case .selfie: return "selfie"
-        case .muscle: return "muscle, flexed biceps"
-        case .mechanicalArm: return "mechanicalarm, mechanical_arm, mechanical arm"
-        case .mechanicalLeg: return "mechanical leg, mechanicalleg, mechanical_leg"
+        case .muscle: return "flexed biceps, muscle"
+        case .mechanicalArm: return "mechanical arm, mechanical_arm, mechanicalarm"
+        case .mechanicalLeg: return "mechanical leg, mechanical_leg, mechanicalleg"
         case .leg: return "leg"
         case .foot: return "foot"
         case .ear: return "ear"
-        case .earWithHearingAid: return "earwithhearingaid, ear with hearing aid, ear_with_hearing_aid"
+        case .earWithHearingAid: return "ear with hearing aid, ear_with_hearing_aid, earwithhearingaid"
         case .nose: return "nose"
         case .brain: return "brain"
         case .anatomicalHeart: return "anatomical heart, anatomical_heart, anatomicalheart"
@@ -224,352 +229,354 @@ extension Emoji {
         case .eyes: return "eyes"
         case .eye: return "eye"
         case .tongue: return "tongue"
-        case .lips: return "mouth, lips"
-        case .bitingLip: return "biting lip, bitinglip, biting_lip"
+        case .lips: return "lips, mouth"
+        case .bitingLip: return "biting lip, biting_lip, bitinglip"
         case .baby: return "baby"
         case .child: return "child"
         case .boy: return "boy"
         case .girl: return "girl"
         case .adult: return "adult"
-        case .personWithBlondHair: return "person with blond hair, personwithblondhair, person_with_blond_hair"
+        case .personWithBlondHair: return "person with blond hair, person_with_blond_hair, personwithblondhair"
         case .man: return "man"
-        case .beardedPerson: return "bearded_person, beardedperson, bearded person"
-        case .manWithBeard: return "man: beard, manwithbeard, man_with_beard"
-        case .womanWithBeard: return "womanwithbeard, woman_with_beard, woman: beard"
-        case .redHairedMan: return "man: red hair, redhairedman, red_haired_man"
-        case .curlyHairedMan: return "curlyhairedman, curly_haired_man, man: curly hair"
-        case .whiteHairedMan: return "white_haired_man, man: white hair, whitehairedman"
-        case .baldMan: return "baldman, man: bald, bald_man"
+        case .beardedPerson: return "bearded person, bearded_person, beardedperson"
+        case .manWithBeard: return "man: beard, man_with_beard, manwithbeard"
+        case .womanWithBeard: return "woman: beard, woman_with_beard, womanwithbeard"
+        case .redHairedMan: return "man: red hair, red_haired_man, redhairedman"
+        case .curlyHairedMan: return "curly_haired_man, curlyhairedman, man: curly hair"
+        case .whiteHairedMan: return "man: white hair, white_haired_man, whitehairedman"
+        case .baldMan: return "bald_man, baldman, man: bald"
         case .woman: return "woman"
-        case .redHairedWoman: return "redhairedwoman, red_haired_woman, woman: red hair"
-        case .redHairedPerson: return "redhairedperson, red_haired_person, person: red hair"
-        case .curlyHairedWoman: return "curlyhairedwoman, curly_haired_woman, woman: curly hair"
-        case .curlyHairedPerson: return "curlyhairedperson, person: curly hair, curly_haired_person"
-        case .whiteHairedWoman: return "white_haired_woman, woman: white hair, whitehairedwoman"
-        case .whiteHairedPerson: return "whitehairedperson, white_haired_person, person: white hair"
-        case .baldWoman: return "woman: bald, bald_woman, baldwoman"
-        case .baldPerson: return "bald_person, person: bald, baldperson"
-        case .blondHairedWoman: return "woman: blond hair, blondhairedwoman, blond-haired-woman"
+        case .redHairedWoman: return "red_haired_woman, redhairedwoman, woman: red hair"
+        case .redHairedPerson: return "person: red hair, red_haired_person, redhairedperson"
+        case .curlyHairedWoman: return "curly_haired_woman, curlyhairedwoman, woman: curly hair"
+        case .curlyHairedPerson: return "curly_haired_person, curlyhairedperson, person: curly hair"
+        case .whiteHairedWoman: return "white_haired_woman, whitehairedwoman, woman: white hair"
+        case .whiteHairedPerson: return "person: white hair, white_haired_person, whitehairedperson"
+        case .baldWoman: return "bald_woman, baldwoman, woman: bald"
+        case .baldPerson: return "bald_person, baldperson, person: bald"
+        case .blondHairedWoman: return "blond-haired-woman, blondhairedwoman, woman: blond hair"
         case .blondHairedMan: return "blond-haired-man, blondhairedman, man: blond hair"
-        case .olderAdult: return "older_adult, older adult, olderadult"
-        case .olderMan: return "older_man, older man, olderman"
+        case .olderAdult: return "older adult, older_adult, olderadult"
+        case .olderMan: return "older man, older_man, olderman"
         case .olderWoman: return "older woman, older_woman, olderwoman"
-        case .personFrowning: return "person_frowning, personfrowning, person frowning"
-        case .manFrowning: return "man frowning, manfrowning, man-frowning"
+        case .personFrowning: return "person frowning, person_frowning, personfrowning"
+        case .manFrowning: return "man frowning, man-frowning, manfrowning"
         case .womanFrowning: return "woman frowning, woman-frowning, womanfrowning"
-        case .personWithPoutingFace: return "person with pouting face, personwithpoutingface, person_with_pouting_face"
+        case .personWithPoutingFace: return "person with pouting face, person_with_pouting_face, personwithpoutingface"
         case .manPouting: return "man pouting, man-pouting, manpouting"
-        case .womanPouting: return "woman-pouting, woman pouting, womanpouting"
-        case .noGood: return "no_good, nogood, face with no good gesture"
-        case .manGesturingNo: return "mangesturingno, man-gesturing-no, man gesturing no"
-        case .womanGesturingNo: return "woman gesturing no, womangesturingno, woman-gesturing-no"
-        case .okWoman: return "ok_woman, okwoman, face with ok gesture"
+        case .womanPouting: return "woman pouting, woman-pouting, womanpouting"
+        case .noGood: return "face with no good gesture, no_good, nogood"
+        case .manGesturingNo: return "man gesturing no, man-gesturing-no, mangesturingno"
+        case .womanGesturingNo: return "woman gesturing no, woman-gesturing-no, womangesturingno"
+        case .okWoman: return "face with ok gesture, ok_woman, okwoman"
         case .manGesturingOk: return "man gesturing ok, man-gesturing-ok, mangesturingok"
-        case .womanGesturingOk: return "woman-gesturing-ok, woman gesturing ok, womangesturingok"
-        case .informationDeskPerson: return "information desk person, informationdeskperson, information_desk_person"
-        case .manTippingHand: return "man-tipping-hand, man tipping hand, mantippinghand"
+        case .womanGesturingOk: return "woman gesturing ok, woman-gesturing-ok, womangesturingok"
+        case .informationDeskPerson: return "information desk person, information_desk_person, informationdeskperson"
+        case .manTippingHand: return "man tipping hand, man-tipping-hand, mantippinghand"
         case .womanTippingHand: return "woman tipping hand, woman-tipping-hand, womantippinghand"
-        case .raisingHand: return "happy person raising one hand, raisinghand, raising_hand"
-        case .manRaisingHand: return "manraisinghand, man-raising-hand, man raising hand"
-        case .womanRaisingHand: return "woman-raising-hand, woman raising hand, womanraisinghand"
-        case .deafPerson: return "deafperson, deaf_person, deaf person"
-        case .deafMan: return "deafman, deaf_man, deaf man"
+        case .raisingHand: return "happy person raising one hand, raising_hand, raisinghand"
+        case .manRaisingHand: return "man raising hand, man-raising-hand, manraisinghand"
+        case .womanRaisingHand: return "woman raising hand, woman-raising-hand, womanraisinghand"
+        case .deafPerson: return "deaf person, deaf_person, deafperson"
+        case .deafMan: return "deaf man, deaf_man, deafman"
         case .deafWoman: return "deaf woman, deaf_woman, deafwoman"
-        case .bow: return "person bowing deeply, bow"
-        case .manBowing: return "manbowing, man-bowing, man bowing"
-        case .womanBowing: return "woman-bowing, womanbowing, woman bowing"
-        case .facePalm: return "face palm, facepalm, face_palm"
-        case .manFacepalming: return "man-facepalming, man facepalming, manfacepalming"
+        case .bow: return "bow, person bowing deeply"
+        case .manBowing: return "man bowing, man-bowing, manbowing"
+        case .womanBowing: return "woman bowing, woman-bowing, womanbowing"
+        case .facePalm: return "face palm, face_palm, facepalm"
+        case .manFacepalming: return "man facepalming, man-facepalming, manfacepalming"
         case .womanFacepalming: return "woman facepalming, woman-facepalming, womanfacepalming"
         case .shrug: return "shrug"
-        case .manShrugging: return "manshrugging, man-shrugging, man shrugging"
-        case .womanShrugging: return "woman-shrugging, womanshrugging, woman shrugging"
-        case .healthWorker: return "health_worker, health worker, healthworker"
+        case .manShrugging: return "man shrugging, man-shrugging, manshrugging"
+        case .womanShrugging: return "woman shrugging, woman-shrugging, womanshrugging"
+        case .healthWorker: return "health worker, health_worker, healthworker"
         case .maleDoctor: return "male-doctor, maledoctor, man health worker"
-        case .femaleDoctor: return "woman health worker, femaledoctor, female-doctor"
+        case .femaleDoctor: return "female-doctor, femaledoctor, woman health worker"
         case .student: return "student"
         case .maleStudent: return "male-student, malestudent, man student"
-        case .femaleStudent: return "femalestudent, woman student, female-student"
+        case .femaleStudent: return "female-student, femalestudent, woman student"
         case .teacher: return "teacher"
         case .maleTeacher: return "male-teacher, maleteacher, man teacher"
-        case .femaleTeacher: return "woman teacher, female-teacher, femaleteacher"
+        case .femaleTeacher: return "female-teacher, femaleteacher, woman teacher"
         case .judge: return "judge"
-        case .maleJudge: return "man judge, male-judge, malejudge"
-        case .femaleJudge: return "female-judge, woman judge, femalejudge"
+        case .maleJudge: return "male-judge, malejudge, man judge"
+        case .femaleJudge: return "female-judge, femalejudge, woman judge"
         case .farmer: return "farmer"
-        case .maleFarmer: return "male-farmer, man farmer, malefarmer"
-        case .femaleFarmer: return "femalefarmer, female-farmer, woman farmer"
+        case .maleFarmer: return "male-farmer, malefarmer, man farmer"
+        case .femaleFarmer: return "female-farmer, femalefarmer, woman farmer"
         case .cook: return "cook"
-        case .maleCook: return "man cook, malecook, male-cook"
-        case .femaleCook: return "female-cook, woman cook, femalecook"
+        case .maleCook: return "male-cook, malecook, man cook"
+        case .femaleCook: return "female-cook, femalecook, woman cook"
         case .mechanic: return "mechanic"
-        case .maleMechanic: return "malemechanic, male-mechanic, man mechanic"
-        case .femaleMechanic: return "female-mechanic, woman mechanic, femalemechanic"
-        case .factoryWorker: return "factory_worker, factory worker, factoryworker"
-        case .maleFactoryWorker: return "man factory worker, male-factory-worker, malefactoryworker"
-        case .femaleFactoryWorker: return "female-factory-worker, woman factory worker, femalefactoryworker"
-        case .officeWorker: return "officeworker, office_worker, office worker"
+        case .maleMechanic: return "male-mechanic, malemechanic, man mechanic"
+        case .femaleMechanic: return "female-mechanic, femalemechanic, woman mechanic"
+        case .factoryWorker: return "factory worker, factory_worker, factoryworker"
+        case .maleFactoryWorker: return "male-factory-worker, malefactoryworker, man factory worker"
+        case .femaleFactoryWorker: return "female-factory-worker, femalefactoryworker, woman factory worker"
+        case .officeWorker: return "office worker, office_worker, officeworker"
         case .maleOfficeWorker: return "male-office-worker, maleofficeworker, man office worker"
-        case .femaleOfficeWorker: return "female-office-worker, woman office worker, femaleofficeworker"
+        case .femaleOfficeWorker: return "female-office-worker, femaleofficeworker, woman office worker"
         case .scientist: return "scientist"
-        case .maleScientist: return "man scientist, malescientist, male-scientist"
+        case .maleScientist: return "male-scientist, malescientist, man scientist"
         case .femaleScientist: return "female-scientist, femalescientist, woman scientist"
         case .technologist: return "technologist"
         case .maleTechnologist: return "male-technologist, maletechnologist, man technologist"
-        case .femaleTechnologist: return "femaletechnologist, woman technologist, female-technologist"
+        case .femaleTechnologist: return "female-technologist, femaletechnologist, woman technologist"
         case .singer: return "singer"
-        case .maleSinger: return "male-singer, man singer, malesinger"
-        case .femaleSinger: return "woman singer, femalesinger, female-singer"
+        case .maleSinger: return "male-singer, malesinger, man singer"
+        case .femaleSinger: return "female-singer, femalesinger, woman singer"
         case .artist: return "artist"
-        case .maleArtist: return "man artist, maleartist, male-artist"
-        case .femaleArtist: return "femaleartist, female-artist, woman artist"
+        case .maleArtist: return "male-artist, maleartist, man artist"
+        case .femaleArtist: return "female-artist, femaleartist, woman artist"
         case .pilot: return "pilot"
         case .malePilot: return "male-pilot, malepilot, man pilot"
-        case .femalePilot: return "female-pilot, woman pilot, femalepilot"
+        case .femalePilot: return "female-pilot, femalepilot, woman pilot"
         case .astronaut: return "astronaut"
-        case .maleAstronaut: return "man astronaut, male-astronaut, maleastronaut"
-        case .femaleAstronaut: return "femaleastronaut, female-astronaut, woman astronaut"
+        case .maleAstronaut: return "male-astronaut, maleastronaut, man astronaut"
+        case .femaleAstronaut: return "female-astronaut, femaleastronaut, woman astronaut"
         case .firefighter: return "firefighter"
-        case .maleFirefighter: return "man firefighter, male-firefighter, malefirefighter"
-        case .femaleFirefighter: return "woman firefighter, femalefirefighter, female-firefighter"
-        case .cop: return "police officer, cop"
-        case .malePoliceOfficer: return "malepoliceofficer, male-police-officer, man police officer"
-        case .femalePoliceOfficer: return "woman police officer, female-police-officer, femalepoliceofficer"
-        case .sleuthOrSpy: return "sleuthorspy, sleuth_or_spy, detective"
-        case .maleDetective: return "maledetective, male-detective, man detective"
-        case .femaleDetective: return "woman detective, female-detective, femaledetective"
+        case .maleFirefighter: return "male-firefighter, malefirefighter, man firefighter"
+        case .femaleFirefighter: return "female-firefighter, femalefirefighter, woman firefighter"
+        case .cop: return "cop, police officer"
+        case .malePoliceOfficer: return "male-police-officer, malepoliceofficer, man police officer"
+        case .femalePoliceOfficer: return "female-police-officer, femalepoliceofficer, woman police officer"
+        case .sleuthOrSpy: return "detective, sleuth_or_spy, sleuthorspy"
+        case .maleDetective: return "male-detective, maledetective, man detective"
+        case .femaleDetective: return "female-detective, femaledetective, woman detective"
         case .guardsman: return "guardsman"
-        case .maleGuard: return "maleguard, male-guard, man guard"
-        case .femaleGuard: return "woman guard, female-guard, femaleguard"
+        case .maleGuard: return "male-guard, maleguard, man guard"
+        case .femaleGuard: return "female-guard, femaleguard, woman guard"
         case .ninja: return "ninja"
-        case .constructionWorker: return "construction_worker, constructionworker, construction worker"
-        case .maleConstructionWorker: return "male-construction-worker, man construction worker, maleconstructionworker"
-        case .femaleConstructionWorker: return "femaleconstructionworker, female-construction-worker, woman construction worker"
-        case .personWithCrown: return "person_with_crown, person with crown, personwithcrown"
+        case .constructionWorker: return "construction worker, construction_worker, constructionworker"
+        case .maleConstructionWorker: return "male-construction-worker, maleconstructionworker, man construction worker"
+        case .femaleConstructionWorker: return "female-construction-worker, femaleconstructionworker, woman construction worker"
+        case .personWithCrown: return "person with crown, person_with_crown, personwithcrown"
         case .prince: return "prince"
         case .princess: return "princess"
-        case .manWithTurban: return "man with turban, manwithturban, man_with_turban"
-        case .manWearingTurban: return "man-wearing-turban, manwearingturban, man wearing turban"
-        case .womanWearingTurban: return "woman-wearing-turban, womanwearingturban, woman wearing turban"
-        case .manWithGuaPiMao: return "man_with_gua_pi_mao, man with gua pi mao, manwithguapimao"
-        case .personWithHeadscarf: return "person_with_headscarf, personwithheadscarf, person with headscarf"
-        case .personInTuxedo: return "person_in_tuxedo, personintuxedo, man in tuxedo"
-        case .manInTuxedo: return "man_in_tuxedo, manintuxedo, man in tuxedo"
-        case .womanInTuxedo: return "womanintuxedo, woman in tuxedo, woman_in_tuxedo"
-        case .brideWithVeil: return "bridewithveil, bride_with_veil, bride with veil"
-        case .manWithVeil: return "man_with_veil, man with veil, manwithveil"
-        case .womanWithVeil: return "woman with veil, womanwithveil, woman_with_veil"
-        case .pregnantWoman: return "pregnant woman, pregnantwoman, pregnant_woman"
-        case .pregnantMan: return "pregnant_man, pregnant man, pregnantman"
-        case .pregnantPerson: return "pregnant_person, pregnant person, pregnantperson"
+        case .manWithTurban: return "man with turban, man_with_turban, manwithturban"
+        case .manWearingTurban: return "man wearing turban, man-wearing-turban, manwearingturban"
+        case .womanWearingTurban: return "woman wearing turban, woman-wearing-turban, womanwearingturban"
+        case .manWithGuaPiMao: return "man with gua pi mao, man_with_gua_pi_mao, manwithguapimao"
+        case .personWithHeadscarf: return "person with headscarf, person_with_headscarf, personwithheadscarf"
+        case .personInTuxedo: return "man in tuxedo, person_in_tuxedo, personintuxedo"
+        case .manInTuxedo: return "man in tuxedo, man_in_tuxedo, manintuxedo"
+        case .womanInTuxedo: return "woman in tuxedo, woman_in_tuxedo, womanintuxedo"
+        case .brideWithVeil: return "bride with veil, bride_with_veil, bridewithveil"
+        case .manWithVeil: return "man with veil, man_with_veil, manwithveil"
+        case .womanWithVeil: return "woman with veil, woman_with_veil, womanwithveil"
+        case .pregnantWoman: return "pregnant woman, pregnant_woman, pregnantwoman"
+        case .pregnantMan: return "pregnant man, pregnant_man, pregnantman"
+        case .pregnantPerson: return "pregnant person, pregnant_person, pregnantperson"
         case .breastFeeding: return "breast-feeding, breastfeeding"
-        case .womanFeedingBaby: return "womanfeedingbaby, woman_feeding_baby, woman feeding baby"
-        case .manFeedingBaby: return "man feeding baby, manfeedingbaby, man_feeding_baby"
-        case .personFeedingBaby: return "personfeedingbaby, person_feeding_baby, person feeding baby"
+        case .womanFeedingBaby: return "woman feeding baby, woman_feeding_baby, womanfeedingbaby"
+        case .manFeedingBaby: return "man feeding baby, man_feeding_baby, manfeedingbaby"
+        case .personFeedingBaby: return "person feeding baby, person_feeding_baby, personfeedingbaby"
         case .angel: return "angel, baby angel"
         case .santa: return "father christmas, santa"
-        case .mrsClaus: return "mrsclaus, mother_christmas, mother christmas, mrs_claus"
-        case .mxClaus: return "mxclaus, mx claus, mx_claus"
+        case .mrsClaus: return "mother christmas, mother_christmas, mrs_claus, mrsclaus"
+        case .mxClaus: return "mx claus, mx_claus, mxclaus"
         case .superhero: return "superhero"
-        case .maleSuperhero: return "male_superhero, man superhero, malesuperhero"
+        case .maleSuperhero: return "male_superhero, malesuperhero, man superhero"
         case .femaleSuperhero: return "female_superhero, femalesuperhero, woman superhero"
         case .supervillain: return "supervillain"
-        case .maleSupervillain: return "malesupervillain, man supervillain, male_supervillain"
-        case .femaleSupervillain: return "female_supervillain, woman supervillain, femalesupervillain"
+        case .maleSupervillain: return "male_supervillain, malesupervillain, man supervillain"
+        case .femaleSupervillain: return "female_supervillain, femalesupervillain, woman supervillain"
         case .mage: return "mage"
         case .maleMage: return "male_mage, malemage, man mage"
-        case .femaleMage: return "female_mage, woman mage, femalemage"
+        case .femaleMage: return "female_mage, femalemage, woman mage"
         case .fairy: return "fairy"
-        case .maleFairy: return "malefairy, man fairy, male_fairy"
-        case .femaleFairy: return "femalefairy, female_fairy, woman fairy"
+        case .maleFairy: return "male_fairy, malefairy, man fairy"
+        case .femaleFairy: return "female_fairy, femalefairy, woman fairy"
         case .vampire: return "vampire"
-        case .maleVampire: return "malevampire, male_vampire, man vampire"
-        case .femaleVampire: return "female_vampire, woman vampire, femalevampire"
+        case .maleVampire: return "male_vampire, malevampire, man vampire"
+        case .femaleVampire: return "female_vampire, femalevampire, woman vampire"
         case .merperson: return "merperson"
         case .merman: return "merman"
         case .mermaid: return "mermaid"
         case .elf: return "elf"
-        case .maleElf: return "male_elf, man elf, maleelf"
+        case .maleElf: return "male_elf, maleelf, man elf"
         case .femaleElf: return "female_elf, femaleelf, woman elf"
         case .genie: return "genie"
-        case .maleGenie: return "man genie, male_genie, malegenie"
-        case .femaleGenie: return "woman genie, femalegenie, female_genie"
+        case .maleGenie: return "male_genie, malegenie, man genie"
+        case .femaleGenie: return "female_genie, femalegenie, woman genie"
         case .zombie: return "zombie"
-        case .maleZombie: return "malezombie, man zombie, male_zombie"
-        case .femaleZombie: return "woman zombie, female_zombie, femalezombie"
+        case .maleZombie: return "male_zombie, malezombie, man zombie"
+        case .femaleZombie: return "female_zombie, femalezombie, woman zombie"
         case .troll: return "troll"
-        case .massage: return "massage, face massage"
+        case .massage: return "face massage, massage"
         case .manGettingMassage: return "man getting massage, man-getting-massage, mangettingmassage"
-        case .womanGettingMassage: return "woman getting massage, womangettingmassage, woman-getting-massage"
+        case .womanGettingMassage: return "woman getting massage, woman-getting-massage, womangettingmassage"
         case .haircut: return "haircut"
-        case .manGettingHaircut: return "mangettinghaircut, man-getting-haircut, man getting haircut"
-        case .womanGettingHaircut: return "woman-getting-haircut, woman getting haircut, womangettinghaircut"
+        case .manGettingHaircut: return "man getting haircut, man-getting-haircut, mangettinghaircut"
+        case .womanGettingHaircut: return "woman getting haircut, woman-getting-haircut, womangettinghaircut"
         case .walking: return "pedestrian, walking"
-        case .manWalking: return "man-walking, man walking, manwalking"
-        case .womanWalking: return "woman-walking, woman walking, womanwalking"
-        case .standingPerson: return "standing person, standingperson, standing_person"
-        case .manStanding: return "manstanding, man_standing, man standing"
-        case .womanStanding: return "woman_standing, womanstanding, woman standing"
-        case .kneelingPerson: return "kneelingperson, kneeling person, kneeling_person"
+        case .manWalking: return "man walking, man-walking, manwalking"
+        case .womanWalking: return "woman walking, woman-walking, womanwalking"
+        case .standingPerson: return "standing person, standing_person, standingperson"
+        case .manStanding: return "man standing, man_standing, manstanding"
+        case .womanStanding: return "woman standing, woman_standing, womanstanding"
+        case .kneelingPerson: return "kneeling person, kneeling_person, kneelingperson"
         case .manKneeling: return "man kneeling, man_kneeling, mankneeling"
-        case .womanKneeling: return "woman_kneeling, woman kneeling, womankneeling"
-        case .personWithProbingCane: return "person_with_probing_cane, personwithprobingcane, person with white cane"
-        case .manWithProbingCane: return "man with white cane, manwithprobingcane, man_with_probing_cane"
-        case .womanWithProbingCane: return "woman_with_probing_cane, womanwithprobingcane, woman with white cane"
-        case .personInMotorizedWheelchair: return "personinmotorizedwheelchair, person in motorized wheelchair, person_in_motorized_wheelchair"
-        case .manInMotorizedWheelchair: return "man in motorized wheelchair, maninmotorizedwheelchair, man_in_motorized_wheelchair"
-        case .womanInMotorizedWheelchair: return "woman in motorized wheelchair, womaninmotorizedwheelchair, woman_in_motorized_wheelchair"
-        case .personInManualWheelchair: return "personinmanualwheelchair, person_in_manual_wheelchair, person in manual wheelchair"
-        case .manInManualWheelchair: return "man_in_manual_wheelchair, maninmanualwheelchair, man in manual wheelchair"
-        case .womanInManualWheelchair: return "womaninmanualwheelchair, woman_in_manual_wheelchair, woman in manual wheelchair"
-        case .runner: return "running, runner"
-        case .manRunning: return "man-running, man running, manrunning"
-        case .womanRunning: return "woman running, womanrunning, woman-running"
+        case .womanKneeling: return "woman kneeling, woman_kneeling, womankneeling"
+        case .personWithProbingCane: return "person with white cane, person_with_probing_cane, personwithprobingcane"
+        case .manWithProbingCane: return "man with white cane, man_with_probing_cane, manwithprobingcane"
+        case .womanWithProbingCane: return "woman with white cane, woman_with_probing_cane, womanwithprobingcane"
+        case .personInMotorizedWheelchair: return "person in motorized wheelchair, person_in_motorized_wheelchair, personinmotorizedwheelchair"
+        case .manInMotorizedWheelchair: return "man in motorized wheelchair, man_in_motorized_wheelchair, maninmotorizedwheelchair"
+        case .womanInMotorizedWheelchair: return "woman in motorized wheelchair, woman_in_motorized_wheelchair, womaninmotorizedwheelchair"
+        case .personInManualWheelchair: return "person in manual wheelchair, person_in_manual_wheelchair, personinmanualwheelchair"
+        case .manInManualWheelchair: return "man in manual wheelchair, man_in_manual_wheelchair, maninmanualwheelchair"
+        case .womanInManualWheelchair: return "woman in manual wheelchair, woman_in_manual_wheelchair, womaninmanualwheelchair"
+        case .runner: return "runner, running"
+        case .manRunning: return "man running, man-running, manrunning"
+        case .womanRunning: return "woman running, woman-running, womanrunning"
         case .dancer: return "dancer"
-        case .manDancing: return "man_dancing, mandancing, man dancing"
-        case .manInBusinessSuitLevitating: return "maninbusinesssuitlevitating, man_in_business_suit_levitating, person in suit levitating"
+        case .manDancing: return "man dancing, man_dancing, mandancing"
+        case .manInBusinessSuitLevitating: return "man_in_business_suit_levitating, maninbusinesssuitlevitating, person in suit levitating"
         case .dancers: return "dancers, woman with bunny ears"
-        case .menWithBunnyEarsPartying: return "menwithbunnyearspartying, man-with-bunny-ears-partying, men with bunny ears, men-with-bunny-ears-partying"
-        case .womenWithBunnyEarsPartying: return "women-with-bunny-ears-partying, woman-with-bunny-ears-partying, womenwithbunnyearspartying, women with bunny ears"
-        case .personInSteamyRoom: return "person_in_steamy_room, person in steamy room, personinsteamyroom"
+        case .menWithBunnyEarsPartying: return "man-with-bunny-ears-partying, men with bunny ears, men-with-bunny-ears-partying, menwithbunnyearspartying"
+        case .womenWithBunnyEarsPartying: return "woman-with-bunny-ears-partying, women with bunny ears, women-with-bunny-ears-partying, womenwithbunnyearspartying"
+        case .personInSteamyRoom: return "person in steamy room, person_in_steamy_room, personinsteamyroom"
         case .manInSteamyRoom: return "man in steamy room, man_in_steamy_room, maninsteamyroom"
         case .womanInSteamyRoom: return "woman in steamy room, woman_in_steamy_room, womaninsteamyroom"
-        case .personClimbing: return "person_climbing, person climbing, personclimbing"
+        case .personClimbing: return "person climbing, person_climbing, personclimbing"
         case .manClimbing: return "man climbing, man_climbing, manclimbing"
-        case .womanClimbing: return "woman climbing, womanclimbing, woman_climbing"
+        case .womanClimbing: return "woman climbing, woman_climbing, womanclimbing"
         case .fencer: return "fencer"
-        case .horseRacing: return "horse_racing, horseracing, horse racing"
+        case .horseRacing: return "horse racing, horse_racing, horseracing"
         case .skier: return "skier"
         case .snowboarder: return "snowboarder"
         case .golfer: return "golfer, person golfing"
-        case .manGolfing: return "mangolfing, man-golfing, man golfing"
-        case .womanGolfing: return "womangolfing, woman golfing, woman-golfing"
+        case .manGolfing: return "man golfing, man-golfing, mangolfing"
+        case .womanGolfing: return "woman golfing, woman-golfing, womangolfing"
         case .surfer: return "surfer"
         case .manSurfing: return "man surfing, man-surfing, mansurfing"
-        case .womanSurfing: return "woman surfing, womansurfing, woman-surfing"
+        case .womanSurfing: return "woman surfing, woman-surfing, womansurfing"
         case .rowboat: return "rowboat"
-        case .manRowingBoat: return "man-rowing-boat, man rowing boat, manrowingboat"
-        case .womanRowingBoat: return "womanrowingboat, woman rowing boat, woman-rowing-boat"
+        case .manRowingBoat: return "man rowing boat, man-rowing-boat, manrowingboat"
+        case .womanRowingBoat: return "woman rowing boat, woman-rowing-boat, womanrowingboat"
         case .swimmer: return "swimmer"
-        case .manSwimming: return "man swimming, manswimming, man-swimming"
-        case .womanSwimming: return "woman swimming, womanswimming, woman-swimming"
-        case .personWithBall: return "person_with_ball, person bouncing ball, personwithball"
-        case .manBouncingBall: return "manbouncingball, man bouncing ball, man-bouncing-ball"
-        case .womanBouncingBall: return "woman-bouncing-ball, woman bouncing ball, womanbouncingball"
+        case .manSwimming: return "man swimming, man-swimming, manswimming"
+        case .womanSwimming: return "woman swimming, woman-swimming, womanswimming"
+        case .personWithBall: return "person bouncing ball, person_with_ball, personwithball"
+        case .manBouncingBall: return "man bouncing ball, man-bouncing-ball, manbouncingball"
+        case .womanBouncingBall: return "woman bouncing ball, woman-bouncing-ball, womanbouncingball"
         case .weightLifter: return "person lifting weights, weight_lifter, weightlifter"
-        case .manLiftingWeights: return "manliftingweights, man-lifting-weights, man lifting weights"
-        case .womanLiftingWeights: return "woman-lifting-weights, woman lifting weights, womanliftingweights"
+        case .manLiftingWeights: return "man lifting weights, man-lifting-weights, manliftingweights"
+        case .womanLiftingWeights: return "woman lifting weights, woman-lifting-weights, womanliftingweights"
         case .bicyclist: return "bicyclist"
-        case .manBiking: return "man biking, manbiking, man-biking"
-        case .womanBiking: return "woman biking, womanbiking, woman-biking"
-        case .mountainBicyclist: return "mountain_bicyclist, mountain bicyclist, mountainbicyclist"
-        case .manMountainBiking: return "man mountain biking, manmountainbiking, man-mountain-biking"
-        case .womanMountainBiking: return "woman-mountain-biking, womanmountainbiking, woman mountain biking"
-        case .personDoingCartwheel: return "person doing cartwheel, persondoingcartwheel, person_doing_cartwheel"
-        case .manCartwheeling: return "man-cartwheeling, mancartwheeling, man cartwheeling"
-        case .womanCartwheeling: return "woman-cartwheeling, woman cartwheeling, womancartwheeling"
+        case .manBiking: return "man biking, man-biking, manbiking"
+        case .womanBiking: return "woman biking, woman-biking, womanbiking"
+        case .mountainBicyclist: return "mountain bicyclist, mountain_bicyclist, mountainbicyclist"
+        case .manMountainBiking: return "man mountain biking, man-mountain-biking, manmountainbiking"
+        case .womanMountainBiking: return "woman mountain biking, woman-mountain-biking, womanmountainbiking"
+        case .personDoingCartwheel: return "person doing cartwheel, person_doing_cartwheel, persondoingcartwheel"
+        case .manCartwheeling: return "man cartwheeling, man-cartwheeling, mancartwheeling"
+        case .womanCartwheeling: return "woman cartwheeling, woman-cartwheeling, womancartwheeling"
         case .wrestlers: return "wrestlers"
         case .manWrestling: return "man-wrestling, manwrestling, men wrestling"
-        case .womanWrestling: return "womanwrestling, women wrestling, woman-wrestling"
-        case .waterPolo: return "water polo, waterpolo, water_polo"
-        case .manPlayingWaterPolo: return "man playing water polo, manplayingwaterpolo, man-playing-water-polo"
-        case .womanPlayingWaterPolo: return "womanplayingwaterpolo, woman playing water polo, woman-playing-water-polo"
+        case .womanWrestling: return "woman-wrestling, womanwrestling, women wrestling"
+        case .waterPolo: return "water polo, water_polo, waterpolo"
+        case .manPlayingWaterPolo: return "man playing water polo, man-playing-water-polo, manplayingwaterpolo"
+        case .womanPlayingWaterPolo: return "woman playing water polo, woman-playing-water-polo, womanplayingwaterpolo"
         case .handball: return "handball"
-        case .manPlayingHandball: return "man-playing-handball, manplayinghandball, man playing handball"
-        case .womanPlayingHandball: return "womanplayinghandball, woman playing handball, woman-playing-handball"
+        case .manPlayingHandball: return "man playing handball, man-playing-handball, manplayinghandball"
+        case .womanPlayingHandball: return "woman playing handball, woman-playing-handball, womanplayinghandball"
         case .juggling: return "juggling"
-        case .manJuggling: return "man-juggling, manjuggling, man juggling"
-        case .womanJuggling: return "woman-juggling, womanjuggling, woman juggling"
-        case .personInLotusPosition: return "personinlotusposition, person in lotus position, person_in_lotus_position"
-        case .manInLotusPosition: return "maninlotusposition, man_in_lotus_position, man in lotus position"
-        case .womanInLotusPosition: return "woman_in_lotus_position, woman in lotus position, womaninlotusposition"
+        case .manJuggling: return "man juggling, man-juggling, manjuggling"
+        case .womanJuggling: return "woman juggling, woman-juggling, womanjuggling"
+        case .personInLotusPosition: return "person in lotus position, person_in_lotus_position, personinlotusposition"
+        case .manInLotusPosition: return "man in lotus position, man_in_lotus_position, maninlotusposition"
+        case .womanInLotusPosition: return "woman in lotus position, woman_in_lotus_position, womaninlotusposition"
         case .bath: return "bath"
-        case .sleepingAccommodation: return "sleeping_accommodation, sleeping accommodation, sleepingaccommodation"
-        case .peopleHoldingHands: return "peopleholdinghands, people_holding_hands, people holding hands"
-        case .twoWomenHoldingHands: return "twowomenholdinghands, two women holding hands, women_holding_hands, two_women_holding_hands"
-        case .manAndWomanHoldingHands: return "man and woman holding hands, couple, man_and_woman_holding_hands, manandwomanholdinghands, woman_and_man_holding_hands"
-        case .twoMenHoldingHands: return "two_men_holding_hands, twomenholdinghands, men_holding_hands, two men holding hands"
-        case .personKissPerson: return "kiss, personkissperson, couplekiss"
-        case .womanKissMan: return "womankissman, kiss: woman, man, woman-kiss-man"
-        case .manKissMan: return "mankissman, man-kiss-man, kiss: man, man"
-        case .womanKissWoman: return "kiss: woman, woman, womankisswoman, woman-kiss-woman"
-        case .personHeartPerson: return "couple_with_heart, personheartperson, couple with heart"
-        case .womanHeartMan: return "womanheartman, woman-heart-man, couple with heart: woman, man"
-        case .manHeartMan: return "man-heart-man, couple with heart: man, man, manheartman"
-        case .womanHeartWoman: return "couple with heart: woman, woman, womanheartwoman, woman-heart-woman"
+        case .sleepingAccommodation: return "sleeping accommodation, sleeping_accommodation, sleepingaccommodation"
+        case .peopleHoldingHands: return "people holding hands, people_holding_hands, peopleholdinghands"
+        case .twoWomenHoldingHands: return "two women holding hands, two_women_holding_hands, twowomenholdinghands, women_holding_hands"
+        case .manAndWomanHoldingHands: return "couple, man and woman holding hands, man_and_woman_holding_hands, manandwomanholdinghands, woman_and_man_holding_hands"
+        case .twoMenHoldingHands: return "men_holding_hands, two men holding hands, two_men_holding_hands, twomenholdinghands"
+        case .personKissPerson: return "couplekiss, kiss, personkissperson"
+        case .womanKissMan: return "kiss: woman, man, woman-kiss-man, womankissman"
+        case .manKissMan: return "kiss: man, man, man-kiss-man, mankissman"
+        case .womanKissWoman: return "kiss: woman, woman, woman-kiss-woman, womankisswoman"
+        case .personHeartPerson: return "couple with heart, couple_with_heart, personheartperson"
+        case .womanHeartMan: return "couple with heart: woman, man, woman-heart-man, womanheartman"
+        case .manHeartMan: return "couple with heart: man, man, man-heart-man, manheartman"
+        case .womanHeartWoman: return "couple with heart: woman, woman, woman-heart-woman, womanheartwoman"
         case .family: return "family"
         case .manWomanBoy: return "family: man, woman, boy, man-woman-boy, manwomanboy"
-        case .manWomanGirl: return "manwomangirl, man-woman-girl, family: man, woman, girl"
-        case .manWomanGirlBoy: return "man-woman-girl-boy, family: man, woman, girl, boy, manwomangirlboy"
+        case .manWomanGirl: return "family: man, woman, girl, man-woman-girl, manwomangirl"
+        case .manWomanGirlBoy: return "family: man, woman, girl, boy, man-woman-girl-boy, manwomangirlboy"
         case .manWomanBoyBoy: return "family: man, woman, boy, boy, man-woman-boy-boy, manwomanboyboy"
-        case .manWomanGirlGirl: return "man-woman-girl-girl, family: man, woman, girl, girl, manwomangirlgirl"
-        case .manManBoy: return "manmanboy, man-man-boy, family: man, man, boy"
-        case .manManGirl: return "manmangirl, family: man, man, girl, man-man-girl"
-        case .manManGirlBoy: return "manmangirlboy, man-man-girl-boy, family: man, man, girl, boy"
-        case .manManBoyBoy: return "manmanboyboy, man-man-boy-boy, family: man, man, boy, boy"
-        case .manManGirlGirl: return "man-man-girl-girl, family: man, man, girl, girl, manmangirlgirl"
-        case .womanWomanBoy: return "family: woman, woman, boy, womanwomanboy, woman-woman-boy"
-        case .womanWomanGirl: return "woman-woman-girl, family: woman, woman, girl, womanwomangirl"
-        case .womanWomanGirlBoy: return "family: woman, woman, girl, boy, womanwomangirlboy, woman-woman-girl-boy"
-        case .womanWomanBoyBoy: return "womanwomanboyboy, woman-woman-boy-boy, family: woman, woman, boy, boy"
-        case .womanWomanGirlGirl: return "family: woman, woman, girl, girl, womanwomangirlgirl, woman-woman-girl-girl"
-        case .manBoy: return "manboy, man-boy, family: man, boy"
-        case .manBoyBoy: return "man-boy-boy, family: man, boy, boy, manboyboy"
-        case .manGirl: return "man-girl, mangirl, family: man, girl"
-        case .manGirlBoy: return "man-girl-boy, family: man, girl, boy, mangirlboy"
-        case .manGirlGirl: return "mangirlgirl, man-girl-girl, family: man, girl, girl"
-        case .womanBoy: return "womanboy, woman-boy, family: woman, boy"
+        case .manWomanGirlGirl: return "family: man, woman, girl, girl, man-woman-girl-girl, manwomangirlgirl"
+        case .manManBoy: return "family: man, man, boy, man-man-boy, manmanboy"
+        case .manManGirl: return "family: man, man, girl, man-man-girl, manmangirl"
+        case .manManGirlBoy: return "family: man, man, girl, boy, man-man-girl-boy, manmangirlboy"
+        case .manManBoyBoy: return "family: man, man, boy, boy, man-man-boy-boy, manmanboyboy"
+        case .manManGirlGirl: return "family: man, man, girl, girl, man-man-girl-girl, manmangirlgirl"
+        case .womanWomanBoy: return "family: woman, woman, boy, woman-woman-boy, womanwomanboy"
+        case .womanWomanGirl: return "family: woman, woman, girl, woman-woman-girl, womanwomangirl"
+        case .womanWomanGirlBoy: return "family: woman, woman, girl, boy, woman-woman-girl-boy, womanwomangirlboy"
+        case .womanWomanBoyBoy: return "family: woman, woman, boy, boy, woman-woman-boy-boy, womanwomanboyboy"
+        case .womanWomanGirlGirl: return "family: woman, woman, girl, girl, woman-woman-girl-girl, womanwomangirlgirl"
+        case .manBoy: return "family: man, boy, man-boy, manboy"
+        case .manBoyBoy: return "family: man, boy, boy, man-boy-boy, manboyboy"
+        case .manGirl: return "family: man, girl, man-girl, mangirl"
+        case .manGirlBoy: return "family: man, girl, boy, man-girl-boy, mangirlboy"
+        case .manGirlGirl: return "family: man, girl, girl, man-girl-girl, mangirlgirl"
+        case .womanBoy: return "family: woman, boy, woman-boy, womanboy"
         case .womanBoyBoy: return "family: woman, boy, boy, woman-boy-boy, womanboyboy"
-        case .womanGirl: return "family: woman, girl, womangirl, woman-girl"
-        case .womanGirlBoy: return "family: woman, girl, boy, womangirlboy, woman-girl-boy"
-        case .womanGirlGirl: return "woman-girl-girl, womangirlgirl, family: woman, girl, girl"
-        case .speakingHeadInSilhouette: return "speaking_head_in_silhouette, speaking head, speakingheadinsilhouette"
-        case .bustInSilhouette: return "bustinsilhouette, bust_in_silhouette, bust in silhouette"
-        case .bustsInSilhouette: return "busts_in_silhouette, busts in silhouette, bustsinsilhouette"
-        case .peopleHugging: return "people_hugging, people hugging, peoplehugging"
+        case .womanGirl: return "family: woman, girl, woman-girl, womangirl"
+        case .womanGirlBoy: return "family: woman, girl, boy, woman-girl-boy, womangirlboy"
+        case .womanGirlGirl: return "family: woman, girl, girl, woman-girl-girl, womangirlgirl"
+        case .speakingHeadInSilhouette: return "speaking head, speaking_head_in_silhouette, speakingheadinsilhouette"
+        case .bustInSilhouette: return "bust in silhouette, bust_in_silhouette, bustinsilhouette"
+        case .bustsInSilhouette: return "busts in silhouette, busts_in_silhouette, bustsinsilhouette"
+        case .peopleHugging: return "people hugging, people_hugging, peoplehugging"
         case .footprints: return "footprints"
-        case .skinTone2: return "skin-tone-2, emoji modifier fitzpatrick type-1-2, skintone2"
-        case .skinTone3: return "skintone3, skin-tone-3, emoji modifier fitzpatrick type-3"
-        case .skinTone4: return "skintone4, skin-tone-4, emoji modifier fitzpatrick type-4"
-        case .skinTone5: return "emoji modifier fitzpatrick type-5, skintone5, skin-tone-5"
-        case .skinTone6: return "skin-tone-6, emoji modifier fitzpatrick type-6, skintone6"
-        case .monkeyFace: return "monkeyface, monkey_face, monkey face"
+        case .skinTone2: return "emoji modifier fitzpatrick type-1-2, skin-tone-2, skintone2"
+        case .skinTone3: return "emoji modifier fitzpatrick type-3, skin-tone-3, skintone3"
+        case .skinTone4: return "emoji modifier fitzpatrick type-4, skin-tone-4, skintone4"
+        case .skinTone5: return "emoji modifier fitzpatrick type-5, skin-tone-5, skintone5"
+        case .skinTone6: return "emoji modifier fitzpatrick type-6, skin-tone-6, skintone6"
+        case .monkeyFace: return "monkey face, monkey_face, monkeyface"
         case .monkey: return "monkey"
         case .gorilla: return "gorilla"
         case .orangutan: return "orangutan"
-        case .dog: return "dog face, dog"
+        case .dog: return "dog, dog face"
         case .dog2: return "dog, dog2"
-        case .guideDog: return "guide_dog, guidedog, guide dog"
+        case .guideDog: return "guide dog, guide_dog, guidedog"
         case .serviceDog: return "service dog, service_dog, servicedog"
         case .poodle: return "poodle"
         case .wolf: return "wolf, wolf face"
-        case .foxFace: return "foxface, fox_face, fox face"
+        case .foxFace: return "fox face, fox_face, foxface"
         case .raccoon: return "raccoon"
         case .cat: return "cat, cat face"
-        case .cat2: return "cat2, cat"
-        case .blackCat: return "black cat, blackcat, black_cat"
-        case .lionFace: return "lion_face, lion face, lionface"
-        case .tiger: return "tiger face, tiger"
+        case .cat2: return "cat, cat2"
+        case .blackCat: return "black cat, black_cat, blackcat"
+        case .lionFace: return "lion face, lion_face, lionface"
+        case .tiger: return "tiger, tiger face"
         case .tiger2: return "tiger, tiger2"
         case .leopard: return "leopard"
-        case .horse: return "horse face, horse"
+        case .horse: return "horse, horse face"
+        case .moose: return "moose"
+        case .donkey: return "donkey"
         case .racehorse: return "horse, racehorse"
-        case .unicornFace: return "unicorn_face, unicorn face, unicornface"
-        case .zebraFace: return "zebra_face, zebra face, zebraface"
+        case .unicornFace: return "unicorn face, unicorn_face, unicornface"
+        case .zebraFace: return "zebra face, zebra_face, zebraface"
         case .deer: return "deer"
         case .bison: return "bison"
-        case .cow: return "cow face, cow"
+        case .cow: return "cow, cow face"
         case .ox: return "ox"
-        case .waterBuffalo: return "water buffalo, waterbuffalo, water_buffalo"
+        case .waterBuffalo: return "water buffalo, water_buffalo, waterbuffalo"
         case .cow2: return "cow, cow2"
         case .pig: return "pig, pig face"
-        case .pig2: return "pig2, pig"
+        case .pig2: return "pig, pig2"
         case .boar: return "boar"
-        case .pigNose: return "pig_nose, pig nose, pignose"
+        case .pigNose: return "pig nose, pig_nose, pignose"
         case .ram: return "ram"
         case .sheep: return "sheep"
         case .goat: return "goat"
-        case .dromedaryCamel: return "dromedary_camel, dromedary camel, dromedarycamel"
+        case .dromedaryCamel: return "dromedary camel, dromedary_camel, dromedarycamel"
         case .camel: return "bactrian camel, camel"
         case .llama: return "llama"
         case .giraffeFace: return "giraffe face, giraffe_face, giraffeface"
@@ -578,34 +585,34 @@ extension Emoji {
         case .rhinoceros: return "rhinoceros"
         case .hippopotamus: return "hippopotamus"
         case .mouse: return "mouse, mouse face"
-        case .mouse2: return "mouse2, mouse"
+        case .mouse2: return "mouse, mouse2"
         case .rat: return "rat"
         case .hamster: return "hamster, hamster face"
         case .rabbit: return "rabbit, rabbit face"
-        case .rabbit2: return "rabbit2, rabbit"
+        case .rabbit2: return "rabbit, rabbit2"
         case .chipmunk: return "chipmunk"
         case .beaver: return "beaver"
         case .hedgehog: return "hedgehog"
         case .bat: return "bat"
-        case .bear: return "bear face, bear"
-        case .polarBear: return "polarbear, polar_bear, polar bear"
+        case .bear: return "bear, bear face"
+        case .polarBear: return "polar bear, polar_bear, polarbear"
         case .koala: return "koala"
-        case .pandaFace: return "panda face, pandaface, panda_face"
+        case .pandaFace: return "panda face, panda_face, pandaface"
         case .sloth: return "sloth"
         case .otter: return "otter"
         case .skunk: return "skunk"
         case .kangaroo: return "kangaroo"
         case .badger: return "badger"
-        case .feet: return "paw prints, feet, paw_prints"
+        case .feet: return "feet, paw prints, paw_prints"
         case .turkey: return "turkey"
         case .chicken: return "chicken"
         case .rooster: return "rooster"
         case .hatchingChick: return "hatching chick, hatching_chick, hatchingchick"
-        case .babyChick: return "baby_chick, baby chick, babychick"
-        case .hatchedChick: return "front-facing baby chick, hatchedchick, hatched_chick"
+        case .babyChick: return "baby chick, baby_chick, babychick"
+        case .hatchedChick: return "front-facing baby chick, hatched_chick, hatchedchick"
         case .bird: return "bird"
         case .penguin: return "penguin"
-        case .doveOfPeace: return "dove, doveofpeace, dove_of_peace"
+        case .doveOfPeace: return "dove, dove_of_peace, doveofpeace"
         case .eagle: return "eagle"
         case .duck: return "duck"
         case .swan: return "swan"
@@ -615,6 +622,9 @@ extension Emoji {
         case .flamingo: return "flamingo"
         case .peacock: return "peacock"
         case .parrot: return "parrot"
+        case .wing: return "wing"
+        case .blackBird: return "black bird, black_bird, blackbird"
+        case .goose: return "goose"
         case .frog: return "frog, frog face"
         case .crocodile: return "crocodile"
         case .turtle: return "turtle"
@@ -626,57 +636,60 @@ extension Emoji {
         case .tRex: return "t-rex, trex"
         case .whale: return "spouting whale, whale"
         case .whale2: return "whale, whale2"
-        case .dolphin: return "flipper, dolphin"
+        case .dolphin: return "dolphin, flipper"
         case .seal: return "seal"
         case .fish: return "fish"
-        case .tropicalFish: return "tropical_fish, tropical fish, tropicalfish"
+        case .tropicalFish: return "tropical fish, tropical_fish, tropicalfish"
         case .blowfish: return "blowfish"
         case .shark: return "shark"
         case .octopus: return "octopus"
         case .shell: return "shell, spiral shell"
         case .coral: return "coral"
+        case .jellyfish: return "jellyfish"
         case .snail: return "snail"
         case .butterfly: return "butterfly"
         case .bug: return "bug"
         case .ant: return "ant"
         case .bee: return "bee, honeybee"
         case .beetle: return "beetle"
-        case .ladybug: return "lady_beetle, lady beetle, ladybug"
+        case .ladybug: return "lady beetle, lady_beetle, ladybug"
         case .cricket: return "cricket"
         case .cockroach: return "cockroach"
         case .spider: return "spider"
-        case .spiderWeb: return "spiderweb, spider_web, spider web"
+        case .spiderWeb: return "spider web, spider_web, spiderweb"
         case .scorpion: return "scorpion"
         case .mosquito: return "mosquito"
         case .fly: return "fly"
         case .worm: return "worm"
         case .microbe: return "microbe"
         case .bouquet: return "bouquet"
-        case .cherryBlossom: return "cherryblossom, cherry_blossom, cherry blossom"
-        case .whiteFlower: return "white_flower, white flower, whiteflower"
+        case .cherryBlossom: return "cherry blossom, cherry_blossom, cherryblossom"
+        case .whiteFlower: return "white flower, white_flower, whiteflower"
         case .lotus: return "lotus"
         case .rosette: return "rosette"
         case .rose: return "rose"
-        case .wiltedFlower: return "wilted flower, wiltedflower, wilted_flower"
+        case .wiltedFlower: return "wilted flower, wilted_flower, wiltedflower"
         case .hibiscus: return "hibiscus"
         case .sunflower: return "sunflower"
         case .blossom: return "blossom"
         case .tulip: return "tulip"
+        case .hyacinth: return "hyacinth"
         case .seedling: return "seedling"
         case .pottedPlant: return "potted plant, potted_plant, pottedplant"
-        case .evergreenTree: return "evergreen tree, evergreentree, evergreen_tree"
-        case .deciduousTree: return "deciduous_tree, deciduous tree, deciduoustree"
-        case .palmTree: return "palm tree, palmtree, palm_tree"
+        case .evergreenTree: return "evergreen tree, evergreen_tree, evergreentree"
+        case .deciduousTree: return "deciduous tree, deciduous_tree, deciduoustree"
+        case .palmTree: return "palm tree, palm_tree, palmtree"
         case .cactus: return "cactus"
-        case .earOfRice: return "earofrice, ear of rice, ear_of_rice"
+        case .earOfRice: return "ear of rice, ear_of_rice, earofrice"
         case .herb: return "herb"
         case .shamrock: return "shamrock"
         case .fourLeafClover: return "four leaf clover, four_leaf_clover, fourleafclover"
-        case .mapleLeaf: return "maple_leaf, mapleleaf, maple leaf"
-        case .fallenLeaf: return "fallen_leaf, fallen leaf, fallenleaf"
-        case .leaves: return "leaves, leaf fluttering in wind"
-        case .emptyNest: return "emptynest, empty_nest, empty nest"
-        case .nestWithEggs: return "nest_with_eggs, nest with eggs, nestwitheggs"
+        case .mapleLeaf: return "maple leaf, maple_leaf, mapleleaf"
+        case .fallenLeaf: return "fallen leaf, fallen_leaf, fallenleaf"
+        case .leaves: return "leaf fluttering in wind, leaves"
+        case .emptyNest: return "empty nest, empty_nest, emptynest"
+        case .nestWithEggs: return "nest with eggs, nest_with_eggs, nestwitheggs"
+        case .mushroom: return "mushroom"
         case .grapes: return "grapes"
         case .melon: return "melon"
         case .watermelon: return "watermelon"
@@ -685,7 +698,7 @@ extension Emoji {
         case .banana: return "banana"
         case .pineapple: return "pineapple"
         case .mango: return "mango"
-        case .apple: return "red apple, apple"
+        case .apple: return "apple, red apple"
         case .greenApple: return "green apple, green_apple, greenapple"
         case .pear: return "pear"
         case .peach: return "peach"
@@ -700,18 +713,19 @@ extension Emoji {
         case .eggplant: return "aubergine, eggplant"
         case .potato: return "potato"
         case .carrot: return "carrot"
-        case .corn: return "ear of maize, corn"
+        case .corn: return "corn, ear of maize"
         case .hotPepper: return "hot pepper, hot_pepper, hotpepper"
-        case .bellPepper: return "bell pepper, bellpepper, bell_pepper"
+        case .bellPepper: return "bell pepper, bell_pepper, bellpepper"
         case .cucumber: return "cucumber"
-        case .leafyGreen: return "leafygreen, leafy_green, leafy green"
+        case .leafyGreen: return "leafy green, leafy_green, leafygreen"
         case .broccoli: return "broccoli"
         case .garlic: return "garlic"
         case .onion: return "onion"
-        case .mushroom: return "mushroom"
         case .peanuts: return "peanuts"
         case .beans: return "beans"
         case .chestnut: return "chestnut"
+        case .gingerRoot: return "ginger root, ginger_root, gingerroot"
+        case .peaPod: return "pea pod, pea_pod, peapod"
         case .bread: return "bread"
         case .croissant: return "croissant"
         case .baguetteBread: return "baguette bread, baguette_bread, baguettebread"
@@ -720,60 +734,60 @@ extension Emoji {
         case .bagel: return "bagel"
         case .pancakes: return "pancakes"
         case .waffle: return "waffle"
-        case .cheeseWedge: return "cheesewedge, cheese wedge, cheese_wedge"
-        case .meatOnBone: return "meatonbone, meat on bone, meat_on_bone"
-        case .poultryLeg: return "poultry_leg, poultry leg, poultryleg"
-        case .cutOfMeat: return "cut of meat, cutofmeat, cut_of_meat"
+        case .cheeseWedge: return "cheese wedge, cheese_wedge, cheesewedge"
+        case .meatOnBone: return "meat on bone, meat_on_bone, meatonbone"
+        case .poultryLeg: return "poultry leg, poultry_leg, poultryleg"
+        case .cutOfMeat: return "cut of meat, cut_of_meat, cutofmeat"
         case .bacon: return "bacon"
         case .hamburger: return "hamburger"
         case .fries: return "french fries, fries"
-        case .pizza: return "slice of pizza, pizza"
-        case .hotdog: return "hotdog, hot dog"
+        case .pizza: return "pizza, slice of pizza"
+        case .hotdog: return "hot dog, hotdog"
         case .sandwich: return "sandwich"
         case .taco: return "taco"
         case .burrito: return "burrito"
         case .tamale: return "tamale"
-        case .stuffedFlatbread: return "stuffed_flatbread, stuffed flatbread, stuffedflatbread"
+        case .stuffedFlatbread: return "stuffed flatbread, stuffed_flatbread, stuffedflatbread"
         case .falafel: return "falafel"
         case .egg: return "egg"
-        case .friedEgg: return "friedegg, fried_egg, cooking"
+        case .friedEgg: return "cooking, fried_egg, friedegg"
         case .shallowPanOfFood: return "shallow pan of food, shallow_pan_of_food, shallowpanoffood"
         case .stew: return "pot of food, stew"
         case .fondue: return "fondue"
-        case .bowlWithSpoon: return "bowlwithspoon, bowl_with_spoon, bowl with spoon"
-        case .greenSalad: return "greensalad, green salad, green_salad"
+        case .bowlWithSpoon: return "bowl with spoon, bowl_with_spoon, bowlwithspoon"
+        case .greenSalad: return "green salad, green_salad, greensalad"
         case .popcorn: return "popcorn"
         case .butter: return "butter"
-        case .salt: return "salt shaker, salt"
-        case .cannedFood: return "canned_food, canned food, cannedfood"
+        case .salt: return "salt, salt shaker"
+        case .cannedFood: return "canned food, canned_food, cannedfood"
         case .bento: return "bento, bento box"
-        case .riceCracker: return "rice_cracker, ricecracker, rice cracker"
-        case .riceBall: return "rice ball, riceball, rice_ball"
-        case .rice: return "rice, cooked rice"
+        case .riceCracker: return "rice cracker, rice_cracker, ricecracker"
+        case .riceBall: return "rice ball, rice_ball, riceball"
+        case .rice: return "cooked rice, rice"
         case .curry: return "curry, curry and rice"
-        case .ramen: return "steaming bowl, ramen"
+        case .ramen: return "ramen, steaming bowl"
         case .spaghetti: return "spaghetti"
-        case .sweetPotato: return "sweet_potato, roasted sweet potato, sweetpotato"
+        case .sweetPotato: return "roasted sweet potato, sweet_potato, sweetpotato"
         case .oden: return "oden"
         case .sushi: return "sushi"
-        case .friedShrimp: return "fried_shrimp, friedshrimp, fried shrimp"
-        case .fishCake: return "fish_cake, fish cake with swirl design, fishcake"
-        case .moonCake: return "mooncake, moon_cake, moon cake"
+        case .friedShrimp: return "fried shrimp, fried_shrimp, friedshrimp"
+        case .fishCake: return "fish cake with swirl design, fish_cake, fishcake"
+        case .moonCake: return "moon cake, moon_cake, mooncake"
         case .dango: return "dango"
         case .dumpling: return "dumpling"
-        case .fortuneCookie: return "fortune_cookie, fortune cookie, fortunecookie"
-        case .takeoutBox: return "takeoutbox, takeout_box, takeout box"
+        case .fortuneCookie: return "fortune cookie, fortune_cookie, fortunecookie"
+        case .takeoutBox: return "takeout box, takeout_box, takeoutbox"
         case .crab: return "crab"
         case .lobster: return "lobster"
         case .shrimp: return "shrimp"
         case .squid: return "squid"
         case .oyster: return "oyster"
         case .icecream: return "icecream, soft ice cream"
-        case .shavedIce: return "shaved ice, shavedice, shaved_ice"
-        case .iceCream: return "ice cream, icecream, ice_cream"
+        case .shavedIce: return "shaved ice, shaved_ice, shavedice"
+        case .iceCream: return "ice cream, ice_cream, icecream"
         case .doughnut: return "doughnut"
         case .cookie: return "cookie"
-        case .birthday: return "birthday cake, birthday"
+        case .birthday: return "birthday, birthday cake"
         case .cake: return "cake, shortcake"
         case .cupcake: return "cupcake"
         case .pie: return "pie"
@@ -781,243 +795,243 @@ extension Emoji {
         case .candy: return "candy"
         case .lollipop: return "lollipop"
         case .custard: return "custard"
-        case .honeyPot: return "honey pot, honeypot, honey_pot"
-        case .babyBottle: return "baby_bottle, baby bottle, babybottle"
-        case .glassOfMilk: return "glass of milk, glassofmilk, glass_of_milk"
-        case .coffee: return "hot beverage, coffee"
+        case .honeyPot: return "honey pot, honey_pot, honeypot"
+        case .babyBottle: return "baby bottle, baby_bottle, babybottle"
+        case .glassOfMilk: return "glass of milk, glass_of_milk, glassofmilk"
+        case .coffee: return "coffee, hot beverage"
         case .teapot: return "teapot"
         case .tea: return "tea, teacup without handle"
-        case .sake: return "sake bottle and cup, sake"
-        case .champagne: return "champagne, bottle with popping cork"
-        case .wineGlass: return "wine_glass, wine glass, wineglass"
+        case .sake: return "sake, sake bottle and cup"
+        case .champagne: return "bottle with popping cork, champagne"
+        case .wineGlass: return "wine glass, wine_glass, wineglass"
         case .cocktail: return "cocktail, cocktail glass"
-        case .tropicalDrink: return "tropicaldrink, tropical drink, tropical_drink"
+        case .tropicalDrink: return "tropical drink, tropical_drink, tropicaldrink"
         case .beer: return "beer, beer mug"
         case .beers: return "beers, clinking beer mugs"
-        case .clinkingGlasses: return "clinkingglasses, clinking_glasses, clinking glasses"
-        case .tumblerGlass: return "tumbler glass, tumblerglass, tumbler_glass"
-        case .pouringLiquid: return "pouring_liquid, pouring liquid, pouringliquid"
-        case .cupWithStraw: return "cup with straw, cupwithstraw, cup_with_straw"
-        case .bubbleTea: return "bubbletea, bubble_tea, bubble tea"
+        case .clinkingGlasses: return "clinking glasses, clinking_glasses, clinkingglasses"
+        case .tumblerGlass: return "tumbler glass, tumbler_glass, tumblerglass"
+        case .pouringLiquid: return "pouring liquid, pouring_liquid, pouringliquid"
+        case .cupWithStraw: return "cup with straw, cup_with_straw, cupwithstraw"
+        case .bubbleTea: return "bubble tea, bubble_tea, bubbletea"
         case .beverageBox: return "beverage box, beverage_box, beveragebox"
-        case .mateDrink: return "mate_drink, mate drink, matedrink"
-        case .iceCube: return "ice_cube, ice cube, icecube"
+        case .mateDrink: return "mate drink, mate_drink, matedrink"
+        case .iceCube: return "ice cube, ice_cube, icecube"
         case .chopsticks: return "chopsticks"
-        case .knifeForkPlate: return "fork and knife with plate, knifeforkplate, knife_fork_plate"
-        case .forkAndKnife: return "forkandknife, fork and knife, fork_and_knife"
+        case .knifeForkPlate: return "fork and knife with plate, knife_fork_plate, knifeforkplate"
+        case .forkAndKnife: return "fork and knife, fork_and_knife, forkandknife"
         case .spoon: return "spoon"
         case .hocho: return "hocho, knife"
         case .jar: return "jar"
         case .amphora: return "amphora"
         case .earthAfrica: return "earth globe europe-africa, earth_africa, earthafrica"
-        case .earthAmericas: return "earth globe americas, earthamericas, earth_americas"
-        case .earthAsia: return "earthasia, earth_asia, earth globe asia-australia"
-        case .globeWithMeridians: return "globewithmeridians, globe_with_meridians, globe with meridians"
-        case .worldMap: return "world_map, world map, worldmap"
+        case .earthAmericas: return "earth globe americas, earth_americas, earthamericas"
+        case .earthAsia: return "earth globe asia-australia, earth_asia, earthasia"
+        case .globeWithMeridians: return "globe with meridians, globe_with_meridians, globewithmeridians"
+        case .worldMap: return "world map, world_map, worldmap"
         case .japan: return "japan, silhouette of japan"
         case .compass: return "compass"
-        case .snowCappedMountain: return "snow_capped_mountain, snow-capped mountain, snowcappedmountain"
+        case .snowCappedMountain: return "snow-capped mountain, snow_capped_mountain, snowcappedmountain"
         case .mountain: return "mountain"
         case .volcano: return "volcano"
-        case .mountFuji: return "mount_fuji, mount fuji, mountfuji"
+        case .mountFuji: return "mount fuji, mount_fuji, mountfuji"
         case .camping: return "camping"
         case .beachWithUmbrella: return "beach with umbrella, beach_with_umbrella, beachwithumbrella"
         case .desert: return "desert"
-        case .desertIsland: return "desert_island, desert island, desertisland"
-        case .nationalPark: return "nationalpark, national_park, national park"
+        case .desertIsland: return "desert island, desert_island, desertisland"
+        case .nationalPark: return "national park, national_park, nationalpark"
         case .stadium: return "stadium"
-        case .classicalBuilding: return "classical_building, classical building, classicalbuilding"
-        case .buildingConstruction: return "building_construction, buildingconstruction, building construction"
+        case .classicalBuilding: return "classical building, classical_building, classicalbuilding"
+        case .buildingConstruction: return "building construction, building_construction, buildingconstruction"
         case .bricks: return "brick, bricks"
         case .rock: return "rock"
         case .wood: return "wood"
         case .hut: return "hut"
-        case .houseBuildings: return "housebuildings, house_buildings, houses"
-        case .derelictHouseBuilding: return "derelict_house_building, derelict house, derelicthousebuilding"
+        case .houseBuildings: return "house_buildings, housebuildings, houses"
+        case .derelictHouseBuilding: return "derelict house, derelict_house_building, derelicthousebuilding"
         case .house: return "house, house building"
         case .houseWithGarden: return "house with garden, house_with_garden, housewithgarden"
-        case .office: return "office building, office"
-        case .postOffice: return "post_office, japanese post office, postoffice"
+        case .office: return "office, office building"
+        case .postOffice: return "japanese post office, post_office, postoffice"
         case .europeanPostOffice: return "european post office, european_post_office, europeanpostoffice"
         case .hospital: return "hospital"
         case .bank: return "bank"
         case .hotel: return "hotel"
-        case .loveHotel: return "love_hotel, love hotel, lovehotel"
-        case .convenienceStore: return "convenience store, conveniencestore, convenience_store"
+        case .loveHotel: return "love hotel, love_hotel, lovehotel"
+        case .convenienceStore: return "convenience store, convenience_store, conveniencestore"
         case .school: return "school"
-        case .departmentStore: return "department_store, department store, departmentstore"
+        case .departmentStore: return "department store, department_store, departmentstore"
         case .factory: return "factory"
-        case .japaneseCastle: return "japanese_castle, japanese castle, japanesecastle"
-        case .europeanCastle: return "europeancastle, european_castle, european castle"
+        case .japaneseCastle: return "japanese castle, japanese_castle, japanesecastle"
+        case .europeanCastle: return "european castle, european_castle, europeancastle"
         case .wedding: return "wedding"
-        case .tokyoTower: return "tokyo tower, tokyotower, tokyo_tower"
-        case .statueOfLiberty: return "statue of liberty, statueofliberty, statue_of_liberty"
+        case .tokyoTower: return "tokyo tower, tokyo_tower, tokyotower"
+        case .statueOfLiberty: return "statue of liberty, statue_of_liberty, statueofliberty"
         case .church: return "church"
         case .mosque: return "mosque"
         case .hinduTemple: return "hindu temple, hindu_temple, hindutemple"
         case .synagogue: return "synagogue"
-        case .shintoShrine: return "shinto shrine, shintoshrine, shinto_shrine"
+        case .shintoShrine: return "shinto shrine, shinto_shrine, shintoshrine"
         case .kaaba: return "kaaba"
         case .fountain: return "fountain"
         case .tent: return "tent"
         case .foggy: return "foggy"
-        case .nightWithStars: return "night with stars, nightwithstars, night_with_stars"
+        case .nightWithStars: return "night with stars, night_with_stars, nightwithstars"
         case .cityscape: return "cityscape"
-        case .sunriseOverMountains: return "sunrise_over_mountains, sunrise over mountains, sunriseovermountains"
+        case .sunriseOverMountains: return "sunrise over mountains, sunrise_over_mountains, sunriseovermountains"
         case .sunrise: return "sunrise"
-        case .citySunset: return "cityscape at dusk, city_sunset, citysunset"
-        case .citySunrise: return "city_sunrise, sunset over buildings, citysunrise"
+        case .citySunset: return "city_sunset, cityscape at dusk, citysunset"
+        case .citySunrise: return "city_sunrise, citysunrise, sunset over buildings"
         case .bridgeAtNight: return "bridge at night, bridge_at_night, bridgeatnight"
-        case .hotsprings: return "hotsprings, hot springs"
+        case .hotsprings: return "hot springs, hotsprings"
         case .carouselHorse: return "carousel horse, carousel_horse, carouselhorse"
-        case .playgroundSlide: return "playground_slide, playground slide, playgroundslide"
-        case .ferrisWheel: return "ferris_wheel, ferriswheel, ferris wheel"
-        case .rollerCoaster: return "roller_coaster, rollercoaster, roller coaster"
-        case .barber: return "barber pole, barber"
-        case .circusTent: return "circus tent, circustent, circus_tent"
-        case .steamLocomotive: return "steam_locomotive, steam locomotive, steamlocomotive"
-        case .railwayCar: return "railwaycar, railway_car, railway car"
-        case .bullettrainSide: return "high-speed train, bullettrain_side, bullettrainside"
-        case .bullettrainFront: return "high-speed train with bullet nose, bullettrain_front, bullettrainfront"
-        case .train2: return "train2, train"
+        case .playgroundSlide: return "playground slide, playground_slide, playgroundslide"
+        case .ferrisWheel: return "ferris wheel, ferris_wheel, ferriswheel"
+        case .rollerCoaster: return "roller coaster, roller_coaster, rollercoaster"
+        case .barber: return "barber, barber pole"
+        case .circusTent: return "circus tent, circus_tent, circustent"
+        case .steamLocomotive: return "steam locomotive, steam_locomotive, steamlocomotive"
+        case .railwayCar: return "railway car, railway_car, railwaycar"
+        case .bullettrainSide: return "bullettrain_side, bullettrainside, high-speed train"
+        case .bullettrainFront: return "bullettrain_front, bullettrainfront, high-speed train with bullet nose"
+        case .train2: return "train, train2"
         case .metro: return "metro"
         case .lightRail: return "light rail, light_rail, lightrail"
         case .station: return "station"
         case .tram: return "tram"
         case .monorail: return "monorail"
-        case .mountainRailway: return "mountain railway, mountainrailway, mountain_railway"
+        case .mountainRailway: return "mountain railway, mountain_railway, mountainrailway"
         case .train: return "train, tram car"
         case .bus: return "bus"
-        case .oncomingBus: return "oncoming bus, oncomingbus, oncoming_bus"
+        case .oncomingBus: return "oncoming bus, oncoming_bus, oncomingbus"
         case .trolleybus: return "trolleybus"
         case .minibus: return "minibus"
         case .ambulance: return "ambulance"
-        case .fireEngine: return "fire_engine, fire engine, fireengine"
-        case .policeCar: return "police_car, policecar, police car"
-        case .oncomingPoliceCar: return "oncoming_police_car, oncomingpolicecar, oncoming police car"
+        case .fireEngine: return "fire engine, fire_engine, fireengine"
+        case .policeCar: return "police car, police_car, policecar"
+        case .oncomingPoliceCar: return "oncoming police car, oncoming_police_car, oncomingpolicecar"
         case .taxi: return "taxi"
-        case .oncomingTaxi: return "oncoming_taxi, oncoming taxi, oncomingtaxi"
-        case .car: return "car, red_car, automobile"
+        case .oncomingTaxi: return "oncoming taxi, oncoming_taxi, oncomingtaxi"
+        case .car: return "automobile, car, red_car"
         case .oncomingAutomobile: return "oncoming automobile, oncoming_automobile, oncomingautomobile"
-        case .blueCar: return "bluecar, blue_car, recreational vehicle"
-        case .pickupTruck: return "pickup_truck, pickup truck, pickuptruck"
+        case .blueCar: return "blue_car, bluecar, recreational vehicle"
+        case .pickupTruck: return "pickup truck, pickup_truck, pickuptruck"
         case .truck: return "delivery truck, truck"
-        case .articulatedLorry: return "articulated_lorry, articulated lorry, articulatedlorry"
+        case .articulatedLorry: return "articulated lorry, articulated_lorry, articulatedlorry"
         case .tractor: return "tractor"
-        case .racingCar: return "racing car, racingcar, racing_car"
-        case .racingMotorcycle: return "racing_motorcycle, motorcycle, racingmotorcycle"
+        case .racingCar: return "racing car, racing_car, racingcar"
+        case .racingMotorcycle: return "motorcycle, racing_motorcycle, racingmotorcycle"
         case .motorScooter: return "motor scooter, motor_scooter, motorscooter"
-        case .manualWheelchair: return "manual_wheelchair, manualwheelchair, manual wheelchair"
-        case .motorizedWheelchair: return "motorized_wheelchair, motorized wheelchair, motorizedwheelchair"
+        case .manualWheelchair: return "manual wheelchair, manual_wheelchair, manualwheelchair"
+        case .motorizedWheelchair: return "motorized wheelchair, motorized_wheelchair, motorizedwheelchair"
         case .autoRickshaw: return "auto rickshaw, auto_rickshaw, autorickshaw"
         case .bike: return "bicycle, bike"
         case .scooter: return "scooter"
         case .skateboard: return "skateboard"
-        case .rollerSkate: return "roller skate, rollerskate, roller_skate"
+        case .rollerSkate: return "roller skate, roller_skate, rollerskate"
         case .busstop: return "bus stop, busstop"
         case .motorway: return "motorway"
-        case .railwayTrack: return "railwaytrack, railway track, railway_track"
-        case .oilDrum: return "oil_drum, oil drum, oildrum"
-        case .fuelpump: return "fuelpump, fuel pump"
+        case .railwayTrack: return "railway track, railway_track, railwaytrack"
+        case .oilDrum: return "oil drum, oil_drum, oildrum"
+        case .fuelpump: return "fuel pump, fuelpump"
         case .wheel: return "wheel"
         case .rotatingLight: return "police cars revolving light, rotating_light, rotatinglight"
-        case .trafficLight: return "horizontal traffic light, trafficlight, traffic_light"
-        case .verticalTrafficLight: return "verticaltrafficlight, vertical traffic light, vertical_traffic_light"
-        case .octagonalSign: return "octagonal_sign, octagonalsign, octagonal sign"
-        case .construction: return "construction sign, construction"
+        case .trafficLight: return "horizontal traffic light, traffic_light, trafficlight"
+        case .verticalTrafficLight: return "vertical traffic light, vertical_traffic_light, verticaltrafficlight"
+        case .octagonalSign: return "octagonal sign, octagonal_sign, octagonalsign"
+        case .construction: return "construction, construction sign"
         case .anchor: return "anchor"
-        case .ringBuoy: return "ring_buoy, ringbuoy, ring buoy"
-        case .boat: return "sailboat, boat"
+        case .ringBuoy: return "ring buoy, ring_buoy, ringbuoy"
+        case .boat: return "boat, sailboat"
         case .canoe: return "canoe"
         case .speedboat: return "speedboat"
-        case .passengerShip: return "passenger_ship, passenger ship, passengership"
+        case .passengerShip: return "passenger ship, passenger_ship, passengership"
         case .ferry: return "ferry"
-        case .motorBoat: return "motorboat, motor_boat, motor boat"
+        case .motorBoat: return "motor boat, motor_boat, motorboat"
         case .ship: return "ship"
         case .airplane: return "airplane"
-        case .smallAirplane: return "small_airplane, smallairplane, small airplane"
+        case .smallAirplane: return "small airplane, small_airplane, smallairplane"
         case .airplaneDeparture: return "airplane departure, airplane_departure, airplanedeparture"
         case .airplaneArriving: return "airplane arriving, airplane_arriving, airplanearriving"
         case .parachute: return "parachute"
         case .seat: return "seat"
         case .helicopter: return "helicopter"
-        case .suspensionRailway: return "suspension_railway, suspension railway, suspensionrailway"
-        case .mountainCableway: return "mountain_cableway, mountain cableway, mountaincableway"
-        case .aerialTramway: return "aerial tramway, aerialtramway, aerial_tramway"
+        case .suspensionRailway: return "suspension railway, suspension_railway, suspensionrailway"
+        case .mountainCableway: return "mountain cableway, mountain_cableway, mountaincableway"
+        case .aerialTramway: return "aerial tramway, aerial_tramway, aerialtramway"
         case .satellite: return "satellite"
         case .rocket: return "rocket"
-        case .flyingSaucer: return "flying saucer, flyingsaucer, flying_saucer"
-        case .bellhopBell: return "bellhop_bell, bellhop bell, bellhopbell"
+        case .flyingSaucer: return "flying saucer, flying_saucer, flyingsaucer"
+        case .bellhopBell: return "bellhop bell, bellhop_bell, bellhopbell"
         case .luggage: return "luggage"
         case .hourglass: return "hourglass"
         case .hourglassFlowingSand: return "hourglass with flowing sand, hourglass_flowing_sand, hourglassflowingsand"
         case .watch: return "watch"
-        case .alarmClock: return "alarm_clock, alarmclock, alarm clock"
+        case .alarmClock: return "alarm clock, alarm_clock, alarmclock"
         case .stopwatch: return "stopwatch"
-        case .timerClock: return "timer_clock, timerclock, timer clock"
-        case .mantelpieceClock: return "mantelpiece_clock, mantelpiece clock, mantelpiececlock"
-        case .clock12: return "clock12, clock face twelve oclock"
+        case .timerClock: return "timer clock, timer_clock, timerclock"
+        case .mantelpieceClock: return "mantelpiece clock, mantelpiece_clock, mantelpiececlock"
+        case .clock12: return "clock face twelve oclock, clock12"
         case .clock1230: return "clock face twelve-thirty, clock1230"
         case .clock1: return "clock face one oclock, clock1"
-        case .clock130: return "clock130, clock face one-thirty"
+        case .clock130: return "clock face one-thirty, clock130"
         case .clock2: return "clock face two oclock, clock2"
-        case .clock230: return "clock230, clock face two-thirty"
-        case .clock3: return "clock3, clock face three oclock"
-        case .clock330: return "clock330, clock face three-thirty"
+        case .clock230: return "clock face two-thirty, clock230"
+        case .clock3: return "clock face three oclock, clock3"
+        case .clock330: return "clock face three-thirty, clock330"
         case .clock4: return "clock face four oclock, clock4"
-        case .clock430: return "clock430, clock face four-thirty"
+        case .clock430: return "clock face four-thirty, clock430"
         case .clock5: return "clock face five oclock, clock5"
-        case .clock530: return "clock530, clock face five-thirty"
-        case .clock6: return "clock6, clock face six oclock"
+        case .clock530: return "clock face five-thirty, clock530"
+        case .clock6: return "clock face six oclock, clock6"
         case .clock630: return "clock face six-thirty, clock630"
         case .clock7: return "clock face seven oclock, clock7"
         case .clock730: return "clock face seven-thirty, clock730"
         case .clock8: return "clock face eight oclock, clock8"
         case .clock830: return "clock face eight-thirty, clock830"
         case .clock9: return "clock face nine oclock, clock9"
-        case .clock930: return "clock930, clock face nine-thirty"
-        case .clock10: return "clock10, clock face ten oclock"
-        case .clock1030: return "clock1030, clock face ten-thirty"
+        case .clock930: return "clock face nine-thirty, clock930"
+        case .clock10: return "clock face ten oclock, clock10"
+        case .clock1030: return "clock face ten-thirty, clock1030"
         case .clock11: return "clock face eleven oclock, clock11"
-        case .clock1130: return "clock1130, clock face eleven-thirty"
-        case .newMoon: return "new moon symbol, newmoon, new_moon"
+        case .clock1130: return "clock face eleven-thirty, clock1130"
+        case .newMoon: return "new moon symbol, new_moon, newmoon"
         case .waxingCrescentMoon: return "waxing crescent moon symbol, waxing_crescent_moon, waxingcrescentmoon"
-        case .firstQuarterMoon: return "firstquartermoon, first_quarter_moon, first quarter moon symbol"
-        case .moon: return "waxing gibbous moon symbol, waxing_gibbous_moon, moon"
-        case .fullMoon: return "full_moon, full moon symbol, fullmoon"
-        case .waningGibbousMoon: return "waning_gibbous_moon, waning gibbous moon symbol, waninggibbousmoon"
-        case .lastQuarterMoon: return "lastquartermoon, last_quarter_moon, last quarter moon symbol"
-        case .waningCrescentMoon: return "waning_crescent_moon, waning crescent moon symbol, waningcrescentmoon"
-        case .crescentMoon: return "crescent_moon, crescent moon, crescentmoon"
-        case .newMoonWithFace: return "newmoonwithface, new_moon_with_face, new moon with face"
+        case .firstQuarterMoon: return "first quarter moon symbol, first_quarter_moon, firstquartermoon"
+        case .moon: return "moon, waxing gibbous moon symbol, waxing_gibbous_moon"
+        case .fullMoon: return "full moon symbol, full_moon, fullmoon"
+        case .waningGibbousMoon: return "waning gibbous moon symbol, waning_gibbous_moon, waninggibbousmoon"
+        case .lastQuarterMoon: return "last quarter moon symbol, last_quarter_moon, lastquartermoon"
+        case .waningCrescentMoon: return "waning crescent moon symbol, waning_crescent_moon, waningcrescentmoon"
+        case .crescentMoon: return "crescent moon, crescent_moon, crescentmoon"
+        case .newMoonWithFace: return "new moon with face, new_moon_with_face, newmoonwithface"
         case .firstQuarterMoonWithFace: return "first quarter moon with face, first_quarter_moon_with_face, firstquartermoonwithface"
-        case .lastQuarterMoonWithFace: return "lastquartermoonwithface, last_quarter_moon_with_face, last quarter moon with face"
+        case .lastQuarterMoonWithFace: return "last quarter moon with face, last_quarter_moon_with_face, lastquartermoonwithface"
         case .thermometer: return "thermometer"
         case .sunny: return "black sun with rays, sunny"
-        case .fullMoonWithFace: return "full_moon_with_face, full moon with face, fullmoonwithface"
-        case .sunWithFace: return "sun_with_face, sunwithface, sun with face"
-        case .ringedPlanet: return "ringed_planet, ringed planet, ringedplanet"
+        case .fullMoonWithFace: return "full moon with face, full_moon_with_face, fullmoonwithface"
+        case .sunWithFace: return "sun with face, sun_with_face, sunwithface"
+        case .ringedPlanet: return "ringed planet, ringed_planet, ringedplanet"
         case .star: return "star, white medium star"
-        case .star2: return "star2, glowing star"
+        case .star2: return "glowing star, star2"
         case .stars: return "shooting star, stars"
         case .milkyWay: return "milky way, milky_way, milkyway"
         case .cloud: return "cloud"
-        case .partlySunny: return "partly_sunny, sun behind cloud, partlysunny"
-        case .thunderCloudAndRain: return "thunder_cloud_and_rain, cloud with lightning and rain, thundercloudandrain"
-        case .mostlySunny: return "sun_small_cloud, mostlysunny, sun behind small cloud, mostly_sunny"
-        case .barelySunny: return "sun_behind_cloud, barely_sunny, sun behind large cloud, barelysunny"
-        case .partlySunnyRain: return "sun behind rain cloud, partly_sunny_rain, partlysunnyrain, sun_behind_rain_cloud"
-        case .rainCloud: return "cloud with rain, raincloud, rain_cloud"
-        case .snowCloud: return "snow_cloud, snowcloud, cloud with snow"
+        case .partlySunny: return "partly_sunny, partlysunny, sun behind cloud"
+        case .thunderCloudAndRain: return "cloud with lightning and rain, thunder_cloud_and_rain, thundercloudandrain"
+        case .mostlySunny: return "mostly_sunny, mostlysunny, sun behind small cloud, sun_small_cloud"
+        case .barelySunny: return "barely_sunny, barelysunny, sun behind large cloud, sun_behind_cloud"
+        case .partlySunnyRain: return "partly_sunny_rain, partlysunnyrain, sun behind rain cloud, sun_behind_rain_cloud"
+        case .rainCloud: return "cloud with rain, rain_cloud, raincloud"
+        case .snowCloud: return "cloud with snow, snow_cloud, snowcloud"
         case .lightning: return "cloud with lightning, lightning, lightning_cloud"
         case .tornado: return "tornado, tornado_cloud"
         case .fog: return "fog"
         case .windBlowingFace: return "wind face, wind_blowing_face, windblowingface"
         case .cyclone: return "cyclone"
         case .rainbow: return "rainbow"
-        case .closedUmbrella: return "closed_umbrella, closedumbrella, closed umbrella"
+        case .closedUmbrella: return "closed umbrella, closed_umbrella, closedumbrella"
         case .umbrella: return "umbrella"
-        case .umbrellaWithRainDrops: return "umbrella with rain drops, umbrellawithraindrops, umbrella_with_rain_drops"
+        case .umbrellaWithRainDrops: return "umbrella with rain drops, umbrella_with_rain_drops, umbrellawithraindrops"
         case .umbrellaOnGround: return "umbrella on ground, umbrella_on_ground, umbrellaonground"
         case .zap: return "high voltage sign, zap"
         case .snowflake: return "snowflake"
@@ -1028,98 +1042,97 @@ extension Emoji {
         case .droplet: return "droplet"
         case .ocean: return "ocean, water wave"
         case .jackOLantern: return "jack-o-lantern, jack_o_lantern, jackolantern"
-        case .christmasTree: return "christmastree, christmas_tree, christmas tree"
+        case .christmasTree: return "christmas tree, christmas_tree, christmastree"
         case .fireworks: return "fireworks"
-        case .sparkler: return "sparkler, firework sparkler"
+        case .sparkler: return "firework sparkler, sparkler"
         case .firecracker: return "firecracker"
         case .sparkles: return "sparkles"
         case .balloon: return "balloon"
-        case .tada: return "tada, party popper"
-        case .confettiBall: return "confetti_ball, confettiball, confetti ball"
-        case .tanabataTree: return "tanabatatree, tanabata tree, tanabata_tree"
+        case .tada: return "party popper, tada"
+        case .confettiBall: return "confetti ball, confetti_ball, confettiball"
+        case .tanabataTree: return "tanabata tree, tanabata_tree, tanabatatree"
         case .bamboo: return "bamboo, pine decoration"
         case .dolls: return "dolls, japanese dolls"
-        case .flags: return "flags, carp streamer"
-        case .windChime: return "windchime, wind_chime, wind chime"
+        case .flags: return "carp streamer, flags"
+        case .windChime: return "wind chime, wind_chime, windchime"
         case .riceScene: return "moon viewing ceremony, rice_scene, ricescene"
-        case .redEnvelope: return "red gift envelope, redenvelope, red_envelope"
+        case .redEnvelope: return "red gift envelope, red_envelope, redenvelope"
         case .ribbon: return "ribbon"
         case .gift: return "gift, wrapped present"
-        case .reminderRibbon: return "reminder ribbon, reminderribbon, reminder_ribbon"
-        case .admissionTickets: return "admission_tickets, admission tickets, admissiontickets"
+        case .reminderRibbon: return "reminder ribbon, reminder_ribbon, reminderribbon"
+        case .admissionTickets: return "admission tickets, admission_tickets, admissiontickets"
         case .ticket: return "ticket"
         case .medal: return "medal, military medal"
         case .trophy: return "trophy"
-        case .sportsMedal: return "sportsmedal, sports medal, sports_medal"
-        case .firstPlaceMedal: return "first place medal, firstplacemedal, first_place_medal"
-        case .secondPlaceMedal: return "secondplacemedal, second_place_medal, second place medal"
-        case .thirdPlaceMedal: return "third_place_medal, thirdplacemedal, third place medal"
-        case .soccer: return "soccer ball, soccer"
+        case .sportsMedal: return "sports medal, sports_medal, sportsmedal"
+        case .firstPlaceMedal: return "first place medal, first_place_medal, firstplacemedal"
+        case .secondPlaceMedal: return "second place medal, second_place_medal, secondplacemedal"
+        case .thirdPlaceMedal: return "third place medal, third_place_medal, thirdplacemedal"
+        case .soccer: return "soccer, soccer ball"
         case .baseball: return "baseball"
         case .softball: return "softball"
-        case .basketball: return "basketball and hoop, basketball"
+        case .basketball: return "basketball, basketball and hoop"
         case .volleyball: return "volleyball"
-        case .football: return "football, american football"
-        case .rugbyFootball: return "rugby_football, rugby football, rugbyfootball"
+        case .football: return "american football, football"
+        case .rugbyFootball: return "rugby football, rugby_football, rugbyfootball"
         case .tennis: return "tennis, tennis racquet and ball"
-        case .flyingDisc: return "flying_disc, flyingdisc, flying disc"
+        case .flyingDisc: return "flying disc, flying_disc, flyingdisc"
         case .bowling: return "bowling"
-        case .cricketBatAndBall: return "cricket_bat_and_ball, cricketbatandball, cricket bat and ball"
-        case .fieldHockeyStickAndBall: return "field_hockey_stick_and_ball, field hockey stick and ball, fieldhockeystickandball"
-        case .iceHockeyStickAndPuck: return "ice_hockey_stick_and_puck, ice hockey stick and puck, icehockeystickandpuck"
-        case .lacrosse: return "lacrosse stick and ball, lacrosse"
+        case .cricketBatAndBall: return "cricket bat and ball, cricket_bat_and_ball, cricketbatandball"
+        case .fieldHockeyStickAndBall: return "field hockey stick and ball, field_hockey_stick_and_ball, fieldhockeystickandball"
+        case .iceHockeyStickAndPuck: return "ice hockey stick and puck, ice_hockey_stick_and_puck, icehockeystickandpuck"
+        case .lacrosse: return "lacrosse, lacrosse stick and ball"
         case .tableTennisPaddleAndBall: return "table tennis paddle and ball, table_tennis_paddle_and_ball, tabletennispaddleandball"
-        case .badmintonRacquetAndShuttlecock: return "badminton_racquet_and_shuttlecock, badminton racquet and shuttlecock, badmintonracquetandshuttlecock"
-        case .boxingGlove: return "boxing_glove, boxing glove, boxingglove"
-        case .martialArtsUniform: return "martial_arts_uniform, martial arts uniform, martialartsuniform"
-        case .goalNet: return "goalnet, goal net, goal_net"
-        case .golf: return "golf, flag in hole"
-        case .iceSkate: return "ice skate, iceskate, ice_skate"
-        case .fishingPoleAndFish: return "fishing pole and fish, fishingpoleandfish, fishing_pole_and_fish"
-        case .divingMask: return "divingmask, diving_mask, diving mask"
+        case .badmintonRacquetAndShuttlecock: return "badminton racquet and shuttlecock, badminton_racquet_and_shuttlecock, badmintonracquetandshuttlecock"
+        case .boxingGlove: return "boxing glove, boxing_glove, boxingglove"
+        case .martialArtsUniform: return "martial arts uniform, martial_arts_uniform, martialartsuniform"
+        case .goalNet: return "goal net, goal_net, goalnet"
+        case .golf: return "flag in hole, golf"
+        case .iceSkate: return "ice skate, ice_skate, iceskate"
+        case .fishingPoleAndFish: return "fishing pole and fish, fishing_pole_and_fish, fishingpoleandfish"
+        case .divingMask: return "diving mask, diving_mask, divingmask"
         case .runningShirtWithSash: return "running shirt with sash, running_shirt_with_sash, runningshirtwithsash"
         case .ski: return "ski, ski and ski boot"
         case .sled: return "sled"
-        case .curlingStone: return "curling_stone, curling stone, curlingstone"
+        case .curlingStone: return "curling stone, curling_stone, curlingstone"
         case .dart: return "dart, direct hit"
         case .yoYo: return "yo-yo, yoyo"
         case .kite: return "kite"
+        case .gun: return "gun, pistol"
         case .eightBall: return "8ball, billiards, eightball"
-        case .crystalBall: return "crystal ball, crystalball, crystal_ball"
-        case .magicWand: return "magic wand, magicwand, magic_wand"
-        case .nazarAmulet: return "nazar amulet, nazaramulet, nazar_amulet"
-        case .hamsa: return "hamsa"
-        case .videoGame: return "video_game, video game, videogame"
+        case .crystalBall: return "crystal ball, crystal_ball, crystalball"
+        case .magicWand: return "magic wand, magic_wand, magicwand"
+        case .videoGame: return "video game, video_game, videogame"
         case .joystick: return "joystick"
-        case .slotMachine: return "slotmachine, slot_machine, slot machine"
-        case .gameDie: return "gamedie, game die, game_die"
+        case .slotMachine: return "slot machine, slot_machine, slotmachine"
+        case .gameDie: return "game die, game_die, gamedie"
         case .jigsaw: return "jigsaw, jigsaw puzzle piece"
-        case .teddyBear: return "teddy_bear, teddy bear, teddybear"
+        case .teddyBear: return "teddy bear, teddy_bear, teddybear"
         case .pinata: return "pinata"
-        case .mirrorBall: return "mirrorball, mirror ball, mirror_ball"
-        case .nestingDolls: return "nesting dolls, nestingdolls, nesting_dolls"
+        case .mirrorBall: return "mirror ball, mirror_ball, mirrorball"
+        case .nestingDolls: return "nesting dolls, nesting_dolls, nestingdolls"
         case .spades: return "black spade suit, spades"
         case .hearts: return "black heart suit, hearts"
-        case .diamonds: return "diamonds, black diamond suit"
-        case .clubs: return "clubs, black club suit"
-        case .chessPawn: return "chess_pawn, chess pawn, chesspawn"
+        case .diamonds: return "black diamond suit, diamonds"
+        case .clubs: return "black club suit, clubs"
+        case .chessPawn: return "chess pawn, chess_pawn, chesspawn"
         case .blackJoker: return "black_joker, blackjoker, playing card black joker"
         case .mahjong: return "mahjong, mahjong tile red dragon"
-        case .flowerPlayingCards: return "flower playing cards, flowerplayingcards, flower_playing_cards"
-        case .performingArts: return "performingarts, performing_arts, performing arts"
-        case .frameWithPicture: return "framed picture, framewithpicture, frame_with_picture"
+        case .flowerPlayingCards: return "flower playing cards, flower_playing_cards, flowerplayingcards"
+        case .performingArts: return "performing arts, performing_arts, performingarts"
+        case .frameWithPicture: return "frame_with_picture, framed picture, framewithpicture"
         case .art: return "art, artist palette"
-        case .thread: return "thread, spool of thread"
-        case .sewingNeedle: return "sewing needle, sewingneedle, sewing_needle"
+        case .thread: return "spool of thread, thread"
+        case .sewingNeedle: return "sewing needle, sewing_needle, sewingneedle"
         case .yarn: return "ball of yarn, yarn"
         case .knot: return "knot"
         case .eyeglasses: return "eyeglasses"
-        case .darkSunglasses: return "sunglasses, darksunglasses, dark_sunglasses"
+        case .darkSunglasses: return "dark_sunglasses, darksunglasses, sunglasses"
         case .goggles: return "goggles"
-        case .labCoat: return "lab_coat, lab coat, labcoat"
-        case .safetyVest: return "safety_vest, safetyvest, safety vest"
+        case .labCoat: return "lab coat, lab_coat, labcoat"
+        case .safetyVest: return "safety vest, safety_vest, safetyvest"
         case .necktie: return "necktie"
-        case .shirt: return "t-shirt, shirt, tshirt"
+        case .shirt: return "shirt, t-shirt, tshirt"
         case .jeans: return "jeans"
         case .scarf: return "scarf"
         case .gloves: return "gloves"
@@ -1128,31 +1141,33 @@ extension Emoji {
         case .dress: return "dress"
         case .kimono: return "kimono"
         case .sari: return "sari"
-        case .onePieceSwimsuit: return "one-piece swimsuit, onepieceswimsuit, one-piece_swimsuit"
+        case .onePieceSwimsuit: return "one-piece swimsuit, one-piece_swimsuit, onepieceswimsuit"
         case .briefs: return "briefs"
         case .shorts: return "shorts"
         case .bikini: return "bikini"
-        case .womansClothes: return "womans_clothes, womansclothes, womans clothes"
+        case .womansClothes: return "womans clothes, womans_clothes, womansclothes"
+        case .foldingHandFan: return "folding hand fan, folding_hand_fan, foldinghandfan"
         case .purse: return "purse"
         case .handbag: return "handbag"
         case .pouch: return "pouch"
-        case .shoppingBags: return "shopping bags, shoppingbags, shopping_bags"
-        case .schoolSatchel: return "school satchel, schoolsatchel, school_satchel"
-        case .thongSandal: return "thong_sandal, thongsandal, thong sandal"
-        case .mansShoe: return "mans_shoe, shoe, mans shoe, mansshoe"
-        case .athleticShoe: return "athletic_shoe, athletic shoe, athleticshoe"
-        case .hikingBoot: return "hikingboot, hiking boot, hiking_boot"
-        case .womansFlatShoe: return "flat shoe, womansflatshoe, womans_flat_shoe"
+        case .shoppingBags: return "shopping bags, shopping_bags, shoppingbags"
+        case .schoolSatchel: return "school satchel, school_satchel, schoolsatchel"
+        case .thongSandal: return "thong sandal, thong_sandal, thongsandal"
+        case .mansShoe: return "mans shoe, mans_shoe, mansshoe, shoe"
+        case .athleticShoe: return "athletic shoe, athletic_shoe, athleticshoe"
+        case .hikingBoot: return "hiking boot, hiking_boot, hikingboot"
+        case .womansFlatShoe: return "flat shoe, womans_flat_shoe, womansflatshoe"
         case .highHeel: return "high-heeled shoe, high_heel, highheel"
         case .sandal: return "sandal, womans sandal"
-        case .balletShoes: return "balletshoes, ballet_shoes, ballet shoes"
+        case .balletShoes: return "ballet shoes, ballet_shoes, balletshoes"
         case .boot: return "boot, womans boots"
+        case .hairPick: return "hair pick, hair_pick, hairpick"
         case .crown: return "crown"
-        case .womansHat: return "womans_hat, womanshat, womans hat"
-        case .tophat: return "tophat, top hat"
-        case .mortarBoard: return "mortarboard, mortar_board, graduation cap"
-        case .billedCap: return "billed_cap, billed cap, billedcap"
-        case .militaryHelmet: return "militaryhelmet, military helmet, military_helmet"
+        case .womansHat: return "womans hat, womans_hat, womanshat"
+        case .tophat: return "top hat, tophat"
+        case .mortarBoard: return "graduation cap, mortar_board, mortarboard"
+        case .billedCap: return "billed cap, billed_cap, billedcap"
+        case .militaryHelmet: return "military helmet, military_helmet, militaryhelmet"
         case .helmetWithWhiteCross: return "helmet_with_white_cross, helmetwithwhitecross, rescue worker’s helmet"
         case .prayerBeads: return "prayer beads, prayer_beads, prayerbeads"
         case .lipstick: return "lipstick"
@@ -1161,157 +1176,159 @@ extension Emoji {
         case .mute: return "mute, speaker with cancellation stroke"
         case .speaker: return "speaker"
         case .sound: return "sound, speaker with one sound wave"
-        case .loudSound: return "loud_sound, speaker with three sound waves, loudsound"
-        case .loudspeaker: return "public address loudspeaker, loudspeaker"
-        case .mega: return "mega, cheering megaphone"
+        case .loudSound: return "loud_sound, loudsound, speaker with three sound waves"
+        case .loudspeaker: return "loudspeaker, public address loudspeaker"
+        case .mega: return "cheering megaphone, mega"
         case .postalHorn: return "postal horn, postal_horn, postalhorn"
         case .bell: return "bell"
-        case .noBell: return "nobell, no_bell, bell with cancellation stroke"
-        case .musicalScore: return "musical_score, musicalscore, musical score"
-        case .musicalNote: return "musical_note, musical note, musicalnote"
+        case .noBell: return "bell with cancellation stroke, no_bell, nobell"
+        case .musicalScore: return "musical score, musical_score, musicalscore"
+        case .musicalNote: return "musical note, musical_note, musicalnote"
         case .notes: return "multiple musical notes, notes"
         case .studioMicrophone: return "studio microphone, studio_microphone, studiomicrophone"
-        case .levelSlider: return "levelslider, level slider, level_slider"
-        case .controlKnobs: return "control_knobs, control knobs, controlknobs"
+        case .levelSlider: return "level slider, level_slider, levelslider"
+        case .controlKnobs: return "control knobs, control_knobs, controlknobs"
         case .microphone: return "microphone"
-        case .headphones: return "headphones, headphone"
+        case .headphones: return "headphone, headphones"
         case .radio: return "radio"
         case .saxophone: return "saxophone"
         case .accordion: return "accordion"
         case .guitar: return "guitar"
-        case .musicalKeyboard: return "musicalkeyboard, musical keyboard, musical_keyboard"
+        case .musicalKeyboard: return "musical keyboard, musical_keyboard, musicalkeyboard"
         case .trumpet: return "trumpet"
         case .violin: return "violin"
         case .banjo: return "banjo"
-        case .drumWithDrumsticks: return "drum_with_drumsticks, drum with drumsticks, drumwithdrumsticks"
+        case .drumWithDrumsticks: return "drum with drumsticks, drum_with_drumsticks, drumwithdrumsticks"
         case .longDrum: return "long drum, long_drum, longdrum"
+        case .maracas: return "maracas"
+        case .flute: return "flute"
         case .iphone: return "iphone, mobile phone"
         case .calling: return "calling, mobile phone with rightwards arrow at left"
         case .phone: return "black telephone, phone, telephone"
-        case .telephoneReceiver: return "telephone receiver, telephonereceiver, telephone_receiver"
+        case .telephoneReceiver: return "telephone receiver, telephone_receiver, telephonereceiver"
         case .pager: return "pager"
-        case .fax: return "fax machine, fax"
+        case .fax: return "fax, fax machine"
         case .battery: return "battery"
-        case .lowBattery: return "lowbattery, low_battery, low battery"
-        case .electricPlug: return "electricplug, electric plug, electric_plug"
-        case .computer: return "personal computer, computer"
-        case .desktopComputer: return "desktop_computer, desktop computer, desktopcomputer"
+        case .lowBattery: return "low battery, low_battery, lowbattery"
+        case .electricPlug: return "electric plug, electric_plug, electricplug"
+        case .computer: return "computer, personal computer"
+        case .desktopComputer: return "desktop computer, desktop_computer, desktopcomputer"
         case .printer: return "printer"
         case .keyboard: return "keyboard"
-        case .threeButtonMouse: return "computer mouse, threebuttonmouse, three_button_mouse"
+        case .threeButtonMouse: return "computer mouse, three_button_mouse, threebuttonmouse"
         case .trackball: return "trackball"
         case .minidisc: return "minidisc"
-        case .floppyDisk: return "floppydisk, floppy_disk, floppy disk"
-        case .cd: return "optical disc, cd"
+        case .floppyDisk: return "floppy disk, floppy_disk, floppydisk"
+        case .cd: return "cd, optical disc"
         case .dvd: return "dvd"
         case .abacus: return "abacus"
-        case .movieCamera: return "movie camera, moviecamera, movie_camera"
-        case .filmFrames: return "filmframes, film frames, film_frames"
-        case .filmProjector: return "film_projector, filmprojector, film projector"
+        case .movieCamera: return "movie camera, movie_camera, moviecamera"
+        case .filmFrames: return "film frames, film_frames, filmframes"
+        case .filmProjector: return "film projector, film_projector, filmprojector"
         case .clapper: return "clapper, clapper board"
         case .tv: return "television, tv"
         case .camera: return "camera"
-        case .cameraWithFlash: return "camera with flash, camerawithflash, camera_with_flash"
-        case .videoCamera: return "video_camera, video camera, videocamera"
+        case .cameraWithFlash: return "camera with flash, camera_with_flash, camerawithflash"
+        case .videoCamera: return "video camera, video_camera, videocamera"
         case .vhs: return "vhs, videocassette"
-        case .mag: return "mag, left-pointing magnifying glass"
+        case .mag: return "left-pointing magnifying glass, mag"
         case .magRight: return "mag_right, magright, right-pointing magnifying glass"
         case .candle: return "candle"
-        case .bulb: return "electric light bulb, bulb"
+        case .bulb: return "bulb, electric light bulb"
         case .flashlight: return "electric torch, flashlight"
-        case .izakayaLantern: return "izakaya_lantern, izakaya lantern, lantern, izakayalantern"
-        case .diyaLamp: return "diyalamp, diya_lamp, diya lamp"
-        case .notebookWithDecorativeCover: return "notebook_with_decorative_cover, notebook with decorative cover, notebookwithdecorativecover"
-        case .closedBook: return "closed_book, closed book, closedbook"
-        case .book: return "book, open_book, open book"
-        case .greenBook: return "greenbook, green book, green_book"
-        case .blueBook: return "blue_book, bluebook, blue book"
-        case .orangeBook: return "orange book, orangebook, orange_book"
+        case .izakayaLantern: return "izakaya lantern, izakaya_lantern, izakayalantern, lantern"
+        case .diyaLamp: return "diya lamp, diya_lamp, diyalamp"
+        case .notebookWithDecorativeCover: return "notebook with decorative cover, notebook_with_decorative_cover, notebookwithdecorativecover"
+        case .closedBook: return "closed book, closed_book, closedbook"
+        case .book: return "book, open book, open_book"
+        case .greenBook: return "green book, green_book, greenbook"
+        case .blueBook: return "blue book, blue_book, bluebook"
+        case .orangeBook: return "orange book, orange_book, orangebook"
         case .books: return "books"
         case .notebook: return "notebook"
         case .ledger: return "ledger"
         case .pageWithCurl: return "page with curl, page_with_curl, pagewithcurl"
         case .scroll: return "scroll"
-        case .pageFacingUp: return "pagefacingup, page_facing_up, page facing up"
+        case .pageFacingUp: return "page facing up, page_facing_up, pagefacingup"
         case .newspaper: return "newspaper"
-        case .rolledUpNewspaper: return "rolledupnewspaper, rolled_up_newspaper, rolled-up newspaper"
-        case .bookmarkTabs: return "bookmarktabs, bookmark_tabs, bookmark tabs"
+        case .rolledUpNewspaper: return "rolled-up newspaper, rolled_up_newspaper, rolledupnewspaper"
+        case .bookmarkTabs: return "bookmark tabs, bookmark_tabs, bookmarktabs"
         case .bookmark: return "bookmark"
         case .label: return "label"
         case .moneybag: return "money bag, moneybag"
         case .coin: return "coin"
         case .yen: return "banknote with yen sign, yen"
-        case .dollar: return "dollar, banknote with dollar sign"
+        case .dollar: return "banknote with dollar sign, dollar"
         case .euro: return "banknote with euro sign, euro"
-        case .pound: return "pound, banknote with pound sign"
-        case .moneyWithWings: return "money_with_wings, money with wings, moneywithwings"
-        case .creditCard: return "creditcard, credit card, credit_card"
+        case .pound: return "banknote with pound sign, pound"
+        case .moneyWithWings: return "money with wings, money_with_wings, moneywithwings"
+        case .creditCard: return "credit card, credit_card, creditcard"
         case .receipt: return "receipt"
         case .chart: return "chart, chart with upwards trend and yen sign"
         case .email: return "email, envelope"
-        case .eMail: return "email, e-mail, e-mail symbol"
-        case .incomingEnvelope: return "incomingenvelope, incoming_envelope, incoming envelope"
-        case .envelopeWithArrow: return "envelope with downwards arrow above, envelopewitharrow, envelope_with_arrow"
-        case .outboxTray: return "outbox tray, outboxtray, outbox_tray"
-        case .inboxTray: return "inboxtray, inbox_tray, inbox tray"
+        case .eMail: return "e-mail, e-mail symbol, email"
+        case .incomingEnvelope: return "incoming envelope, incoming_envelope, incomingenvelope"
+        case .envelopeWithArrow: return "envelope with downwards arrow above, envelope_with_arrow, envelopewitharrow"
+        case .outboxTray: return "outbox tray, outbox_tray, outboxtray"
+        case .inboxTray: return "inbox tray, inbox_tray, inboxtray"
         case .package: return "package"
         case .mailbox: return "closed mailbox with raised flag, mailbox"
-        case .mailboxClosed: return "mailbox_closed, closed mailbox with lowered flag, mailboxclosed"
-        case .mailboxWithMail: return "mailboxwithmail, mailbox_with_mail, open mailbox with raised flag"
-        case .mailboxWithNoMail: return "open mailbox with lowered flag, mailboxwithnomail, mailbox_with_no_mail"
+        case .mailboxClosed: return "closed mailbox with lowered flag, mailbox_closed, mailboxclosed"
+        case .mailboxWithMail: return "mailbox_with_mail, mailboxwithmail, open mailbox with raised flag"
+        case .mailboxWithNoMail: return "mailbox_with_no_mail, mailboxwithnomail, open mailbox with lowered flag"
         case .postbox: return "postbox"
-        case .ballotBoxWithBallot: return "ballotboxwithballot, ballot box with ballot, ballot_box_with_ballot"
-        case .pencil2: return "pencil2, pencil"
+        case .ballotBoxWithBallot: return "ballot box with ballot, ballot_box_with_ballot, ballotboxwithballot"
+        case .pencil2: return "pencil, pencil2"
         case .blackNib: return "black nib, black_nib, blacknib"
-        case .lowerLeftFountainPen: return "lowerleftfountainpen, lower_left_fountain_pen, fountain pen"
-        case .lowerLeftBallpointPen: return "pen, lowerleftballpointpen, lower_left_ballpoint_pen"
-        case .lowerLeftPaintbrush: return "lowerleftpaintbrush, paintbrush, lower_left_paintbrush"
-        case .lowerLeftCrayon: return "crayon, lowerleftcrayon, lower_left_crayon"
+        case .lowerLeftFountainPen: return "fountain pen, lower_left_fountain_pen, lowerleftfountainpen"
+        case .lowerLeftBallpointPen: return "lower_left_ballpoint_pen, lowerleftballpointpen, pen"
+        case .lowerLeftPaintbrush: return "lower_left_paintbrush, lowerleftpaintbrush, paintbrush"
+        case .lowerLeftCrayon: return "crayon, lower_left_crayon, lowerleftcrayon"
         case .memo: return "memo, pencil"
         case .briefcase: return "briefcase"
-        case .fileFolder: return "filefolder, file folder, file_folder"
-        case .openFileFolder: return "openfilefolder, open file folder, open_file_folder"
-        case .cardIndexDividers: return "card index dividers, cardindexdividers, card_index_dividers"
+        case .fileFolder: return "file folder, file_folder, filefolder"
+        case .openFileFolder: return "open file folder, open_file_folder, openfilefolder"
+        case .cardIndexDividers: return "card index dividers, card_index_dividers, cardindexdividers"
         case .date: return "calendar, date"
         case .calendar: return "calendar, tear-off calendar"
-        case .spiralNotePad: return "spiralnotepad, spiral notepad, spiral_note_pad"
-        case .spiralCalendarPad: return "spiralcalendarpad, spiral calendar, spiral_calendar_pad"
-        case .cardIndex: return "card index, cardindex, card_index"
-        case .chartWithUpwardsTrend: return "chartwithupwardstrend, chart with upwards trend, chart_with_upwards_trend"
-        case .chartWithDownwardsTrend: return "chartwithdownwardstrend, chart with downwards trend, chart_with_downwards_trend"
-        case .barChart: return "barchart, bar chart, bar_chart"
+        case .spiralNotePad: return "spiral notepad, spiral_note_pad, spiralnotepad"
+        case .spiralCalendarPad: return "spiral calendar, spiral_calendar_pad, spiralcalendarpad"
+        case .cardIndex: return "card index, card_index, cardindex"
+        case .chartWithUpwardsTrend: return "chart with upwards trend, chart_with_upwards_trend, chartwithupwardstrend"
+        case .chartWithDownwardsTrend: return "chart with downwards trend, chart_with_downwards_trend, chartwithdownwardstrend"
+        case .barChart: return "bar chart, bar_chart, barchart"
         case .clipboard: return "clipboard"
         case .pushpin: return "pushpin"
         case .roundPushpin: return "round pushpin, round_pushpin, roundpushpin"
         case .paperclip: return "paperclip"
         case .linkedPaperclips: return "linked paperclips, linked_paperclips, linkedpaperclips"
-        case .straightRuler: return "straightruler, straight ruler, straight_ruler"
-        case .triangularRuler: return "triangular ruler, triangularruler, triangular_ruler"
+        case .straightRuler: return "straight ruler, straight_ruler, straightruler"
+        case .triangularRuler: return "triangular ruler, triangular_ruler, triangularruler"
         case .scissors: return "black scissors, scissors"
         case .cardFileBox: return "card file box, card_file_box, cardfilebox"
-        case .fileCabinet: return "file_cabinet, filecabinet, file cabinet"
+        case .fileCabinet: return "file cabinet, file_cabinet, filecabinet"
         case .wastebasket: return "wastebasket"
         case .lock: return "lock"
         case .unlock: return "open lock, unlock"
-        case .lockWithInkPen: return "lock_with_ink_pen, lock with ink pen, lockwithinkpen"
-        case .closedLockWithKey: return "closedlockwithkey, closed_lock_with_key, closed lock with key"
+        case .lockWithInkPen: return "lock with ink pen, lock_with_ink_pen, lockwithinkpen"
+        case .closedLockWithKey: return "closed lock with key, closed_lock_with_key, closedlockwithkey"
         case .key: return "key"
-        case .oldKey: return "oldkey, old key, old_key"
+        case .oldKey: return "old key, old_key, oldkey"
         case .hammer: return "hammer"
         case .axe: return "axe"
         case .pick: return "pick"
-        case .hammerAndPick: return "hammerandpick, hammer and pick, hammer_and_pick"
-        case .hammerAndWrench: return "hammerandwrench, hammer_and_wrench, hammer and wrench"
-        case .daggerKnife: return "daggerknife, dagger_knife, dagger"
-        case .crossedSwords: return "crossedswords, crossed_swords, crossed swords"
-        case .gun: return "gun, pistol"
+        case .hammerAndPick: return "hammer and pick, hammer_and_pick, hammerandpick"
+        case .hammerAndWrench: return "hammer and wrench, hammer_and_wrench, hammerandwrench"
+        case .daggerKnife: return "dagger, dagger_knife, daggerknife"
+        case .crossedSwords: return "crossed swords, crossed_swords, crossedswords"
+        case .bomb: return "bomb"
         case .boomerang: return "boomerang"
-        case .bowAndArrow: return "bow_and_arrow, bowandarrow, bow and arrow"
+        case .bowAndArrow: return "bow and arrow, bow_and_arrow, bowandarrow"
         case .shield: return "shield"
-        case .carpentrySaw: return "carpentry_saw, carpentry saw, carpentrysaw"
+        case .carpentrySaw: return "carpentry saw, carpentry_saw, carpentrysaw"
         case .wrench: return "wrench"
         case .screwdriver: return "screwdriver"
-        case .nutAndBolt: return "nut_and_bolt, nut and bolt, nutandbolt"
+        case .nutAndBolt: return "nut and bolt, nut_and_bolt, nutandbolt"
         case .gear: return "gear"
         case .compression: return "clamp, compression"
         case .scales: return "balance scale, scales"
@@ -1323,14 +1340,14 @@ extension Emoji {
         case .magnet: return "magnet"
         case .ladder: return "ladder"
         case .alembic: return "alembic"
-        case .testTube: return "test tube, testtube, test_tube"
+        case .testTube: return "test tube, test_tube, testtube"
         case .petriDish: return "petri dish, petri_dish, petridish"
         case .dna: return "dna, dna double helix"
         case .microscope: return "microscope"
         case .telescope: return "telescope"
-        case .satelliteAntenna: return "satelliteantenna, satellite_antenna, satellite antenna"
+        case .satelliteAntenna: return "satellite antenna, satellite_antenna, satelliteantenna"
         case .syringe: return "syringe"
-        case .dropOfBlood: return "drop of blood, dropofblood, drop_of_blood"
+        case .dropOfBlood: return "drop of blood, drop_of_blood, dropofblood"
         case .pill: return "pill"
         case .adhesiveBandage: return "adhesive bandage, adhesive_bandage, adhesivebandage"
         case .crutch: return "crutch"
@@ -1341,92 +1358,95 @@ extension Emoji {
         case .mirror: return "mirror"
         case .window: return "window"
         case .bed: return "bed"
-        case .couchAndLamp: return "couch_and_lamp, couchandlamp, couch and lamp"
+        case .couchAndLamp: return "couch and lamp, couch_and_lamp, couchandlamp"
         case .chair: return "chair"
         case .toilet: return "toilet"
         case .plunger: return "plunger"
         case .shower: return "shower"
         case .bathtub: return "bathtub"
-        case .mouseTrap: return "mousetrap, mouse_trap, mouse trap"
+        case .mouseTrap: return "mouse trap, mouse_trap, mousetrap"
         case .razor: return "razor"
-        case .lotionBottle: return "lotionbottle, lotion_bottle, lotion bottle"
-        case .safetyPin: return "safety pin, safetypin, safety_pin"
+        case .lotionBottle: return "lotion bottle, lotion_bottle, lotionbottle"
+        case .safetyPin: return "safety pin, safety_pin, safetypin"
         case .broom: return "broom"
         case .basket: return "basket"
-        case .rollOfPaper: return "roll_of_paper, rollofpaper, roll of paper"
+        case .rollOfPaper: return "roll of paper, roll_of_paper, rollofpaper"
         case .bucket: return "bucket"
-        case .soap: return "soap, bar of soap"
+        case .soap: return "bar of soap, soap"
         case .bubbles: return "bubbles"
         case .toothbrush: return "toothbrush"
         case .sponge: return "sponge"
         case .fireExtinguisher: return "fire extinguisher, fire_extinguisher, fireextinguisher"
-        case .shoppingTrolley: return "shopping_trolley, shopping trolley, shoppingtrolley"
+        case .shoppingTrolley: return "shopping trolley, shopping_trolley, shoppingtrolley"
         case .smoking: return "smoking, smoking symbol"
         case .coffin: return "coffin"
         case .headstone: return "headstone"
-        case .funeralUrn: return "funeralurn, funeral urn, funeral_urn"
+        case .funeralUrn: return "funeral urn, funeral_urn, funeralurn"
+        case .nazarAmulet: return "nazar amulet, nazar_amulet, nazaramulet"
+        case .hamsa: return "hamsa"
         case .moyai: return "moyai"
         case .placard: return "placard"
-        case .identificationCard: return "identification_card, identification card, identificationcard"
+        case .identificationCard: return "identification card, identification_card, identificationcard"
         case .atm: return "atm, automated teller machine"
-        case .putLitterInItsPlace: return "putlitterinitsplace, put_litter_in_its_place, put litter in its place symbol"
-        case .potableWater: return "potablewater, potable water symbol, potable_water"
-        case .wheelchair: return "wheelchair symbol, wheelchair"
+        case .putLitterInItsPlace: return "put litter in its place symbol, put_litter_in_its_place, putlitterinitsplace"
+        case .potableWater: return "potable water symbol, potable_water, potablewater"
+        case .wheelchair: return "wheelchair, wheelchair symbol"
         case .mens: return "mens, mens symbol"
-        case .womens: return "womens symbol, womens"
+        case .womens: return "womens, womens symbol"
         case .restroom: return "restroom"
-        case .babySymbol: return "baby_symbol, babysymbol, baby symbol"
-        case .wc: return "wc, water closet"
-        case .passportControl: return "passport_control, passport control, passportcontrol"
+        case .babySymbol: return "baby symbol, baby_symbol, babysymbol"
+        case .wc: return "water closet, wc"
+        case .passportControl: return "passport control, passport_control, passportcontrol"
         case .customs: return "customs"
-        case .baggageClaim: return "baggageclaim, baggage claim, baggage_claim"
-        case .leftLuggage: return "left luggage, leftluggage, left_luggage"
+        case .baggageClaim: return "baggage claim, baggage_claim, baggageclaim"
+        case .leftLuggage: return "left luggage, left_luggage, leftluggage"
         case .warning: return "warning, warning sign"
-        case .childrenCrossing: return "children crossing, childrencrossing, children_crossing"
+        case .childrenCrossing: return "children crossing, children_crossing, childrencrossing"
         case .noEntry: return "no entry, no_entry, noentry"
-        case .noEntrySign: return "no entry sign, noentrysign, no_entry_sign"
+        case .noEntrySign: return "no entry sign, no_entry_sign, noentrysign"
         case .noBicycles: return "no bicycles, no_bicycles, nobicycles"
-        case .noSmoking: return "nosmoking, no_smoking, no smoking symbol"
-        case .doNotLitter: return "donotlitter, do not litter symbol, do_not_litter"
-        case .nonPotableWater: return "nonpotablewater, non-potable_water, non-potable water symbol"
-        case .noPedestrians: return "nopedestrians, no pedestrians, no_pedestrians"
-        case .noMobilePhones: return "no mobile phones, nomobilephones, no_mobile_phones"
-        case .underage: return "underage, no one under eighteen symbol"
-        case .radioactiveSign: return "radioactive, radioactivesign, radioactive_sign"
-        case .biohazardSign: return "biohazard, biohazardsign, biohazard_sign"
-        case .arrowUp: return "arrowup, arrow_up, upwards black arrow"
-        case .arrowUpperRight: return "north east arrow, arrow_upper_right, arrowupperright"
-        case .arrowRight: return "arrowright, black rightwards arrow, arrow_right"
-        case .arrowLowerRight: return "arrowlowerright, arrow_lower_right, south east arrow"
-        case .arrowDown: return "downwards black arrow, arrowdown, arrow_down"
-        case .arrowLowerLeft: return "arrow_lower_left, south west arrow, arrowlowerleft"
-        case .arrowLeft: return "arrow_left, leftwards black arrow, arrowleft"
-        case .arrowUpperLeft: return "arrow_upper_left, north west arrow, arrowupperleft"
-        case .arrowUpDown: return "arrowupdown, arrow_up_down, up down arrow"
-        case .leftRightArrow: return "left_right_arrow, left right arrow, leftrightarrow"
-        case .leftwardsArrowWithHook: return "leftwards_arrow_with_hook, leftwardsarrowwithhook, leftwards arrow with hook"
-        case .arrowRightHook: return "arrow_right_hook, rightwards arrow with hook, arrowrighthook"
-        case .arrowHeadingUp: return "arrow_heading_up, arrow pointing rightwards then curving upwards, arrowheadingup"
-        case .arrowHeadingDown: return "arrow_heading_down, arrow pointing rightwards then curving downwards, arrowheadingdown"
-        case .arrowsClockwise: return "clockwise downwards and upwards open circle arrows, arrowsclockwise, arrows_clockwise"
-        case .arrowsCounterclockwise: return "arrowscounterclockwise, arrows_counterclockwise, anticlockwise downwards and upwards open circle arrows"
+        case .noSmoking: return "no smoking symbol, no_smoking, nosmoking"
+        case .doNotLitter: return "do not litter symbol, do_not_litter, donotlitter"
+        case .nonPotableWater: return "non-potable water symbol, non-potable_water, nonpotablewater"
+        case .noPedestrians: return "no pedestrians, no_pedestrians, nopedestrians"
+        case .noMobilePhones: return "no mobile phones, no_mobile_phones, nomobilephones"
+        case .underage: return "no one under eighteen symbol, underage"
+        case .radioactiveSign: return "radioactive, radioactive_sign, radioactivesign"
+        case .biohazardSign: return "biohazard, biohazard_sign, biohazardsign"
+        case .arrowUp: return "arrow_up, arrowup, upwards black arrow"
+        case .arrowUpperRight: return "arrow_upper_right, arrowupperright, north east arrow"
+        case .arrowRight: return "arrow_right, arrowright, black rightwards arrow"
+        case .arrowLowerRight: return "arrow_lower_right, arrowlowerright, south east arrow"
+        case .arrowDown: return "arrow_down, arrowdown, downwards black arrow"
+        case .arrowLowerLeft: return "arrow_lower_left, arrowlowerleft, south west arrow"
+        case .arrowLeft: return "arrow_left, arrowleft, leftwards black arrow"
+        case .arrowUpperLeft: return "arrow_upper_left, arrowupperleft, north west arrow"
+        case .arrowUpDown: return "arrow_up_down, arrowupdown, up down arrow"
+        case .leftRightArrow: return "left right arrow, left_right_arrow, leftrightarrow"
+        case .leftwardsArrowWithHook: return "leftwards arrow with hook, leftwards_arrow_with_hook, leftwardsarrowwithhook"
+        case .arrowRightHook: return "arrow_right_hook, arrowrighthook, rightwards arrow with hook"
+        case .arrowHeadingUp: return "arrow pointing rightwards then curving upwards, arrow_heading_up, arrowheadingup"
+        case .arrowHeadingDown: return "arrow pointing rightwards then curving downwards, arrow_heading_down, arrowheadingdown"
+        case .arrowsClockwise: return "arrows_clockwise, arrowsclockwise, clockwise downwards and upwards open circle arrows"
+        case .arrowsCounterclockwise: return "anticlockwise downwards and upwards open circle arrows, arrows_counterclockwise, arrowscounterclockwise"
         case .back: return "back, back with leftwards arrow above"
-        case .end: return "end with leftwards arrow above, end"
+        case .end: return "end, end with leftwards arrow above"
         case .on: return "on, on with exclamation mark with left right arrow above"
-        case .soon: return "soon with rightwards arrow above, soon"
+        case .soon: return "soon, soon with rightwards arrow above"
         case .top: return "top, top with upwards arrow above"
-        case .placeOfWorship: return "place_of_worship, placeofworship, place of worship"
-        case .atomSymbol: return "atomsymbol, atom_symbol, atom symbol"
-        case .omSymbol: return "omsymbol, om, om_symbol"
-        case .starOfDavid: return "star_of_david, star of david, starofdavid"
-        case .wheelOfDharma: return "wheel of dharma, wheelofdharma, wheel_of_dharma"
-        case .yinYang: return "yin yang, yinyang, yin_yang"
-        case .latinCross: return "latin_cross, latin cross, latincross"
-        case .orthodoxCross: return "orthodox cross, orthodoxcross, orthodox_cross"
-        case .starAndCrescent: return "starandcrescent, star_and_crescent, star and crescent"
-        case .peaceSymbol: return "peacesymbol, peace_symbol, peace symbol"
-        case .menorahWithNineBranches: return "menorah_with_nine_branches, menorahwithninebranches, menorah with nine branches"
-        case .sixPointedStar: return "six_pointed_star, six pointed star with middle dot, sixpointedstar"
+        case .placeOfWorship: return "place of worship, place_of_worship, placeofworship"
+        case .atomSymbol: return "atom symbol, atom_symbol, atomsymbol"
+        case .omSymbol: return "om, om_symbol, omsymbol"
+        case .starOfDavid: return "star of david, star_of_david, starofdavid"
+        case .wheelOfDharma: return "wheel of dharma, wheel_of_dharma, wheelofdharma"
+        case .yinYang: return "yin yang, yin_yang, yinyang"
+        case .latinCross: return "latin cross, latin_cross, latincross"
+        case .orthodoxCross: return "orthodox cross, orthodox_cross, orthodoxcross"
+        case .starAndCrescent: return "star and crescent, star_and_crescent, starandcrescent"
+        case .peaceSymbol: return "peace symbol, peace_symbol, peacesymbol"
+        case .menorahWithNineBranches: return "menorah with nine branches, menorah_with_nine_branches, menorahwithninebranches"
+        case .sixPointedStar: return "six pointed star with middle dot, six_pointed_star, sixpointedstar"
+        case .khanda: return "khanda"
         case .aries: return "aries"
         case .taurus: return "taurus"
         case .gemini: return "gemini"
@@ -1440,424 +1460,425 @@ extension Emoji {
         case .aquarius: return "aquarius"
         case .pisces: return "pisces"
         case .ophiuchus: return "ophiuchus"
-        case .twistedRightwardsArrows: return "twisted rightwards arrows, twistedrightwardsarrows, twisted_rightwards_arrows"
-        case .`repeat`: return "repeat, clockwise rightwards and leftwards open circle arrows, `repeat`"
-        case .repeatOne: return "repeatone, repeat_one, clockwise rightwards and leftwards open circle arrows with circled one overlay"
-        case .arrowForward: return "arrowforward, arrow_forward, black right-pointing triangle"
-        case .fastForward: return "fast_forward, fastforward, black right-pointing double triangle"
-        case .blackRightPointingDoubleTriangleWithVerticalBar: return "next track button, black_right_pointing_double_triangle_with_vertical_bar, blackrightpointingdoubletrianglewithverticalbar"
+        case .twistedRightwardsArrows: return "twisted rightwards arrows, twisted_rightwards_arrows, twistedrightwardsarrows"
+        case .`repeat`: return "`repeat`, clockwise rightwards and leftwards open circle arrows, repeat"
+        case .repeatOne: return "clockwise rightwards and leftwards open circle arrows with circled one overlay, repeat_one, repeatone"
+        case .arrowForward: return "arrow_forward, arrowforward, black right-pointing triangle"
+        case .fastForward: return "black right-pointing double triangle, fast_forward, fastforward"
+        case .blackRightPointingDoubleTriangleWithVerticalBar: return "black_right_pointing_double_triangle_with_vertical_bar, blackrightpointingdoubletrianglewithverticalbar, next track button"
         case .blackRightPointingTriangleWithDoubleVerticalBar: return "black_right_pointing_triangle_with_double_vertical_bar, blackrightpointingtrianglewithdoubleverticalbar, play or pause button"
-        case .arrowBackward: return "arrow_backward, black left-pointing triangle, arrowbackward"
+        case .arrowBackward: return "arrow_backward, arrowbackward, black left-pointing triangle"
         case .rewind: return "black left-pointing double triangle, rewind"
-        case .blackLeftPointingDoubleTriangleWithVerticalBar: return "last track button, blackleftpointingdoubletrianglewithverticalbar, black_left_pointing_double_triangle_with_vertical_bar"
-        case .arrowUpSmall: return "up-pointing small red triangle, arrowupsmall, arrow_up_small"
-        case .arrowDoubleUp: return "arrow_double_up, black up-pointing double triangle, arrowdoubleup"
-        case .arrowDownSmall: return "arrow_down_small, down-pointing small red triangle, arrowdownsmall"
-        case .arrowDoubleDown: return "arrowdoubledown, arrow_double_down, black down-pointing double triangle"
-        case .doubleVerticalBar: return "doubleverticalbar, double_vertical_bar, pause button"
-        case .blackSquareForStop: return "blacksquareforstop, black_square_for_stop, stop button"
-        case .blackCircleForRecord: return "record button, black_circle_for_record, blackcircleforrecord"
-        case .eject: return "eject button, eject"
+        case .blackLeftPointingDoubleTriangleWithVerticalBar: return "black_left_pointing_double_triangle_with_vertical_bar, blackleftpointingdoubletrianglewithverticalbar, last track button"
+        case .arrowUpSmall: return "arrow_up_small, arrowupsmall, up-pointing small red triangle"
+        case .arrowDoubleUp: return "arrow_double_up, arrowdoubleup, black up-pointing double triangle"
+        case .arrowDownSmall: return "arrow_down_small, arrowdownsmall, down-pointing small red triangle"
+        case .arrowDoubleDown: return "arrow_double_down, arrowdoubledown, black down-pointing double triangle"
+        case .doubleVerticalBar: return "double_vertical_bar, doubleverticalbar, pause button"
+        case .blackSquareForStop: return "black_square_for_stop, blacksquareforstop, stop button"
+        case .blackCircleForRecord: return "black_circle_for_record, blackcircleforrecord, record button"
+        case .eject: return "eject, eject button"
         case .cinema: return "cinema"
-        case .lowBrightness: return "lowbrightness, low brightness symbol, low_brightness"
-        case .highBrightness: return "high brightness symbol, highbrightness, high_brightness"
-        case .signalStrength: return "signal_strength, signalstrength, antenna with bars"
-        case .vibrationMode: return "vibration_mode, vibration mode, vibrationmode"
-        case .mobilePhoneOff: return "mobilephoneoff, mobile phone off, mobile_phone_off"
-        case .femaleSign: return "femalesign, female sign, female_sign"
+        case .lowBrightness: return "low brightness symbol, low_brightness, lowbrightness"
+        case .highBrightness: return "high brightness symbol, high_brightness, highbrightness"
+        case .signalStrength: return "antenna with bars, signal_strength, signalstrength"
+        case .wireless: return "wireless"
+        case .vibrationMode: return "vibration mode, vibration_mode, vibrationmode"
+        case .mobilePhoneOff: return "mobile phone off, mobile_phone_off, mobilephoneoff"
+        case .femaleSign: return "female sign, female_sign, femalesign"
         case .maleSign: return "male sign, male_sign, malesign"
         case .transgenderSymbol: return "transgender symbol, transgender_symbol, transgendersymbol"
-        case .heavyMultiplicationX: return "heavymultiplicationx, heavy_multiplication_x, heavy multiplication x"
+        case .heavyMultiplicationX: return "heavy multiplication x, heavy_multiplication_x, heavymultiplicationx"
         case .heavyPlusSign: return "heavy plus sign, heavy_plus_sign, heavyplussign"
-        case .heavyMinusSign: return "heavy_minus_sign, heavy minus sign, heavyminussign"
-        case .heavyDivisionSign: return "heavy division sign, heavydivisionsign, heavy_division_sign"
-        case .heavyEqualsSign: return "heavy equals sign, heavyequalssign, heavy_equals_sign"
+        case .heavyMinusSign: return "heavy minus sign, heavy_minus_sign, heavyminussign"
+        case .heavyDivisionSign: return "heavy division sign, heavy_division_sign, heavydivisionsign"
+        case .heavyEqualsSign: return "heavy equals sign, heavy_equals_sign, heavyequalssign"
         case .infinity: return "infinity"
         case .bangbang: return "bangbang, double exclamation mark"
         case .interrobang: return "exclamation question mark, interrobang"
-        case .question: return "question, black question mark ornament"
-        case .greyQuestion: return "greyquestion, grey_question, white question mark ornament"
-        case .greyExclamation: return "white exclamation mark ornament, greyexclamation, grey_exclamation"
-        case .exclamation: return "heavy exclamation mark symbol, exclamation, heavy_exclamation_mark"
-        case .wavyDash: return "wavy_dash, wavy dash, wavydash"
-        case .currencyExchange: return "currency exchange, currencyexchange, currency_exchange"
-        case .heavyDollarSign: return "heavydollarsign, heavy_dollar_sign, heavy dollar sign"
+        case .question: return "black question mark ornament, question"
+        case .greyQuestion: return "grey_question, greyquestion, white question mark ornament"
+        case .greyExclamation: return "grey_exclamation, greyexclamation, white exclamation mark ornament"
+        case .exclamation: return "exclamation, heavy exclamation mark symbol, heavy_exclamation_mark"
+        case .wavyDash: return "wavy dash, wavy_dash, wavydash"
+        case .currencyExchange: return "currency exchange, currency_exchange, currencyexchange"
+        case .heavyDollarSign: return "heavy dollar sign, heavy_dollar_sign, heavydollarsign"
         case .medicalSymbol: return "medical symbol, medical_symbol, medicalsymbol, staff_of_aesculapius"
-        case .recycle: return "recycle, black universal recycling symbol"
-        case .fleurDeLis: return "fleurdelis, fleur-de-lis, fleur_de_lis"
+        case .recycle: return "black universal recycling symbol, recycle"
+        case .fleurDeLis: return "fleur-de-lis, fleur_de_lis, fleurdelis"
         case .trident: return "trident, trident emblem"
-        case .nameBadge: return "namebadge, name_badge, name badge"
-        case .beginner: return "japanese symbol for beginner, beginner"
-        case .o: return "o, heavy large circle"
+        case .nameBadge: return "name badge, name_badge, namebadge"
+        case .beginner: return "beginner, japanese symbol for beginner"
+        case .o: return "heavy large circle, o"
         case .whiteCheckMark: return "white heavy check mark, white_check_mark, whitecheckmark"
-        case .ballotBoxWithCheck: return "ballotboxwithcheck, ballot_box_with_check, ballot box with check"
-        case .heavyCheckMark: return "heavy check mark, heavycheckmark, heavy_check_mark"
-        case .x: return "x, cross mark"
-        case .negativeSquaredCrossMark: return "negative_squared_cross_mark, negative squared cross mark, negativesquaredcrossmark"
-        case .curlyLoop: return "curly_loop, curlyloop, curly loop"
+        case .ballotBoxWithCheck: return "ballot box with check, ballot_box_with_check, ballotboxwithcheck"
+        case .heavyCheckMark: return "heavy check mark, heavy_check_mark, heavycheckmark"
+        case .x: return "cross mark, x"
+        case .negativeSquaredCrossMark: return "negative squared cross mark, negative_squared_cross_mark, negativesquaredcrossmark"
+        case .curlyLoop: return "curly loop, curly_loop, curlyloop"
         case .loop: return "double curly loop, loop"
         case .partAlternationMark: return "part alternation mark, part_alternation_mark, partalternationmark"
-        case .eightSpokedAsterisk: return "eight_spoked_asterisk, eight spoked asterisk, eightspokedasterisk"
+        case .eightSpokedAsterisk: return "eight spoked asterisk, eight_spoked_asterisk, eightspokedasterisk"
         case .eightPointedBlackStar: return "eight pointed black star, eight_pointed_black_star, eightpointedblackstar"
         case .sparkle: return "sparkle"
         case .copyright: return "copyright, copyright sign"
         case .registered: return "registered, registered sign"
-        case .tm: return "trade mark sign, tm"
-        case .hash: return "hash key, hash"
-        case .keycapStar: return "keycapstar, keycap_star, keycap: *"
+        case .tm: return "tm, trade mark sign"
+        case .hash: return "hash, hash key"
+        case .keycapStar: return "keycap: *, keycap_star, keycapstar"
         case .zero: return "keycap 0, zero"
         case .one: return "keycap 1, one"
-        case .two: return "two, keycap 2"
-        case .three: return "three, keycap 3"
-        case .four: return "keycap 4, four"
+        case .two: return "keycap 2, two"
+        case .three: return "keycap 3, three"
+        case .four: return "four, keycap 4"
         case .five: return "five, keycap 5"
-        case .six: return "six, keycap 6"
-        case .seven: return "seven, keycap 7"
+        case .six: return "keycap 6, six"
+        case .seven: return "keycap 7, seven"
         case .eight: return "eight, keycap 8"
         case .nine: return "keycap 9, nine"
-        case .keycapTen: return "keycap_ten, keycap ten, keycapten"
-        case .capitalAbcd: return "input symbol for latin capital letters, capitalabcd, capital_abcd"
+        case .keycapTen: return "keycap ten, keycap_ten, keycapten"
+        case .capitalAbcd: return "capital_abcd, capitalabcd, input symbol for latin capital letters"
         case .abcd: return "abcd, input symbol for latin small letters"
         case .oneTwoThreeFour: return "1234, input symbol for numbers, onetwothreefour"
         case .symbols: return "input symbol for symbols, symbols"
         case .abc: return "abc, input symbol for latin letters"
         case .a: return "a, negative squared latin capital letter a"
-        case .ab: return "negative squared ab, ab"
+        case .ab: return "ab, negative squared ab"
         case .b: return "b, negative squared latin capital letter b"
         case .cl: return "cl, squared cl"
-        case .cool: return "squared cool, cool"
+        case .cool: return "cool, squared cool"
         case .free: return "free, squared free"
-        case .informationSource: return "informationsource, information_source, information source"
+        case .informationSource: return "information source, information_source, informationsource"
         case .id: return "id, squared id"
         case .m: return "circled latin capital letter m, m"
-        case .new: return "squared new, new"
+        case .new: return "new, squared new"
         case .ng: return "ng, squared ng"
-        case .o2: return "o2, negative squared latin capital letter o"
+        case .o2: return "negative squared latin capital letter o, o2"
         case .ok: return "ok, squared ok"
-        case .parking: return "parking, negative squared latin capital letter p"
+        case .parking: return "negative squared latin capital letter p, parking"
         case .sos: return "sos, squared sos"
         case .up: return "squared up with exclamation mark, up"
         case .vs: return "squared vs, vs"
-        case .koko: return "squared katakana koko, koko"
-        case .sa: return "squared katakana sa, sa"
+        case .koko: return "koko, squared katakana koko"
+        case .sa: return "sa, squared katakana sa"
         case .u6708: return "squared cjk unified ideograph-6708, u6708"
         case .u6709: return "squared cjk unified ideograph-6709, u6709"
         case .u6307: return "squared cjk unified ideograph-6307, u6307"
         case .ideographAdvantage: return "circled ideograph advantage, ideograph_advantage, ideographadvantage"
-        case .u5272: return "u5272, squared cjk unified ideograph-5272"
-        case .u7121: return "u7121, squared cjk unified ideograph-7121"
-        case .u7981: return "u7981, squared cjk unified ideograph-7981"
-        case .accept: return "circled ideograph accept, accept"
+        case .u5272: return "squared cjk unified ideograph-5272, u5272"
+        case .u7121: return "squared cjk unified ideograph-7121, u7121"
+        case .u7981: return "squared cjk unified ideograph-7981, u7981"
+        case .accept: return "accept, circled ideograph accept"
         case .u7533: return "squared cjk unified ideograph-7533, u7533"
         case .u5408: return "squared cjk unified ideograph-5408, u5408"
         case .u7a7a: return "squared cjk unified ideograph-7a7a, u7a7a"
-        case .congratulations: return "congratulations, circled ideograph congratulation"
-        case .secret: return "secret, circled ideograph secret"
+        case .congratulations: return "circled ideograph congratulation, congratulations"
+        case .secret: return "circled ideograph secret, secret"
         case .u55b6: return "squared cjk unified ideograph-55b6, u55b6"
         case .u6e80: return "squared cjk unified ideograph-6e80, u6e80"
-        case .redCircle: return "red_circle, large red circle, redcircle"
-        case .largeOrangeCircle: return "large_orange_circle, large orange circle, largeorangecircle"
-        case .largeYellowCircle: return "largeyellowcircle, large_yellow_circle, large yellow circle"
-        case .largeGreenCircle: return "largegreencircle, large green circle, large_green_circle"
-        case .largeBlueCircle: return "large_blue_circle, large blue circle, largebluecircle"
-        case .largePurpleCircle: return "large_purple_circle, large purple circle, largepurplecircle"
-        case .largeBrownCircle: return "largebrowncircle, large brown circle, large_brown_circle"
+        case .redCircle: return "large red circle, red_circle, redcircle"
+        case .largeOrangeCircle: return "large orange circle, large_orange_circle, largeorangecircle"
+        case .largeYellowCircle: return "large yellow circle, large_yellow_circle, largeyellowcircle"
+        case .largeGreenCircle: return "large green circle, large_green_circle, largegreencircle"
+        case .largeBlueCircle: return "large blue circle, large_blue_circle, largebluecircle"
+        case .largePurpleCircle: return "large purple circle, large_purple_circle, largepurplecircle"
+        case .largeBrownCircle: return "large brown circle, large_brown_circle, largebrowncircle"
         case .blackCircle: return "black_circle, blackcircle, medium black circle"
-        case .whiteCircle: return "white_circle, medium white circle, whitecircle"
-        case .largeRedSquare: return "large red square, largeredsquare, large_red_square"
-        case .largeOrangeSquare: return "large orange square, largeorangesquare, large_orange_square"
+        case .whiteCircle: return "medium white circle, white_circle, whitecircle"
+        case .largeRedSquare: return "large red square, large_red_square, largeredsquare"
+        case .largeOrangeSquare: return "large orange square, large_orange_square, largeorangesquare"
         case .largeYellowSquare: return "large yellow square, large_yellow_square, largeyellowsquare"
-        case .largeGreenSquare: return "large_green_square, large green square, largegreensquare"
-        case .largeBlueSquare: return "large blue square, largebluesquare, large_blue_square"
+        case .largeGreenSquare: return "large green square, large_green_square, largegreensquare"
+        case .largeBlueSquare: return "large blue square, large_blue_square, largebluesquare"
         case .largePurpleSquare: return "large purple square, large_purple_square, largepurplesquare"
-        case .largeBrownSquare: return "largebrownsquare, large_brown_square, large brown square"
-        case .blackLargeSquare: return "black_large_square, blacklargesquare, black large square"
-        case .whiteLargeSquare: return "whitelargesquare, white_large_square, white large square"
-        case .blackMediumSquare: return "black medium square, blackmediumsquare, black_medium_square"
-        case .whiteMediumSquare: return "white_medium_square, white medium square, whitemediumsquare"
-        case .blackMediumSmallSquare: return "black medium small square, blackmediumsmallsquare, black_medium_small_square"
-        case .whiteMediumSmallSquare: return "white_medium_small_square, whitemediumsmallsquare, white medium small square"
-        case .blackSmallSquare: return "black_small_square, blacksmallsquare, black small square"
-        case .whiteSmallSquare: return "white_small_square, white small square, whitesmallsquare"
-        case .largeOrangeDiamond: return "largeorangediamond, large orange diamond, large_orange_diamond"
-        case .largeBlueDiamond: return "large_blue_diamond, large blue diamond, largebluediamond"
-        case .smallOrangeDiamond: return "smallorangediamond, small orange diamond, small_orange_diamond"
-        case .smallBlueDiamond: return "small blue diamond, smallbluediamond, small_blue_diamond"
-        case .smallRedTriangle: return "small_red_triangle, up-pointing red triangle, smallredtriangle"
-        case .smallRedTriangleDown: return "small_red_triangle_down, down-pointing red triangle, smallredtriangledown"
+        case .largeBrownSquare: return "large brown square, large_brown_square, largebrownsquare"
+        case .blackLargeSquare: return "black large square, black_large_square, blacklargesquare"
+        case .whiteLargeSquare: return "white large square, white_large_square, whitelargesquare"
+        case .blackMediumSquare: return "black medium square, black_medium_square, blackmediumsquare"
+        case .whiteMediumSquare: return "white medium square, white_medium_square, whitemediumsquare"
+        case .blackMediumSmallSquare: return "black medium small square, black_medium_small_square, blackmediumsmallsquare"
+        case .whiteMediumSmallSquare: return "white medium small square, white_medium_small_square, whitemediumsmallsquare"
+        case .blackSmallSquare: return "black small square, black_small_square, blacksmallsquare"
+        case .whiteSmallSquare: return "white small square, white_small_square, whitesmallsquare"
+        case .largeOrangeDiamond: return "large orange diamond, large_orange_diamond, largeorangediamond"
+        case .largeBlueDiamond: return "large blue diamond, large_blue_diamond, largebluediamond"
+        case .smallOrangeDiamond: return "small orange diamond, small_orange_diamond, smallorangediamond"
+        case .smallBlueDiamond: return "small blue diamond, small_blue_diamond, smallbluediamond"
+        case .smallRedTriangle: return "small_red_triangle, smallredtriangle, up-pointing red triangle"
+        case .smallRedTriangleDown: return "down-pointing red triangle, small_red_triangle_down, smallredtriangledown"
         case .diamondShapeWithADotInside: return "diamond shape with a dot inside, diamond_shape_with_a_dot_inside, diamondshapewithadotinside"
-        case .radioButton: return "radio button, radiobutton, radio_button"
-        case .whiteSquareButton: return "whitesquarebutton, white_square_button, white square button"
-        case .blackSquareButton: return "blacksquarebutton, black_square_button, black square button"
-        case .checkeredFlag: return "chequered flag, checkered_flag, checkeredflag"
-        case .triangularFlagOnPost: return "triangularflagonpost, triangular_flag_on_post, triangular flag on post"
-        case .crossedFlags: return "crossed flags, crossedflags, crossed_flags"
+        case .radioButton: return "radio button, radio_button, radiobutton"
+        case .whiteSquareButton: return "white square button, white_square_button, whitesquarebutton"
+        case .blackSquareButton: return "black square button, black_square_button, blacksquarebutton"
+        case .checkeredFlag: return "checkered_flag, checkeredflag, chequered flag"
+        case .triangularFlagOnPost: return "triangular flag on post, triangular_flag_on_post, triangularflagonpost"
+        case .crossedFlags: return "crossed flags, crossed_flags, crossedflags"
         case .wavingBlackFlag: return "waving black flag, waving_black_flag, wavingblackflag"
-        case .wavingWhiteFlag: return "wavingwhiteflag, waving_white_flag, white flag"
-        case .rainbowFlag: return "rainbowflag, rainbow-flag, rainbow flag"
+        case .wavingWhiteFlag: return "waving_white_flag, wavingwhiteflag, white flag"
+        case .rainbowFlag: return "rainbow flag, rainbow-flag, rainbowflag"
         case .transgenderFlag: return "transgender flag, transgender_flag, transgenderflag"
-        case .pirateFlag: return "pirate flag, pirateflag, pirate_flag"
-        case .flagAc: return "flag-ac, ascension island flag, flagac"
-        case .flagAd: return "flagad, flag-ad, andorra flag"
-        case .flagAe: return "united arab emirates flag, flagae, flag-ae"
-        case .flagAf: return "afghanistan flag, flagaf, flag-af"
-        case .flagAg: return "antigua & barbuda flag, flagag, flag-ag"
-        case .flagAi: return "flagai, flag-ai, anguilla flag"
-        case .flagAl: return "flagal, flag-al, albania flag"
-        case .flagAm: return "armenia flag, flagam, flag-am"
-        case .flagAo: return "flag-ao, angola flag, flagao"
-        case .flagAq: return "flag-aq, antarctica flag, flagaq"
+        case .pirateFlag: return "pirate flag, pirate_flag, pirateflag"
+        case .flagAc: return "ascension island flag, flag-ac, flagac"
+        case .flagAd: return "andorra flag, flag-ad, flagad"
+        case .flagAe: return "flag-ae, flagae, united arab emirates flag"
+        case .flagAf: return "afghanistan flag, flag-af, flagaf"
+        case .flagAg: return "antigua & barbuda flag, flag-ag, flagag"
+        case .flagAi: return "anguilla flag, flag-ai, flagai"
+        case .flagAl: return "albania flag, flag-al, flagal"
+        case .flagAm: return "armenia flag, flag-am, flagam"
+        case .flagAo: return "angola flag, flag-ao, flagao"
+        case .flagAq: return "antarctica flag, flag-aq, flagaq"
         case .flagAr: return "argentina flag, flag-ar, flagar"
         case .flagAs: return "american samoa flag, flag-as, flagas"
-        case .flagAt: return "flag-at, austria flag, flagat"
-        case .flagAu: return "flag-au, flagau, australia flag"
+        case .flagAt: return "austria flag, flag-at, flagat"
+        case .flagAu: return "australia flag, flag-au, flagau"
         case .flagAw: return "aruba flag, flag-aw, flagaw"
         case .flagAx: return "flag-ax, flagax, åland islands flag"
-        case .flagAz: return "flagaz, flag-az, azerbaijan flag"
-        case .flagBa: return "flagba, flag-ba, bosnia & herzegovina flag"
-        case .flagBb: return "barbados flag, flagbb, flag-bb"
-        case .flagBd: return "flag-bd, bangladesh flag, flagbd"
-        case .flagBe: return "belgium flag, flagbe, flag-be"
-        case .flagBf: return "burkina faso flag, flagbf, flag-bf"
-        case .flagBg: return "flagbg, bulgaria flag, flag-bg"
-        case .flagBh: return "bahrain flag, flagbh, flag-bh"
-        case .flagBi: return "flagbi, flag-bi, burundi flag"
-        case .flagBj: return "flagbj, flag-bj, benin flag"
-        case .flagBl: return "flag-bl, st. barthélemy flag, flagbl"
+        case .flagAz: return "azerbaijan flag, flag-az, flagaz"
+        case .flagBa: return "bosnia & herzegovina flag, flag-ba, flagba"
+        case .flagBb: return "barbados flag, flag-bb, flagbb"
+        case .flagBd: return "bangladesh flag, flag-bd, flagbd"
+        case .flagBe: return "belgium flag, flag-be, flagbe"
+        case .flagBf: return "burkina faso flag, flag-bf, flagbf"
+        case .flagBg: return "bulgaria flag, flag-bg, flagbg"
+        case .flagBh: return "bahrain flag, flag-bh, flagbh"
+        case .flagBi: return "burundi flag, flag-bi, flagbi"
+        case .flagBj: return "benin flag, flag-bj, flagbj"
+        case .flagBl: return "flag-bl, flagbl, st. barthélemy flag"
         case .flagBm: return "bermuda flag, flag-bm, flagbm"
-        case .flagBn: return "flag-bn, brunei flag, flagbn"
-        case .flagBo: return "flag-bo, flagbo, bolivia flag"
-        case .flagBq: return "flagbq, caribbean netherlands flag, flag-bq"
-        case .flagBr: return "flag-br, flagbr, brazil flag"
-        case .flagBs: return "flagbs, flag-bs, bahamas flag"
-        case .flagBt: return "flagbt, flag-bt, bhutan flag"
+        case .flagBn: return "brunei flag, flag-bn, flagbn"
+        case .flagBo: return "bolivia flag, flag-bo, flagbo"
+        case .flagBq: return "caribbean netherlands flag, flag-bq, flagbq"
+        case .flagBr: return "brazil flag, flag-br, flagbr"
+        case .flagBs: return "bahamas flag, flag-bs, flagbs"
+        case .flagBt: return "bhutan flag, flag-bt, flagbt"
         case .flagBv: return "bouvet island flag, flag-bv, flagbv"
         case .flagBw: return "botswana flag, flag-bw, flagbw"
-        case .flagBy: return "flag-by, belarus flag, flagby"
+        case .flagBy: return "belarus flag, flag-by, flagby"
         case .flagBz: return "belize flag, flag-bz, flagbz"
-        case .flagCa: return "flag-ca, flagca, canada flag"
-        case .flagCc: return "flag-cc, cocos (keeling) islands flag, flagcc"
-        case .flagCd: return "flag-cd, flagcd, congo - kinshasa flag"
-        case .flagCf: return "central african republic flag, flagcf, flag-cf"
-        case .flagCg: return "congo - brazzaville flag, flagcg, flag-cg"
-        case .flagCh: return "switzerland flag, flagch, flag-ch"
-        case .flagCi: return "flagci, côte d’ivoire flag, flag-ci"
-        case .flagCk: return "flagck, cook islands flag, flag-ck"
-        case .flagCl: return "flagcl, chile flag, flag-cl"
-        case .flagCm: return "flagcm, flag-cm, cameroon flag"
+        case .flagCa: return "canada flag, flag-ca, flagca"
+        case .flagCc: return "cocos (keeling) islands flag, flag-cc, flagcc"
+        case .flagCd: return "congo - kinshasa flag, flag-cd, flagcd"
+        case .flagCf: return "central african republic flag, flag-cf, flagcf"
+        case .flagCg: return "congo - brazzaville flag, flag-cg, flagcg"
+        case .flagCh: return "flag-ch, flagch, switzerland flag"
+        case .flagCi: return "côte d’ivoire flag, flag-ci, flagci"
+        case .flagCk: return "cook islands flag, flag-ck, flagck"
+        case .flagCl: return "chile flag, flag-cl, flagcl"
+        case .flagCm: return "cameroon flag, flag-cm, flagcm"
         case .cn: return "china flag, cn, flag-cn"
-        case .flagCo: return "flagco, flag-co, colombia flag"
-        case .flagCp: return "clipperton island flag, flagcp, flag-cp"
-        case .flagCr: return "flagcr, costa rica flag, flag-cr"
-        case .flagCu: return "flag-cu, cuba flag, flagcu"
-        case .flagCv: return "flag-cv, flagcv, cape verde flag"
-        case .flagCw: return "flagcw, flag-cw, curaçao flag"
+        case .flagCo: return "colombia flag, flag-co, flagco"
+        case .flagCp: return "clipperton island flag, flag-cp, flagcp"
+        case .flagCr: return "costa rica flag, flag-cr, flagcr"
+        case .flagCu: return "cuba flag, flag-cu, flagcu"
+        case .flagCv: return "cape verde flag, flag-cv, flagcv"
+        case .flagCw: return "curaçao flag, flag-cw, flagcw"
         case .flagCx: return "christmas island flag, flag-cx, flagcx"
-        case .flagCy: return "cyprus flag, flagcy, flag-cy"
-        case .flagCz: return "flag-cz, czechia flag, flagcz"
-        case .de: return "flag-de, de, germany flag"
-        case .flagDg: return "diego garcia flag, flagdg, flag-dg"
-        case .flagDj: return "flag-dj, djibouti flag, flagdj"
-        case .flagDk: return "flag-dk, denmark flag, flagdk"
-        case .flagDm: return "flag-dm, flagdm, dominica flag"
-        case .flagDo: return "dominican republic flag, flagdo, flag-do"
-        case .flagDz: return "flag-dz, algeria flag, flagdz"
-        case .flagEa: return "ceuta & melilla flag, flagea, flag-ea"
-        case .flagEc: return "flag-ec, ecuador flag, flagec"
-        case .flagEe: return "flag-ee, estonia flag, flagee"
+        case .flagCy: return "cyprus flag, flag-cy, flagcy"
+        case .flagCz: return "czechia flag, flag-cz, flagcz"
+        case .de: return "de, flag-de, germany flag"
+        case .flagDg: return "diego garcia flag, flag-dg, flagdg"
+        case .flagDj: return "djibouti flag, flag-dj, flagdj"
+        case .flagDk: return "denmark flag, flag-dk, flagdk"
+        case .flagDm: return "dominica flag, flag-dm, flagdm"
+        case .flagDo: return "dominican republic flag, flag-do, flagdo"
+        case .flagDz: return "algeria flag, flag-dz, flagdz"
+        case .flagEa: return "ceuta & melilla flag, flag-ea, flagea"
+        case .flagEc: return "ecuador flag, flag-ec, flagec"
+        case .flagEe: return "estonia flag, flag-ee, flagee"
         case .flagEg: return "egypt flag, flag-eg, flageg"
-        case .flagEh: return "flag-eh, western sahara flag, flageh"
-        case .flagEr: return "flag-er, eritrea flag, flager"
-        case .es: return "es, spain flag, flag-es"
-        case .flagEt: return "flag-et, ethiopia flag, flaget"
-        case .flagEu: return "flag-eu, european union flag, flageu"
-        case .flagFi: return "finland flag, flagfi, flag-fi"
-        case .flagFj: return "flagfj, flag-fj, fiji flag"
-        case .flagFk: return "flag-fk, flagfk, falkland islands flag"
-        case .flagFm: return "flagfm, flag-fm, micronesia flag"
-        case .flagFo: return "flag-fo, faroe islands flag, flagfo"
-        case .fr: return "flag-fr, france flag, fr"
-        case .flagGa: return "gabon flag, flag-ga, flagga"
-        case .gb: return "gb, uk, united kingdom flag, flag-gb"
-        case .flagGd: return "flaggd, flag-gd, grenada flag"
-        case .flagGe: return "georgia flag, flagge, flag-ge"
-        case .flagGf: return "flag-gf, french guiana flag, flaggf"
-        case .flagGg: return "guernsey flag, flaggg, flag-gg"
-        case .flagGh: return "flaggh, flag-gh, ghana flag"
-        case .flagGi: return "flag-gi, gibraltar flag, flaggi"
+        case .flagEh: return "flag-eh, flageh, western sahara flag"
+        case .flagEr: return "eritrea flag, flag-er, flager"
+        case .es: return "es, flag-es, spain flag"
+        case .flagEt: return "ethiopia flag, flag-et, flaget"
+        case .flagEu: return "european union flag, flag-eu, flageu"
+        case .flagFi: return "finland flag, flag-fi, flagfi"
+        case .flagFj: return "fiji flag, flag-fj, flagfj"
+        case .flagFk: return "falkland islands flag, flag-fk, flagfk"
+        case .flagFm: return "flag-fm, flagfm, micronesia flag"
+        case .flagFo: return "faroe islands flag, flag-fo, flagfo"
+        case .fr: return "flag-fr, fr, france flag"
+        case .flagGa: return "flag-ga, flagga, gabon flag"
+        case .gb: return "flag-gb, gb, uk, united kingdom flag"
+        case .flagGd: return "flag-gd, flaggd, grenada flag"
+        case .flagGe: return "flag-ge, flagge, georgia flag"
+        case .flagGf: return "flag-gf, flaggf, french guiana flag"
+        case .flagGg: return "flag-gg, flaggg, guernsey flag"
+        case .flagGh: return "flag-gh, flaggh, ghana flag"
+        case .flagGi: return "flag-gi, flaggi, gibraltar flag"
         case .flagGl: return "flag-gl, flaggl, greenland flag"
-        case .flagGm: return "flag-gm, gambia flag, flaggm"
-        case .flagGn: return "flaggn, guinea flag, flag-gn"
-        case .flagGp: return "guadeloupe flag, flag-gp, flaggp"
-        case .flagGq: return "flag-gq, equatorial guinea flag, flaggq"
+        case .flagGm: return "flag-gm, flaggm, gambia flag"
+        case .flagGn: return "flag-gn, flaggn, guinea flag"
+        case .flagGp: return "flag-gp, flaggp, guadeloupe flag"
+        case .flagGq: return "equatorial guinea flag, flag-gq, flaggq"
         case .flagGr: return "flag-gr, flaggr, greece flag"
-        case .flagGs: return "flag-gs, south georgia & south sandwich islands flag, flaggs"
+        case .flagGs: return "flag-gs, flaggs, south georgia & south sandwich islands flag"
         case .flagGt: return "flag-gt, flaggt, guatemala flag"
-        case .flagGu: return "flaggu, guam flag, flag-gu"
-        case .flagGw: return "guinea-bissau flag, flag-gw, flaggw"
-        case .flagGy: return "flaggy, flag-gy, guyana flag"
-        case .flagHk: return "flag-hk, hong kong sar china flag, flaghk"
+        case .flagGu: return "flag-gu, flaggu, guam flag"
+        case .flagGw: return "flag-gw, flaggw, guinea-bissau flag"
+        case .flagGy: return "flag-gy, flaggy, guyana flag"
+        case .flagHk: return "flag-hk, flaghk, hong kong sar china flag"
         case .flagHm: return "flag-hm, flaghm, heard & mcdonald islands flag"
-        case .flagHn: return "flag-hn, honduras flag, flaghn"
-        case .flagHr: return "flaghr, croatia flag, flag-hr"
-        case .flagHt: return "flag-ht, haiti flag, flaght"
-        case .flagHu: return "flaghu, flag-hu, hungary flag"
-        case .flagIc: return "flagic, flag-ic, canary islands flag"
-        case .flagId: return "flagid, flag-id, indonesia flag"
-        case .flagIe: return "ireland flag, flagie, flag-ie"
-        case .flagIl: return "flag-il, israel flag, flagil"
-        case .flagIm: return "isle of man flag, flag-im, flagim"
-        case .flagIn: return "india flag, flagin, flag-in"
-        case .flagIo: return "flag-io, british indian ocean territory flag, flagio"
-        case .flagIq: return "flagiq, iraq flag, flag-iq"
-        case .flagIr: return "flag-ir, iran flag, flagir"
-        case .flagIs: return "flag-is, iceland flag, flagis"
-        case .it: return "it, italy flag, flag-it"
-        case .flagJe: return "jersey flag, flagje, flag-je"
-        case .flagJm: return "flag-jm, jamaica flag, flagjm"
-        case .flagJo: return "flag-jo, jordan flag, flagjo"
-        case .jp: return "japan flag, jp, flag-jp"
-        case .flagKe: return "kenya flag, flag-ke, flagke"
-        case .flagKg: return "kyrgyzstan flag, flagkg, flag-kg"
-        case .flagKh: return "cambodia flag, flagkh, flag-kh"
-        case .flagKi: return "flagki, flag-ki, kiribati flag"
-        case .flagKm: return "flag-km, comoros flag, flagkm"
-        case .flagKn: return "st. kitts & nevis flag, flagkn, flag-kn"
-        case .flagKp: return "flag-kp, north korea flag, flagkp"
-        case .kr: return "kr, south korea flag, flag-kr"
+        case .flagHn: return "flag-hn, flaghn, honduras flag"
+        case .flagHr: return "croatia flag, flag-hr, flaghr"
+        case .flagHt: return "flag-ht, flaght, haiti flag"
+        case .flagHu: return "flag-hu, flaghu, hungary flag"
+        case .flagIc: return "canary islands flag, flag-ic, flagic"
+        case .flagId: return "flag-id, flagid, indonesia flag"
+        case .flagIe: return "flag-ie, flagie, ireland flag"
+        case .flagIl: return "flag-il, flagil, israel flag"
+        case .flagIm: return "flag-im, flagim, isle of man flag"
+        case .flagIn: return "flag-in, flagin, india flag"
+        case .flagIo: return "british indian ocean territory flag, flag-io, flagio"
+        case .flagIq: return "flag-iq, flagiq, iraq flag"
+        case .flagIr: return "flag-ir, flagir, iran flag"
+        case .flagIs: return "flag-is, flagis, iceland flag"
+        case .it: return "flag-it, it, italy flag"
+        case .flagJe: return "flag-je, flagje, jersey flag"
+        case .flagJm: return "flag-jm, flagjm, jamaica flag"
+        case .flagJo: return "flag-jo, flagjo, jordan flag"
+        case .jp: return "flag-jp, japan flag, jp"
+        case .flagKe: return "flag-ke, flagke, kenya flag"
+        case .flagKg: return "flag-kg, flagkg, kyrgyzstan flag"
+        case .flagKh: return "cambodia flag, flag-kh, flagkh"
+        case .flagKi: return "flag-ki, flagki, kiribati flag"
+        case .flagKm: return "comoros flag, flag-km, flagkm"
+        case .flagKn: return "flag-kn, flagkn, st. kitts & nevis flag"
+        case .flagKp: return "flag-kp, flagkp, north korea flag"
+        case .kr: return "flag-kr, kr, south korea flag"
         case .flagKw: return "flag-kw, flagkw, kuwait flag"
-        case .flagKy: return "flagky, cayman islands flag, flag-ky"
-        case .flagKz: return "flag-kz, kazakhstan flag, flagkz"
-        case .flagLa: return "flagla, flag-la, laos flag"
-        case .flagLb: return "flaglb, lebanon flag, flag-lb"
-        case .flagLc: return "st. lucia flag, flag-lc, flaglc"
-        case .flagLi: return "flag-li, liechtenstein flag, flagli"
+        case .flagKy: return "cayman islands flag, flag-ky, flagky"
+        case .flagKz: return "flag-kz, flagkz, kazakhstan flag"
+        case .flagLa: return "flag-la, flagla, laos flag"
+        case .flagLb: return "flag-lb, flaglb, lebanon flag"
+        case .flagLc: return "flag-lc, flaglc, st. lucia flag"
+        case .flagLi: return "flag-li, flagli, liechtenstein flag"
         case .flagLk: return "flag-lk, flaglk, sri lanka flag"
-        case .flagLr: return "flaglr, liberia flag, flag-lr"
-        case .flagLs: return "flagls, flag-ls, lesotho flag"
-        case .flagLt: return "lithuania flag, flaglt, flag-lt"
-        case .flagLu: return "luxembourg flag, flaglu, flag-lu"
-        case .flagLv: return "flaglv, latvia flag, flag-lv"
-        case .flagLy: return "libya flag, flagly, flag-ly"
-        case .flagMa: return "flag-ma, morocco flag, flagma"
-        case .flagMc: return "flag-mc, monaco flag, flagmc"
-        case .flagMd: return "flagmd, flag-md, moldova flag"
-        case .flagMe: return "montenegro flag, flag-me, flagme"
-        case .flagMf: return "flagmf, flag-mf, st. martin flag"
-        case .flagMg: return "flag-mg, madagascar flag, flagmg"
+        case .flagLr: return "flag-lr, flaglr, liberia flag"
+        case .flagLs: return "flag-ls, flagls, lesotho flag"
+        case .flagLt: return "flag-lt, flaglt, lithuania flag"
+        case .flagLu: return "flag-lu, flaglu, luxembourg flag"
+        case .flagLv: return "flag-lv, flaglv, latvia flag"
+        case .flagLy: return "flag-ly, flagly, libya flag"
+        case .flagMa: return "flag-ma, flagma, morocco flag"
+        case .flagMc: return "flag-mc, flagmc, monaco flag"
+        case .flagMd: return "flag-md, flagmd, moldova flag"
+        case .flagMe: return "flag-me, flagme, montenegro flag"
+        case .flagMf: return "flag-mf, flagmf, st. martin flag"
+        case .flagMg: return "flag-mg, flagmg, madagascar flag"
         case .flagMh: return "flag-mh, flagmh, marshall islands flag"
-        case .flagMk: return "flagmk, flag-mk, north macedonia flag"
-        case .flagMl: return "flag-ml, mali flag, flagml"
+        case .flagMk: return "flag-mk, flagmk, north macedonia flag"
+        case .flagMl: return "flag-ml, flagml, mali flag"
         case .flagMm: return "flag-mm, flagmm, myanmar (burma) flag"
         case .flagMn: return "flag-mn, flagmn, mongolia flag"
-        case .flagMo: return "flag-mo, macao sar china flag, flagmo"
-        case .flagMp: return "flagmp, northern mariana islands flag, flag-mp"
-        case .flagMq: return "martinique flag, flagmq, flag-mq"
-        case .flagMr: return "flagmr, mauritania flag, flag-mr"
-        case .flagMs: return "montserrat flag, flagms, flag-ms"
-        case .flagMt: return "flag-mt, malta flag, flagmt"
+        case .flagMo: return "flag-mo, flagmo, macao sar china flag"
+        case .flagMp: return "flag-mp, flagmp, northern mariana islands flag"
+        case .flagMq: return "flag-mq, flagmq, martinique flag"
+        case .flagMr: return "flag-mr, flagmr, mauritania flag"
+        case .flagMs: return "flag-ms, flagms, montserrat flag"
+        case .flagMt: return "flag-mt, flagmt, malta flag"
         case .flagMu: return "flag-mu, flagmu, mauritius flag"
-        case .flagMv: return "maldives flag, flag-mv, flagmv"
-        case .flagMw: return "flagmw, flag-mw, malawi flag"
-        case .flagMx: return "mexico flag, flagmx, flag-mx"
-        case .flagMy: return "flag-my, malaysia flag, flagmy"
-        case .flagMz: return "flagmz, flag-mz, mozambique flag"
-        case .flagNa: return "flagna, namibia flag, flag-na"
-        case .flagNc: return "new caledonia flag, flagnc, flag-nc"
-        case .flagNe: return "flagne, niger flag, flag-ne"
-        case .flagNf: return "flagnf, flag-nf, norfolk island flag"
-        case .flagNg: return "nigeria flag, flag-ng, flagng"
-        case .flagNi: return "flag-ni, nicaragua flag, flagni"
-        case .flagNl: return "flag-nl, netherlands flag, flagnl"
-        case .flagNo: return "norway flag, flagno, flag-no"
-        case .flagNp: return "flagnp, flag-np, nepal flag"
-        case .flagNr: return "flagnr, flag-nr, nauru flag"
-        case .flagNu: return "flag-nu, niue flag, flagnu"
-        case .flagNz: return "new zealand flag, flagnz, flag-nz"
-        case .flagOm: return "flagom, oman flag, flag-om"
-        case .flagPa: return "panama flag, flagpa, flag-pa"
-        case .flagPe: return "peru flag, flagpe, flag-pe"
-        case .flagPf: return "flagpf, flag-pf, french polynesia flag"
-        case .flagPg: return "flagpg, flag-pg, papua new guinea flag"
+        case .flagMv: return "flag-mv, flagmv, maldives flag"
+        case .flagMw: return "flag-mw, flagmw, malawi flag"
+        case .flagMx: return "flag-mx, flagmx, mexico flag"
+        case .flagMy: return "flag-my, flagmy, malaysia flag"
+        case .flagMz: return "flag-mz, flagmz, mozambique flag"
+        case .flagNa: return "flag-na, flagna, namibia flag"
+        case .flagNc: return "flag-nc, flagnc, new caledonia flag"
+        case .flagNe: return "flag-ne, flagne, niger flag"
+        case .flagNf: return "flag-nf, flagnf, norfolk island flag"
+        case .flagNg: return "flag-ng, flagng, nigeria flag"
+        case .flagNi: return "flag-ni, flagni, nicaragua flag"
+        case .flagNl: return "flag-nl, flagnl, netherlands flag"
+        case .flagNo: return "flag-no, flagno, norway flag"
+        case .flagNp: return "flag-np, flagnp, nepal flag"
+        case .flagNr: return "flag-nr, flagnr, nauru flag"
+        case .flagNu: return "flag-nu, flagnu, niue flag"
+        case .flagNz: return "flag-nz, flagnz, new zealand flag"
+        case .flagOm: return "flag-om, flagom, oman flag"
+        case .flagPa: return "flag-pa, flagpa, panama flag"
+        case .flagPe: return "flag-pe, flagpe, peru flag"
+        case .flagPf: return "flag-pf, flagpf, french polynesia flag"
+        case .flagPg: return "flag-pg, flagpg, papua new guinea flag"
         case .flagPh: return "flag-ph, flagph, philippines flag"
-        case .flagPk: return "flagpk, flag-pk, pakistan flag"
+        case .flagPk: return "flag-pk, flagpk, pakistan flag"
         case .flagPl: return "flag-pl, flagpl, poland flag"
-        case .flagPm: return "flag-pm, st. pierre & miquelon flag, flagpm"
-        case .flagPn: return "flagpn, pitcairn islands flag, flag-pn"
-        case .flagPr: return "puerto rico flag, flagpr, flag-pr"
-        case .flagPs: return "flag-ps, palestinian territories flag, flagps"
-        case .flagPt: return "flag-pt, portugal flag, flagpt"
-        case .flagPw: return "palau flag, flagpw, flag-pw"
-        case .flagPy: return "flagpy, flag-py, paraguay flag"
-        case .flagQa: return "flagqa, qatar flag, flag-qa"
+        case .flagPm: return "flag-pm, flagpm, st. pierre & miquelon flag"
+        case .flagPn: return "flag-pn, flagpn, pitcairn islands flag"
+        case .flagPr: return "flag-pr, flagpr, puerto rico flag"
+        case .flagPs: return "flag-ps, flagps, palestinian territories flag"
+        case .flagPt: return "flag-pt, flagpt, portugal flag"
+        case .flagPw: return "flag-pw, flagpw, palau flag"
+        case .flagPy: return "flag-py, flagpy, paraguay flag"
+        case .flagQa: return "flag-qa, flagqa, qatar flag"
         case .flagRe: return "flag-re, flagre, réunion flag"
-        case .flagRo: return "flag-ro, romania flag, flagro"
-        case .flagRs: return "flagrs, flag-rs, serbia flag"
-        case .ru: return "russia flag, ru, flag-ru"
-        case .flagRw: return "rwanda flag, flag-rw, flagrw"
+        case .flagRo: return "flag-ro, flagro, romania flag"
+        case .flagRs: return "flag-rs, flagrs, serbia flag"
+        case .ru: return "flag-ru, ru, russia flag"
+        case .flagRw: return "flag-rw, flagrw, rwanda flag"
         case .flagSa: return "flag-sa, flagsa, saudi arabia flag"
-        case .flagSb: return "solomon islands flag, flag-sb, flagsb"
-        case .flagSc: return "flagsc, seychelles flag, flag-sc"
+        case .flagSb: return "flag-sb, flagsb, solomon islands flag"
+        case .flagSc: return "flag-sc, flagsc, seychelles flag"
         case .flagSd: return "flag-sd, flagsd, sudan flag"
-        case .flagSe: return "flag-se, sweden flag, flagse"
-        case .flagSg: return "flag-sg, singapore flag, flagsg"
-        case .flagSh: return "flagsh, st. helena flag, flag-sh"
-        case .flagSi: return "flag-si, slovenia flag, flagsi"
-        case .flagSj: return "flag-sj, svalbard & jan mayen flag, flagsj"
-        case .flagSk: return "slovakia flag, flagsk, flag-sk"
-        case .flagSl: return "sierra leone flag, flag-sl, flagsl"
-        case .flagSm: return "flag-sm, san marino flag, flagsm"
-        case .flagSn: return "senegal flag, flagsn, flag-sn"
-        case .flagSo: return "flagso, flag-so, somalia flag"
-        case .flagSr: return "flag-sr, suriname flag, flagsr"
-        case .flagSs: return "flag-ss, south sudan flag, flagss"
-        case .flagSt: return "flagst, flag-st, são tomé & príncipe flag"
-        case .flagSv: return "flag-sv, el salvador flag, flagsv"
-        case .flagSx: return "flag-sx, sint maarten flag, flagsx"
-        case .flagSy: return "flag-sy, syria flag, flagsy"
-        case .flagSz: return "flagsz, eswatini flag, flag-sz"
+        case .flagSe: return "flag-se, flagse, sweden flag"
+        case .flagSg: return "flag-sg, flagsg, singapore flag"
+        case .flagSh: return "flag-sh, flagsh, st. helena flag"
+        case .flagSi: return "flag-si, flagsi, slovenia flag"
+        case .flagSj: return "flag-sj, flagsj, svalbard & jan mayen flag"
+        case .flagSk: return "flag-sk, flagsk, slovakia flag"
+        case .flagSl: return "flag-sl, flagsl, sierra leone flag"
+        case .flagSm: return "flag-sm, flagsm, san marino flag"
+        case .flagSn: return "flag-sn, flagsn, senegal flag"
+        case .flagSo: return "flag-so, flagso, somalia flag"
+        case .flagSr: return "flag-sr, flagsr, suriname flag"
+        case .flagSs: return "flag-ss, flagss, south sudan flag"
+        case .flagSt: return "flag-st, flagst, são tomé & príncipe flag"
+        case .flagSv: return "el salvador flag, flag-sv, flagsv"
+        case .flagSx: return "flag-sx, flagsx, sint maarten flag"
+        case .flagSy: return "flag-sy, flagsy, syria flag"
+        case .flagSz: return "eswatini flag, flag-sz, flagsz"
         case .flagTa: return "flag-ta, flagta, tristan da cunha flag"
-        case .flagTc: return "flagtc, turks & caicos islands flag, flag-tc"
-        case .flagTd: return "flagtd, flag-td, chad flag"
-        case .flagTf: return "flag-tf, french southern territories flag, flagtf"
-        case .flagTg: return "flagtg, togo flag, flag-tg"
-        case .flagTh: return "thailand flag, flagth, flag-th"
-        case .flagTj: return "tajikistan flag, flagtj, flag-tj"
-        case .flagTk: return "tokelau flag, flag-tk, flagtk"
-        case .flagTl: return "flag-tl, timor-leste flag, flagtl"
-        case .flagTm: return "flag-tm, turkmenistan flag, flagtm"
-        case .flagTn: return "flagtn, tunisia flag, flag-tn"
+        case .flagTc: return "flag-tc, flagtc, turks & caicos islands flag"
+        case .flagTd: return "chad flag, flag-td, flagtd"
+        case .flagTf: return "flag-tf, flagtf, french southern territories flag"
+        case .flagTg: return "flag-tg, flagtg, togo flag"
+        case .flagTh: return "flag-th, flagth, thailand flag"
+        case .flagTj: return "flag-tj, flagtj, tajikistan flag"
+        case .flagTk: return "flag-tk, flagtk, tokelau flag"
+        case .flagTl: return "flag-tl, flagtl, timor-leste flag"
+        case .flagTm: return "flag-tm, flagtm, turkmenistan flag"
+        case .flagTn: return "flag-tn, flagtn, tunisia flag"
         case .flagTo: return "flag-to, flagto, tonga flag"
-        case .flagTr: return "flagtr, flag-tr, turkey flag"
-        case .flagTt: return "flag-tt, trinidad & tobago flag, flagtt"
-        case .flagTv: return "tuvalu flag, flag-tv, flagtv"
-        case .flagTw: return "flag-tw, taiwan flag, flagtw"
+        case .flagTr: return "flag-tr, flagtr, turkey flag"
+        case .flagTt: return "flag-tt, flagtt, trinidad & tobago flag"
+        case .flagTv: return "flag-tv, flagtv, tuvalu flag"
+        case .flagTw: return "flag-tw, flagtw, taiwan flag"
         case .flagTz: return "flag-tz, flagtz, tanzania flag"
-        case .flagUa: return "ukraine flag, flagua, flag-ua"
-        case .flagUg: return "flagug, uganda flag, flag-ug"
+        case .flagUa: return "flag-ua, flagua, ukraine flag"
+        case .flagUg: return "flag-ug, flagug, uganda flag"
         case .flagUm: return "flag-um, flagum, u.s. outlying islands flag"
-        case .flagUn: return "united nations flag, flag-un, flagun"
-        case .us: return "flag-us, us, united states flag"
-        case .flagUy: return "flaguy, uruguay flag, flag-uy"
-        case .flagUz: return "flag-uz, uzbekistan flag, flaguz"
+        case .flagUn: return "flag-un, flagun, united nations flag"
+        case .us: return "flag-us, united states flag, us"
+        case .flagUy: return "flag-uy, flaguy, uruguay flag"
+        case .flagUz: return "flag-uz, flaguz, uzbekistan flag"
         case .flagVa: return "flag-va, flagva, vatican city flag"
-        case .flagVc: return "flag-vc, st. vincent & grenadines flag, flagvc"
-        case .flagVe: return "flag-ve, venezuela flag, flagve"
-        case .flagVg: return "flag-vg, flagvg, british virgin islands flag"
-        case .flagVi: return "flagvi, u.s. virgin islands flag, flag-vi"
-        case .flagVn: return "flagvn, flag-vn, vietnam flag"
-        case .flagVu: return "flagvu, vanuatu flag, flag-vu"
-        case .flagWf: return "flag-wf, wallis & futuna flag, flagwf"
-        case .flagWs: return "flag-ws, samoa flag, flagws"
-        case .flagXk: return "flagxk, kosovo flag, flag-xk"
-        case .flagYe: return "flagye, yemen flag, flag-ye"
+        case .flagVc: return "flag-vc, flagvc, st. vincent & grenadines flag"
+        case .flagVe: return "flag-ve, flagve, venezuela flag"
+        case .flagVg: return "british virgin islands flag, flag-vg, flagvg"
+        case .flagVi: return "flag-vi, flagvi, u.s. virgin islands flag"
+        case .flagVn: return "flag-vn, flagvn, vietnam flag"
+        case .flagVu: return "flag-vu, flagvu, vanuatu flag"
+        case .flagWf: return "flag-wf, flagwf, wallis & futuna flag"
+        case .flagWs: return "flag-ws, flagws, samoa flag"
+        case .flagXk: return "flag-xk, flagxk, kosovo flag"
+        case .flagYe: return "flag-ye, flagye, yemen flag"
         case .flagYt: return "flag-yt, flagyt, mayotte flag"
-        case .flagZa: return "south africa flag, flagza, flag-za"
-        case .flagZm: return "flag-zm, zambia flag, flagzm"
-        case .flagZw: return "flagzw, zimbabwe flag, flag-zw"
-        case .flagEngland: return "flagengland, england flag, flag-england"
-        case .flagScotland: return "scotland flag, flagscotland, flag-scotland"
-        case .flagWales: return "flagwales, flag-wales, wales flag"
+        case .flagZa: return "flag-za, flagza, south africa flag"
+        case .flagZm: return "flag-zm, flagzm, zambia flag"
+        case .flagZw: return "flag-zw, flagzw, zimbabwe flag"
+        case .flagEngland: return "england flag, flag-england, flagengland"
+        case .flagScotland: return "flag-scotland, flagscotland, scotland flag"
+        case .flagWales: return "flag-wales, flagwales, wales flag"
         }
     }
 }
diff --git a/Session/Emoji/Emoji+SkinTones.swift b/Session/Emoji/Emoji+SkinTones.swift
index e9aaec044..facfd6d44 100644
--- a/Session/Emoji/Emoji+SkinTones.swift
+++ b/Session/Emoji/Emoji+SkinTones.swift
@@ -106,6 +106,22 @@ extension Emoji {
                 [.mediumDark]: "🫴🏾",
                 [.dark]: "🫴🏿",
             ]
+        case .leftwardsPushingHand:
+            return [
+                [.light]: "🫷🏻",
+                [.mediumLight]: "🫷🏼",
+                [.medium]: "🫷🏽",
+                [.mediumDark]: "🫷🏾",
+                [.dark]: "🫷🏿",
+            ]
+        case .rightwardsPushingHand:
+            return [
+                [.light]: "🫸🏻",
+                [.mediumLight]: "🫸🏼",
+                [.medium]: "🫸🏽",
+                [.mediumDark]: "🫸🏾",
+                [.dark]: "🫸🏿",
+            ]
         case .okHand:
             return [
                 [.light]: "👌🏻",
diff --git a/Session/Emoji/Emoji.swift b/Session/Emoji/Emoji.swift
index 096dae434..15cda7df5 100644
--- a/Session/Emoji/Emoji.swift
+++ b/Session/Emoji/Emoji.swift
@@ -54,6 +54,7 @@ enum Emoji: String, CaseIterable, Equatable {
     case grimacing = "😬"
     case faceExhaling = "😮‍💨"
     case lyingFace = "🤥"
+    case shakingFace = "🫨"
     case relieved = "😌"
     case pensive = "😔"
     case sleepy = "😪"
@@ -131,7 +132,6 @@ enum Emoji: String, CaseIterable, Equatable {
     case seeNoEvil = "🙈"
     case hearNoEvil = "🙉"
     case speakNoEvil = "🙊"
-    case kiss = "💋"
     case loveLetter = "💌"
     case cupid = "💘"
     case giftHeart = "💝"
@@ -146,14 +146,18 @@ enum Emoji: String, CaseIterable, Equatable {
     case heartOnFire = "❤️‍🔥"
     case mendingHeart = "❤️‍🩹"
     case heart = "❤️"
+    case pinkHeart = "🩷"
     case orangeHeart = "🧡"
     case yellowHeart = "💛"
     case greenHeart = "💚"
     case blueHeart = "💙"
+    case lightBlueHeart = "🩵"
     case purpleHeart = "💜"
     case brownHeart = "🤎"
     case blackHeart = "🖤"
+    case greyHeart = "🩶"
     case whiteHeart = "🤍"
+    case kiss = "💋"
     case oneHundred = "💯"
     case anger = "💢"
     case boom = "💥"
@@ -161,7 +165,6 @@ enum Emoji: String, CaseIterable, Equatable {
     case sweatDrops = "💦"
     case dash = "💨"
     case hole = "🕳️"
-    case bomb = "💣"
     case speechBalloon = "💬"
     case eyeInSpeechBubble = "👁️‍🗨️"
     case leftSpeechBubble = "🗨️"
@@ -177,6 +180,8 @@ enum Emoji: String, CaseIterable, Equatable {
     case leftwardsHand = "🫲"
     case palmDownHand = "🫳"
     case palmUpHand = "🫴"
+    case leftwardsPushingHand = "🫷"
+    case rightwardsPushingHand = "🫸"
     case okHand = "👌"
     case pinchedFingers = "🤌"
     case pinchingHand = "🤏"
@@ -554,6 +559,8 @@ enum Emoji: String, CaseIterable, Equatable {
     case tiger2 = "🐅"
     case leopard = "🐆"
     case horse = "🐴"
+    case moose = "🫎"
+    case donkey = "🫏"
     case racehorse = "🐎"
     case unicornFace = "🦄"
     case zebraFace = "🦓"
@@ -616,6 +623,9 @@ enum Emoji: String, CaseIterable, Equatable {
     case flamingo = "🦩"
     case peacock = "🦚"
     case parrot = "🦜"
+    case wing = "🪽"
+    case blackBird = "🐦‍⬛"
+    case goose = "🪿"
     case frog = "🐸"
     case crocodile = "🐊"
     case turtle = "🐢"
@@ -636,6 +646,7 @@ enum Emoji: String, CaseIterable, Equatable {
     case octopus = "🐙"
     case shell = "🐚"
     case coral = "🪸"
+    case jellyfish = "🪼"
     case snail = "🐌"
     case butterfly = "🦋"
     case bug = "🐛"
@@ -663,6 +674,7 @@ enum Emoji: String, CaseIterable, Equatable {
     case sunflower = "🌻"
     case blossom = "🌼"
     case tulip = "🌷"
+    case hyacinth = "🪻"
     case seedling = "🌱"
     case pottedPlant = "🪴"
     case evergreenTree = "🌲"
@@ -678,6 +690,7 @@ enum Emoji: String, CaseIterable, Equatable {
     case leaves = "🍃"
     case emptyNest = "🪹"
     case nestWithEggs = "🪺"
+    case mushroom = "🍄"
     case grapes = "🍇"
     case melon = "🍈"
     case watermelon = "🍉"
@@ -709,10 +722,11 @@ enum Emoji: String, CaseIterable, Equatable {
     case broccoli = "🥦"
     case garlic = "🧄"
     case onion = "🧅"
-    case mushroom = "🍄"
     case peanuts = "🥜"
     case beans = "🫘"
     case chestnut = "🌰"
+    case gingerRoot = "🫚"
+    case peaPod = "🫛"
     case bread = "🍞"
     case croissant = "🥐"
     case baguetteBread = "🥖"
@@ -1085,11 +1099,10 @@ enum Emoji: String, CaseIterable, Equatable {
     case dart = "🎯"
     case yoYo = "🪀"
     case kite = "🪁"
+    case gun = "🔫"
     case eightBall = "🎱"
     case crystalBall = "🔮"
     case magicWand = "🪄"
-    case nazarAmulet = "🧿"
-    case hamsa = "🪬"
     case videoGame = "🎮"
     case joystick = "🕹️"
     case slotMachine = "🎰"
@@ -1134,6 +1147,7 @@ enum Emoji: String, CaseIterable, Equatable {
     case shorts = "🩳"
     case bikini = "👙"
     case womansClothes = "👚"
+    case foldingHandFan = "🪭"
     case purse = "👛"
     case handbag = "👜"
     case pouch = "👝"
@@ -1148,6 +1162,7 @@ enum Emoji: String, CaseIterable, Equatable {
     case sandal = "👡"
     case balletShoes = "🩰"
     case boot = "👢"
+    case hairPick = "🪮"
     case crown = "👑"
     case womansHat = "👒"
     case tophat = "🎩"
@@ -1186,6 +1201,8 @@ enum Emoji: String, CaseIterable, Equatable {
     case banjo = "🪕"
     case drumWithDrumsticks = "🥁"
     case longDrum = "🪘"
+    case maracas = "🪇"
+    case flute = "🪈"
     case iphone = "📱"
     case calling = "📲"
     case phone = "☎️"
@@ -1305,7 +1322,7 @@ enum Emoji: String, CaseIterable, Equatable {
     case hammerAndWrench = "🛠️"
     case daggerKnife = "🗡️"
     case crossedSwords = "⚔️"
-    case gun = "🔫"
+    case bomb = "💣"
     case boomerang = "🪃"
     case bowAndArrow = "🏹"
     case shield = "🛡️"
@@ -1366,6 +1383,8 @@ enum Emoji: String, CaseIterable, Equatable {
     case coffin = "⚰️"
     case headstone = "🪦"
     case funeralUrn = "⚱️"
+    case nazarAmulet = "🧿"
+    case hamsa = "🪬"
     case moyai = "🗿"
     case placard = "🪧"
     case identificationCard = "🪪"
@@ -1428,6 +1447,7 @@ enum Emoji: String, CaseIterable, Equatable {
     case peaceSymbol = "☮️"
     case menorahWithNineBranches = "🕎"
     case sixPointedStar = "🔯"
+    case khanda = "🪯"
     case aries = "♈"
     case taurus = "♉"
     case gemini = "♊"
@@ -1463,6 +1483,7 @@ enum Emoji: String, CaseIterable, Equatable {
     case lowBrightness = "🔅"
     case highBrightness = "🔆"
     case signalStrength = "📶"
+    case wireless = "🛜"
     case vibrationMode = "📳"
     case mobilePhoneOff = "📴"
     case femaleSign = "♀️"
diff --git a/Session/Emoji/EmojiWithSkinTones+String.swift b/Session/Emoji/EmojiWithSkinTones+String.swift
index 218048c86..8f4bd5d74 100644
--- a/Session/Emoji/EmojiWithSkinTones+String.swift
+++ b/Session/Emoji/EmojiWithSkinTones+String.swift
@@ -4,7266 +4,4725 @@
 extension EmojiWithSkinTones {
     init?(rawValue: String) {
         guard rawValue.isSingleEmoji else { return nil }
-        if rawValue == "😀" {
-            self.init(baseEmoji: .grinning, skinTones: nil)
-        } else if rawValue == "😃" {
-            self.init(baseEmoji: .smiley, skinTones: nil)
-        } else if rawValue == "😄" {
-            self.init(baseEmoji: .smile, skinTones: nil)
-        } else if rawValue == "😁" {
-            self.init(baseEmoji: .grin, skinTones: nil)
-        } else if rawValue == "😆" {
-            self.init(baseEmoji: .laughing, skinTones: nil)
-        } else if rawValue == "😅" {
-            self.init(baseEmoji: .sweatSmile, skinTones: nil)
-        } else if rawValue == "🤣" {
-            self.init(baseEmoji: .rollingOnTheFloorLaughing, skinTones: nil)
-        } else if rawValue == "😂" {
-            self.init(baseEmoji: .joy, skinTones: nil)
-        } else if rawValue == "🙂" {
-            self.init(baseEmoji: .slightlySmilingFace, skinTones: nil)
-        } else if rawValue == "🙃" {
-            self.init(baseEmoji: .upsideDownFace, skinTones: nil)
-        } else if rawValue == "🫠" {
-            self.init(baseEmoji: .meltingFace, skinTones: nil)
-        } else if rawValue == "😉" {
-            self.init(baseEmoji: .wink, skinTones: nil)
-        } else if rawValue == "😊" {
-            self.init(baseEmoji: .blush, skinTones: nil)
-        } else if rawValue == "😇" {
-            self.init(baseEmoji: .innocent, skinTones: nil)
-        } else if rawValue == "🥰" {
-            self.init(baseEmoji: .smilingFaceWith3Hearts, skinTones: nil)
-        } else if rawValue == "😍" {
-            self.init(baseEmoji: .heartEyes, skinTones: nil)
-        } else if rawValue == "🤩" {
-            self.init(baseEmoji: .starStruck, skinTones: nil)
-        } else if rawValue == "😘" {
-            self.init(baseEmoji: .kissingHeart, skinTones: nil)
-        } else if rawValue == "😗" {
-            self.init(baseEmoji: .kissing, skinTones: nil)
-        } else if rawValue == "☺️" {
-            self.init(baseEmoji: .relaxed, skinTones: nil)
-        } else if rawValue == "😚" {
-            self.init(baseEmoji: .kissingClosedEyes, skinTones: nil)
-        } else if rawValue == "😙" {
-            self.init(baseEmoji: .kissingSmilingEyes, skinTones: nil)
-        } else if rawValue == "🥲" {
-            self.init(baseEmoji: .smilingFaceWithTear, skinTones: nil)
-        } else if rawValue == "😋" {
-            self.init(baseEmoji: .yum, skinTones: nil)
-        } else if rawValue == "😛" {
-            self.init(baseEmoji: .stuckOutTongue, skinTones: nil)
-        } else if rawValue == "😜" {
-            self.init(baseEmoji: .stuckOutTongueWinkingEye, skinTones: nil)
-        } else if rawValue == "🤪" {
-            self.init(baseEmoji: .zanyFace, skinTones: nil)
-        } else if rawValue == "😝" {
-            self.init(baseEmoji: .stuckOutTongueClosedEyes, skinTones: nil)
-        } else if rawValue == "🤑" {
-            self.init(baseEmoji: .moneyMouthFace, skinTones: nil)
-        } else if rawValue == "🤗" {
-            self.init(baseEmoji: .huggingFace, skinTones: nil)
-        } else if rawValue == "🤭" {
-            self.init(baseEmoji: .faceWithHandOverMouth, skinTones: nil)
-        } else if rawValue == "🫢" {
-            self.init(baseEmoji: .faceWithOpenEyesAndHandOverMouth, skinTones: nil)
-        } else if rawValue == "🫣" {
-            self.init(baseEmoji: .faceWithPeekingEye, skinTones: nil)
-        } else if rawValue == "🤫" {
-            self.init(baseEmoji: .shushingFace, skinTones: nil)
-        } else if rawValue == "🤔" {
-            self.init(baseEmoji: .thinkingFace, skinTones: nil)
-        } else if rawValue == "🫡" {
-            self.init(baseEmoji: .salutingFace, skinTones: nil)
-        } else if rawValue == "🤐" {
-            self.init(baseEmoji: .zipperMouthFace, skinTones: nil)
-        } else if rawValue == "🤨" {
-            self.init(baseEmoji: .faceWithRaisedEyebrow, skinTones: nil)
-        } else if rawValue == "😐" {
-            self.init(baseEmoji: .neutralFace, skinTones: nil)
-        } else if rawValue == "😑" {
-            self.init(baseEmoji: .expressionless, skinTones: nil)
-        } else if rawValue == "😶" {
-            self.init(baseEmoji: .noMouth, skinTones: nil)
-        } else if rawValue == "🫥" {
-            self.init(baseEmoji: .dottedLineFace, skinTones: nil)
-        } else if rawValue == "😶‍🌫️" {
-            self.init(baseEmoji: .faceInClouds, skinTones: nil)
-        } else if rawValue == "😏" {
-            self.init(baseEmoji: .smirk, skinTones: nil)
-        } else if rawValue == "😒" {
-            self.init(baseEmoji: .unamused, skinTones: nil)
-        } else if rawValue == "🙄" {
-            self.init(baseEmoji: .faceWithRollingEyes, skinTones: nil)
-        } else if rawValue == "😬" {
-            self.init(baseEmoji: .grimacing, skinTones: nil)
-        } else if rawValue == "😮‍💨" {
-            self.init(baseEmoji: .faceExhaling, skinTones: nil)
-        } else if rawValue == "🤥" {
-            self.init(baseEmoji: .lyingFace, skinTones: nil)
-        } else if rawValue == "😌" {
-            self.init(baseEmoji: .relieved, skinTones: nil)
-        } else if rawValue == "😔" {
-            self.init(baseEmoji: .pensive, skinTones: nil)
-        } else if rawValue == "😪" {
-            self.init(baseEmoji: .sleepy, skinTones: nil)
-        } else if rawValue == "🤤" {
-            self.init(baseEmoji: .droolingFace, skinTones: nil)
-        } else if rawValue == "😴" {
-            self.init(baseEmoji: .sleeping, skinTones: nil)
-        } else if rawValue == "😷" {
-            self.init(baseEmoji: .mask, skinTones: nil)
-        } else if rawValue == "🤒" {
-            self.init(baseEmoji: .faceWithThermometer, skinTones: nil)
-        } else if rawValue == "🤕" {
-            self.init(baseEmoji: .faceWithHeadBandage, skinTones: nil)
-        } else if rawValue == "🤢" {
-            self.init(baseEmoji: .nauseatedFace, skinTones: nil)
-        } else if rawValue == "🤮" {
-            self.init(baseEmoji: .faceVomiting, skinTones: nil)
-        } else if rawValue == "🤧" {
-            self.init(baseEmoji: .sneezingFace, skinTones: nil)
-        } else if rawValue == "🥵" {
-            self.init(baseEmoji: .hotFace, skinTones: nil)
-        } else if rawValue == "🥶" {
-            self.init(baseEmoji: .coldFace, skinTones: nil)
-        } else if rawValue == "🥴" {
-            self.init(baseEmoji: .woozyFace, skinTones: nil)
-        } else if rawValue == "😵" {
-            self.init(baseEmoji: .dizzyFace, skinTones: nil)
-        } else if rawValue == "😵‍💫" {
-            self.init(baseEmoji: .faceWithSpiralEyes, skinTones: nil)
-        } else if rawValue == "🤯" {
-            self.init(baseEmoji: .explodingHead, skinTones: nil)
-        } else if rawValue == "🤠" {
-            self.init(baseEmoji: .faceWithCowboyHat, skinTones: nil)
-        } else if rawValue == "🥳" {
-            self.init(baseEmoji: .partyingFace, skinTones: nil)
-        } else if rawValue == "🥸" {
-            self.init(baseEmoji: .disguisedFace, skinTones: nil)
-        } else if rawValue == "😎" {
-            self.init(baseEmoji: .sunglasses, skinTones: nil)
-        } else if rawValue == "🤓" {
-            self.init(baseEmoji: .nerdFace, skinTones: nil)
-        } else if rawValue == "🧐" {
-            self.init(baseEmoji: .faceWithMonocle, skinTones: nil)
-        } else if rawValue == "😕" {
-            self.init(baseEmoji: .confused, skinTones: nil)
-        } else if rawValue == "🫤" {
-            self.init(baseEmoji: .faceWithDiagonalMouth, skinTones: nil)
-        } else if rawValue == "😟" {
-            self.init(baseEmoji: .worried, skinTones: nil)
-        } else if rawValue == "🙁" {
-            self.init(baseEmoji: .slightlyFrowningFace, skinTones: nil)
-        } else if rawValue == "☹️" {
-            self.init(baseEmoji: .whiteFrowningFace, skinTones: nil)
-        } else if rawValue == "😮" {
-            self.init(baseEmoji: .openMouth, skinTones: nil)
-        } else if rawValue == "😯" {
-            self.init(baseEmoji: .hushed, skinTones: nil)
-        } else if rawValue == "😲" {
-            self.init(baseEmoji: .astonished, skinTones: nil)
-        } else if rawValue == "😳" {
-            self.init(baseEmoji: .flushed, skinTones: nil)
-        } else if rawValue == "🥺" {
-            self.init(baseEmoji: .pleadingFace, skinTones: nil)
-        } else if rawValue == "🥹" {
-            self.init(baseEmoji: .faceHoldingBackTears, skinTones: nil)
-        } else if rawValue == "😦" {
-            self.init(baseEmoji: .frowning, skinTones: nil)
-        } else if rawValue == "😧" {
-            self.init(baseEmoji: .anguished, skinTones: nil)
-        } else if rawValue == "😨" {
-            self.init(baseEmoji: .fearful, skinTones: nil)
-        } else if rawValue == "😰" {
-            self.init(baseEmoji: .coldSweat, skinTones: nil)
-        } else if rawValue == "😥" {
-            self.init(baseEmoji: .disappointedRelieved, skinTones: nil)
-        } else if rawValue == "😢" {
-            self.init(baseEmoji: .cry, skinTones: nil)
-        } else if rawValue == "😭" {
-            self.init(baseEmoji: .sob, skinTones: nil)
-        } else if rawValue == "😱" {
-            self.init(baseEmoji: .scream, skinTones: nil)
-        } else if rawValue == "😖" {
-            self.init(baseEmoji: .confounded, skinTones: nil)
-        } else if rawValue == "😣" {
-            self.init(baseEmoji: .persevere, skinTones: nil)
-        } else if rawValue == "😞" {
-            self.init(baseEmoji: .disappointed, skinTones: nil)
-        } else if rawValue == "😓" {
-            self.init(baseEmoji: .sweat, skinTones: nil)
-        } else if rawValue == "😩" {
-            self.init(baseEmoji: .weary, skinTones: nil)
-        } else if rawValue == "😫" {
-            self.init(baseEmoji: .tiredFace, skinTones: nil)
-        } else if rawValue == "🥱" {
-            self.init(baseEmoji: .yawningFace, skinTones: nil)
-        } else if rawValue == "😤" {
-            self.init(baseEmoji: .triumph, skinTones: nil)
-        } else if rawValue == "😡" {
-            self.init(baseEmoji: .rage, skinTones: nil)
-        } else if rawValue == "😠" {
-            self.init(baseEmoji: .angry, skinTones: nil)
-        } else if rawValue == "🤬" {
-            self.init(baseEmoji: .faceWithSymbolsOnMouth, skinTones: nil)
-        } else if rawValue == "😈" {
-            self.init(baseEmoji: .smilingImp, skinTones: nil)
-        } else if rawValue == "👿" {
-            self.init(baseEmoji: .imp, skinTones: nil)
-        } else if rawValue == "💀" {
-            self.init(baseEmoji: .skull, skinTones: nil)
-        } else if rawValue == "☠️" {
-            self.init(baseEmoji: .skullAndCrossbones, skinTones: nil)
-        } else if rawValue == "💩" {
-            self.init(baseEmoji: .hankey, skinTones: nil)
-        } else if rawValue == "🤡" {
-            self.init(baseEmoji: .clownFace, skinTones: nil)
-        } else if rawValue == "👹" {
-            self.init(baseEmoji: .japaneseOgre, skinTones: nil)
-        } else if rawValue == "👺" {
-            self.init(baseEmoji: .japaneseGoblin, skinTones: nil)
-        } else if rawValue == "👻" {
-            self.init(baseEmoji: .ghost, skinTones: nil)
-        } else if rawValue == "👽" {
-            self.init(baseEmoji: .alien, skinTones: nil)
-        } else if rawValue == "👾" {
-            self.init(baseEmoji: .spaceInvader, skinTones: nil)
-        } else if rawValue == "🤖" {
-            self.init(baseEmoji: .robotFace, skinTones: nil)
-        } else if rawValue == "😺" {
-            self.init(baseEmoji: .smileyCat, skinTones: nil)
-        } else if rawValue == "😸" {
-            self.init(baseEmoji: .smileCat, skinTones: nil)
-        } else if rawValue == "😹" {
-            self.init(baseEmoji: .joyCat, skinTones: nil)
-        } else if rawValue == "😻" {
-            self.init(baseEmoji: .heartEyesCat, skinTones: nil)
-        } else if rawValue == "😼" {
-            self.init(baseEmoji: .smirkCat, skinTones: nil)
-        } else if rawValue == "😽" {
-            self.init(baseEmoji: .kissingCat, skinTones: nil)
-        } else if rawValue == "🙀" {
-            self.init(baseEmoji: .screamCat, skinTones: nil)
-        } else if rawValue == "😿" {
-            self.init(baseEmoji: .cryingCatFace, skinTones: nil)
-        } else if rawValue == "😾" {
-            self.init(baseEmoji: .poutingCat, skinTones: nil)
-        } else if rawValue == "🙈" {
-            self.init(baseEmoji: .seeNoEvil, skinTones: nil)
-        } else if rawValue == "🙉" {
-            self.init(baseEmoji: .hearNoEvil, skinTones: nil)
-        } else if rawValue == "🙊" {
-            self.init(baseEmoji: .speakNoEvil, skinTones: nil)
-        } else if rawValue == "💋" {
-            self.init(baseEmoji: .kiss, skinTones: nil)
-        } else if rawValue == "💌" {
-            self.init(baseEmoji: .loveLetter, skinTones: nil)
-        } else if rawValue == "💘" {
-            self.init(baseEmoji: .cupid, skinTones: nil)
-        } else if rawValue == "💝" {
-            self.init(baseEmoji: .giftHeart, skinTones: nil)
-        } else if rawValue == "💖" {
-            self.init(baseEmoji: .sparklingHeart, skinTones: nil)
-        } else if rawValue == "💗" {
-            self.init(baseEmoji: .heartpulse, skinTones: nil)
-        } else if rawValue == "💓" {
-            self.init(baseEmoji: .heartbeat, skinTones: nil)
-        } else if rawValue == "💞" {
-            self.init(baseEmoji: .revolvingHearts, skinTones: nil)
-        } else if rawValue == "💕" {
-            self.init(baseEmoji: .twoHearts, skinTones: nil)
-        } else if rawValue == "💟" {
-            self.init(baseEmoji: .heartDecoration, skinTones: nil)
-        } else if rawValue == "❣️" {
-            self.init(baseEmoji: .heavyHeartExclamationMarkOrnament, skinTones: nil)
-        } else if rawValue == "💔" {
-            self.init(baseEmoji: .brokenHeart, skinTones: nil)
-        } else if rawValue == "❤️‍🔥" {
-            self.init(baseEmoji: .heartOnFire, skinTones: nil)
-        } else if rawValue == "❤️‍🩹" {
-            self.init(baseEmoji: .mendingHeart, skinTones: nil)
-        } else if rawValue == "❤️" {
-            self.init(baseEmoji: .heart, skinTones: nil)
-        } else if rawValue == "🧡" {
-            self.init(baseEmoji: .orangeHeart, skinTones: nil)
-        } else if rawValue == "💛" {
-            self.init(baseEmoji: .yellowHeart, skinTones: nil)
-        } else if rawValue == "💚" {
-            self.init(baseEmoji: .greenHeart, skinTones: nil)
-        } else if rawValue == "💙" {
-            self.init(baseEmoji: .blueHeart, skinTones: nil)
-        } else if rawValue == "💜" {
-            self.init(baseEmoji: .purpleHeart, skinTones: nil)
-        } else if rawValue == "🤎" {
-            self.init(baseEmoji: .brownHeart, skinTones: nil)
-        } else if rawValue == "🖤" {
-            self.init(baseEmoji: .blackHeart, skinTones: nil)
-        } else if rawValue == "🤍" {
-            self.init(baseEmoji: .whiteHeart, skinTones: nil)
-        } else if rawValue == "💯" {
-            self.init(baseEmoji: .oneHundred, skinTones: nil)
-        } else if rawValue == "💢" {
-            self.init(baseEmoji: .anger, skinTones: nil)
-        } else if rawValue == "💥" {
-            self.init(baseEmoji: .boom, skinTones: nil)
-        } else if rawValue == "💫" {
-            self.init(baseEmoji: .dizzy, skinTones: nil)
-        } else if rawValue == "💦" {
-            self.init(baseEmoji: .sweatDrops, skinTones: nil)
-        } else if rawValue == "💨" {
-            self.init(baseEmoji: .dash, skinTones: nil)
-        } else if rawValue == "🕳️" {
-            self.init(baseEmoji: .hole, skinTones: nil)
-        } else if rawValue == "💣" {
-            self.init(baseEmoji: .bomb, skinTones: nil)
-        } else if rawValue == "💬" {
-            self.init(baseEmoji: .speechBalloon, skinTones: nil)
-        } else if rawValue == "👁️‍🗨️" {
-            self.init(baseEmoji: .eyeInSpeechBubble, skinTones: nil)
-        } else if rawValue == "🗨️" {
-            self.init(baseEmoji: .leftSpeechBubble, skinTones: nil)
-        } else if rawValue == "🗯️" {
-            self.init(baseEmoji: .rightAngerBubble, skinTones: nil)
-        } else if rawValue == "💭" {
-            self.init(baseEmoji: .thoughtBalloon, skinTones: nil)
-        } else if rawValue == "💤" {
-            self.init(baseEmoji: .zzz, skinTones: nil)
-        } else if rawValue == "👋" {
-            self.init(baseEmoji: .wave, skinTones: nil)
-        } else if rawValue == "👋🏻" {
-            self.init(baseEmoji: .wave, skinTones: [.light])
-        } else if rawValue == "👋🏼" {
-            self.init(baseEmoji: .wave, skinTones: [.mediumLight])
-        } else if rawValue == "👋🏽" {
-            self.init(baseEmoji: .wave, skinTones: [.medium])
-        } else if rawValue == "👋🏾" {
-            self.init(baseEmoji: .wave, skinTones: [.mediumDark])
-        } else if rawValue == "👋🏿" {
-            self.init(baseEmoji: .wave, skinTones: [.dark])
-        } else if rawValue == "🤚" {
-            self.init(baseEmoji: .raisedBackOfHand, skinTones: nil)
-        } else if rawValue == "🤚🏻" {
-            self.init(baseEmoji: .raisedBackOfHand, skinTones: [.light])
-        } else if rawValue == "🤚🏼" {
-            self.init(baseEmoji: .raisedBackOfHand, skinTones: [.mediumLight])
-        } else if rawValue == "🤚🏽" {
-            self.init(baseEmoji: .raisedBackOfHand, skinTones: [.medium])
-        } else if rawValue == "🤚🏾" {
-            self.init(baseEmoji: .raisedBackOfHand, skinTones: [.mediumDark])
-        } else if rawValue == "🤚🏿" {
-            self.init(baseEmoji: .raisedBackOfHand, skinTones: [.dark])
-        } else if rawValue == "🖐️" {
-            self.init(baseEmoji: .raisedHandWithFingersSplayed, skinTones: nil)
-        } else if rawValue == "🖐🏻" {
-            self.init(baseEmoji: .raisedHandWithFingersSplayed, skinTones: [.light])
-        } else if rawValue == "🖐🏼" {
-            self.init(baseEmoji: .raisedHandWithFingersSplayed, skinTones: [.mediumLight])
-        } else if rawValue == "🖐🏽" {
-            self.init(baseEmoji: .raisedHandWithFingersSplayed, skinTones: [.medium])
-        } else if rawValue == "🖐🏾" {
-            self.init(baseEmoji: .raisedHandWithFingersSplayed, skinTones: [.mediumDark])
-        } else if rawValue == "🖐🏿" {
-            self.init(baseEmoji: .raisedHandWithFingersSplayed, skinTones: [.dark])
-        } else if rawValue == "✋" {
-            self.init(baseEmoji: .hand, skinTones: nil)
-        } else if rawValue == "✋🏻" {
-            self.init(baseEmoji: .hand, skinTones: [.light])
-        } else if rawValue == "✋🏼" {
-            self.init(baseEmoji: .hand, skinTones: [.mediumLight])
-        } else if rawValue == "✋🏽" {
-            self.init(baseEmoji: .hand, skinTones: [.medium])
-        } else if rawValue == "✋🏾" {
-            self.init(baseEmoji: .hand, skinTones: [.mediumDark])
-        } else if rawValue == "✋🏿" {
-            self.init(baseEmoji: .hand, skinTones: [.dark])
-        } else if rawValue == "🖖" {
-            self.init(baseEmoji: .spockHand, skinTones: nil)
-        } else if rawValue == "🖖🏻" {
-            self.init(baseEmoji: .spockHand, skinTones: [.light])
-        } else if rawValue == "🖖🏼" {
-            self.init(baseEmoji: .spockHand, skinTones: [.mediumLight])
-        } else if rawValue == "🖖🏽" {
-            self.init(baseEmoji: .spockHand, skinTones: [.medium])
-        } else if rawValue == "🖖🏾" {
-            self.init(baseEmoji: .spockHand, skinTones: [.mediumDark])
-        } else if rawValue == "🖖🏿" {
-            self.init(baseEmoji: .spockHand, skinTones: [.dark])
-        } else if rawValue == "🫱" {
-            self.init(baseEmoji: .rightwardsHand, skinTones: nil)
-        } else if rawValue == "🫱🏻" {
-            self.init(baseEmoji: .rightwardsHand, skinTones: [.light])
-        } else if rawValue == "🫱🏼" {
-            self.init(baseEmoji: .rightwardsHand, skinTones: [.mediumLight])
-        } else if rawValue == "🫱🏽" {
-            self.init(baseEmoji: .rightwardsHand, skinTones: [.medium])
-        } else if rawValue == "🫱🏾" {
-            self.init(baseEmoji: .rightwardsHand, skinTones: [.mediumDark])
-        } else if rawValue == "🫱🏿" {
-            self.init(baseEmoji: .rightwardsHand, skinTones: [.dark])
-        } else if rawValue == "🫲" {
-            self.init(baseEmoji: .leftwardsHand, skinTones: nil)
-        } else if rawValue == "🫲🏻" {
-            self.init(baseEmoji: .leftwardsHand, skinTones: [.light])
-        } else if rawValue == "🫲🏼" {
-            self.init(baseEmoji: .leftwardsHand, skinTones: [.mediumLight])
-        } else if rawValue == "🫲🏽" {
-            self.init(baseEmoji: .leftwardsHand, skinTones: [.medium])
-        } else if rawValue == "🫲🏾" {
-            self.init(baseEmoji: .leftwardsHand, skinTones: [.mediumDark])
-        } else if rawValue == "🫲🏿" {
-            self.init(baseEmoji: .leftwardsHand, skinTones: [.dark])
-        } else if rawValue == "🫳" {
-            self.init(baseEmoji: .palmDownHand, skinTones: nil)
-        } else if rawValue == "🫳🏻" {
-            self.init(baseEmoji: .palmDownHand, skinTones: [.light])
-        } else if rawValue == "🫳🏼" {
-            self.init(baseEmoji: .palmDownHand, skinTones: [.mediumLight])
-        } else if rawValue == "🫳🏽" {
-            self.init(baseEmoji: .palmDownHand, skinTones: [.medium])
-        } else if rawValue == "🫳🏾" {
-            self.init(baseEmoji: .palmDownHand, skinTones: [.mediumDark])
-        } else if rawValue == "🫳🏿" {
-            self.init(baseEmoji: .palmDownHand, skinTones: [.dark])
-        } else if rawValue == "🫴" {
-            self.init(baseEmoji: .palmUpHand, skinTones: nil)
-        } else if rawValue == "🫴🏻" {
-            self.init(baseEmoji: .palmUpHand, skinTones: [.light])
-        } else if rawValue == "🫴🏼" {
-            self.init(baseEmoji: .palmUpHand, skinTones: [.mediumLight])
-        } else if rawValue == "🫴🏽" {
-            self.init(baseEmoji: .palmUpHand, skinTones: [.medium])
-        } else if rawValue == "🫴🏾" {
-            self.init(baseEmoji: .palmUpHand, skinTones: [.mediumDark])
-        } else if rawValue == "🫴🏿" {
-            self.init(baseEmoji: .palmUpHand, skinTones: [.dark])
-        } else if rawValue == "👌" {
-            self.init(baseEmoji: .okHand, skinTones: nil)
-        } else if rawValue == "👌🏻" {
-            self.init(baseEmoji: .okHand, skinTones: [.light])
-        } else if rawValue == "👌🏼" {
-            self.init(baseEmoji: .okHand, skinTones: [.mediumLight])
-        } else if rawValue == "👌🏽" {
-            self.init(baseEmoji: .okHand, skinTones: [.medium])
-        } else if rawValue == "👌🏾" {
-            self.init(baseEmoji: .okHand, skinTones: [.mediumDark])
-        } else if rawValue == "👌🏿" {
-            self.init(baseEmoji: .okHand, skinTones: [.dark])
-        } else if rawValue == "🤌" {
-            self.init(baseEmoji: .pinchedFingers, skinTones: nil)
-        } else if rawValue == "🤌🏻" {
-            self.init(baseEmoji: .pinchedFingers, skinTones: [.light])
-        } else if rawValue == "🤌🏼" {
-            self.init(baseEmoji: .pinchedFingers, skinTones: [.mediumLight])
-        } else if rawValue == "🤌🏽" {
-            self.init(baseEmoji: .pinchedFingers, skinTones: [.medium])
-        } else if rawValue == "🤌🏾" {
-            self.init(baseEmoji: .pinchedFingers, skinTones: [.mediumDark])
-        } else if rawValue == "🤌🏿" {
-            self.init(baseEmoji: .pinchedFingers, skinTones: [.dark])
-        } else if rawValue == "🤏" {
-            self.init(baseEmoji: .pinchingHand, skinTones: nil)
-        } else if rawValue == "🤏🏻" {
-            self.init(baseEmoji: .pinchingHand, skinTones: [.light])
-        } else if rawValue == "🤏🏼" {
-            self.init(baseEmoji: .pinchingHand, skinTones: [.mediumLight])
-        } else if rawValue == "🤏🏽" {
-            self.init(baseEmoji: .pinchingHand, skinTones: [.medium])
-        } else if rawValue == "🤏🏾" {
-            self.init(baseEmoji: .pinchingHand, skinTones: [.mediumDark])
-        } else if rawValue == "🤏🏿" {
-            self.init(baseEmoji: .pinchingHand, skinTones: [.dark])
-        } else if rawValue == "✌️" {
-            self.init(baseEmoji: .v, skinTones: nil)
-        } else if rawValue == "✌🏻" {
-            self.init(baseEmoji: .v, skinTones: [.light])
-        } else if rawValue == "✌🏼" {
-            self.init(baseEmoji: .v, skinTones: [.mediumLight])
-        } else if rawValue == "✌🏽" {
-            self.init(baseEmoji: .v, skinTones: [.medium])
-        } else if rawValue == "✌🏾" {
-            self.init(baseEmoji: .v, skinTones: [.mediumDark])
-        } else if rawValue == "✌🏿" {
-            self.init(baseEmoji: .v, skinTones: [.dark])
-        } else if rawValue == "🤞" {
-            self.init(baseEmoji: .crossedFingers, skinTones: nil)
-        } else if rawValue == "🤞🏻" {
-            self.init(baseEmoji: .crossedFingers, skinTones: [.light])
-        } else if rawValue == "🤞🏼" {
-            self.init(baseEmoji: .crossedFingers, skinTones: [.mediumLight])
-        } else if rawValue == "🤞🏽" {
-            self.init(baseEmoji: .crossedFingers, skinTones: [.medium])
-        } else if rawValue == "🤞🏾" {
-            self.init(baseEmoji: .crossedFingers, skinTones: [.mediumDark])
-        } else if rawValue == "🤞🏿" {
-            self.init(baseEmoji: .crossedFingers, skinTones: [.dark])
-        } else if rawValue == "🫰" {
-            self.init(baseEmoji: .handWithIndexFingerAndThumbCrossed, skinTones: nil)
-        } else if rawValue == "🫰🏻" {
-            self.init(baseEmoji: .handWithIndexFingerAndThumbCrossed, skinTones: [.light])
-        } else if rawValue == "🫰🏼" {
-            self.init(baseEmoji: .handWithIndexFingerAndThumbCrossed, skinTones: [.mediumLight])
-        } else if rawValue == "🫰🏽" {
-            self.init(baseEmoji: .handWithIndexFingerAndThumbCrossed, skinTones: [.medium])
-        } else if rawValue == "🫰🏾" {
-            self.init(baseEmoji: .handWithIndexFingerAndThumbCrossed, skinTones: [.mediumDark])
-        } else if rawValue == "🫰🏿" {
-            self.init(baseEmoji: .handWithIndexFingerAndThumbCrossed, skinTones: [.dark])
-        } else if rawValue == "🤟" {
-            self.init(baseEmoji: .iLoveYouHandSign, skinTones: nil)
-        } else if rawValue == "🤟🏻" {
-            self.init(baseEmoji: .iLoveYouHandSign, skinTones: [.light])
-        } else if rawValue == "🤟🏼" {
-            self.init(baseEmoji: .iLoveYouHandSign, skinTones: [.mediumLight])
-        } else if rawValue == "🤟🏽" {
-            self.init(baseEmoji: .iLoveYouHandSign, skinTones: [.medium])
-        } else if rawValue == "🤟🏾" {
-            self.init(baseEmoji: .iLoveYouHandSign, skinTones: [.mediumDark])
-        } else if rawValue == "🤟🏿" {
-            self.init(baseEmoji: .iLoveYouHandSign, skinTones: [.dark])
-        } else if rawValue == "🤘" {
-            self.init(baseEmoji: .theHorns, skinTones: nil)
-        } else if rawValue == "🤘🏻" {
-            self.init(baseEmoji: .theHorns, skinTones: [.light])
-        } else if rawValue == "🤘🏼" {
-            self.init(baseEmoji: .theHorns, skinTones: [.mediumLight])
-        } else if rawValue == "🤘🏽" {
-            self.init(baseEmoji: .theHorns, skinTones: [.medium])
-        } else if rawValue == "🤘🏾" {
-            self.init(baseEmoji: .theHorns, skinTones: [.mediumDark])
-        } else if rawValue == "🤘🏿" {
-            self.init(baseEmoji: .theHorns, skinTones: [.dark])
-        } else if rawValue == "🤙" {
-            self.init(baseEmoji: .callMeHand, skinTones: nil)
-        } else if rawValue == "🤙🏻" {
-            self.init(baseEmoji: .callMeHand, skinTones: [.light])
-        } else if rawValue == "🤙🏼" {
-            self.init(baseEmoji: .callMeHand, skinTones: [.mediumLight])
-        } else if rawValue == "🤙🏽" {
-            self.init(baseEmoji: .callMeHand, skinTones: [.medium])
-        } else if rawValue == "🤙🏾" {
-            self.init(baseEmoji: .callMeHand, skinTones: [.mediumDark])
-        } else if rawValue == "🤙🏿" {
-            self.init(baseEmoji: .callMeHand, skinTones: [.dark])
-        } else if rawValue == "👈" {
-            self.init(baseEmoji: .pointLeft, skinTones: nil)
-        } else if rawValue == "👈🏻" {
-            self.init(baseEmoji: .pointLeft, skinTones: [.light])
-        } else if rawValue == "👈🏼" {
-            self.init(baseEmoji: .pointLeft, skinTones: [.mediumLight])
-        } else if rawValue == "👈🏽" {
-            self.init(baseEmoji: .pointLeft, skinTones: [.medium])
-        } else if rawValue == "👈🏾" {
-            self.init(baseEmoji: .pointLeft, skinTones: [.mediumDark])
-        } else if rawValue == "👈🏿" {
-            self.init(baseEmoji: .pointLeft, skinTones: [.dark])
-        } else if rawValue == "👉" {
-            self.init(baseEmoji: .pointRight, skinTones: nil)
-        } else if rawValue == "👉🏻" {
-            self.init(baseEmoji: .pointRight, skinTones: [.light])
-        } else if rawValue == "👉🏼" {
-            self.init(baseEmoji: .pointRight, skinTones: [.mediumLight])
-        } else if rawValue == "👉🏽" {
-            self.init(baseEmoji: .pointRight, skinTones: [.medium])
-        } else if rawValue == "👉🏾" {
-            self.init(baseEmoji: .pointRight, skinTones: [.mediumDark])
-        } else if rawValue == "👉🏿" {
-            self.init(baseEmoji: .pointRight, skinTones: [.dark])
-        } else if rawValue == "👆" {
-            self.init(baseEmoji: .pointUp2, skinTones: nil)
-        } else if rawValue == "👆🏻" {
-            self.init(baseEmoji: .pointUp2, skinTones: [.light])
-        } else if rawValue == "👆🏼" {
-            self.init(baseEmoji: .pointUp2, skinTones: [.mediumLight])
-        } else if rawValue == "👆🏽" {
-            self.init(baseEmoji: .pointUp2, skinTones: [.medium])
-        } else if rawValue == "👆🏾" {
-            self.init(baseEmoji: .pointUp2, skinTones: [.mediumDark])
-        } else if rawValue == "👆🏿" {
-            self.init(baseEmoji: .pointUp2, skinTones: [.dark])
-        } else if rawValue == "🖕" {
-            self.init(baseEmoji: .middleFinger, skinTones: nil)
-        } else if rawValue == "🖕🏻" {
-            self.init(baseEmoji: .middleFinger, skinTones: [.light])
-        } else if rawValue == "🖕🏼" {
-            self.init(baseEmoji: .middleFinger, skinTones: [.mediumLight])
-        } else if rawValue == "🖕🏽" {
-            self.init(baseEmoji: .middleFinger, skinTones: [.medium])
-        } else if rawValue == "🖕🏾" {
-            self.init(baseEmoji: .middleFinger, skinTones: [.mediumDark])
-        } else if rawValue == "🖕🏿" {
-            self.init(baseEmoji: .middleFinger, skinTones: [.dark])
-        } else if rawValue == "👇" {
-            self.init(baseEmoji: .pointDown, skinTones: nil)
-        } else if rawValue == "👇🏻" {
-            self.init(baseEmoji: .pointDown, skinTones: [.light])
-        } else if rawValue == "👇🏼" {
-            self.init(baseEmoji: .pointDown, skinTones: [.mediumLight])
-        } else if rawValue == "👇🏽" {
-            self.init(baseEmoji: .pointDown, skinTones: [.medium])
-        } else if rawValue == "👇🏾" {
-            self.init(baseEmoji: .pointDown, skinTones: [.mediumDark])
-        } else if rawValue == "👇🏿" {
-            self.init(baseEmoji: .pointDown, skinTones: [.dark])
-        } else if rawValue == "☝️" {
-            self.init(baseEmoji: .pointUp, skinTones: nil)
-        } else if rawValue == "☝🏻" {
-            self.init(baseEmoji: .pointUp, skinTones: [.light])
-        } else if rawValue == "☝🏼" {
-            self.init(baseEmoji: .pointUp, skinTones: [.mediumLight])
-        } else if rawValue == "☝🏽" {
-            self.init(baseEmoji: .pointUp, skinTones: [.medium])
-        } else if rawValue == "☝🏾" {
-            self.init(baseEmoji: .pointUp, skinTones: [.mediumDark])
-        } else if rawValue == "☝🏿" {
-            self.init(baseEmoji: .pointUp, skinTones: [.dark])
-        } else if rawValue == "🫵" {
-            self.init(baseEmoji: .indexPointingAtTheViewer, skinTones: nil)
-        } else if rawValue == "🫵🏻" {
-            self.init(baseEmoji: .indexPointingAtTheViewer, skinTones: [.light])
-        } else if rawValue == "🫵🏼" {
-            self.init(baseEmoji: .indexPointingAtTheViewer, skinTones: [.mediumLight])
-        } else if rawValue == "🫵🏽" {
-            self.init(baseEmoji: .indexPointingAtTheViewer, skinTones: [.medium])
-        } else if rawValue == "🫵🏾" {
-            self.init(baseEmoji: .indexPointingAtTheViewer, skinTones: [.mediumDark])
-        } else if rawValue == "🫵🏿" {
-            self.init(baseEmoji: .indexPointingAtTheViewer, skinTones: [.dark])
-        } else if rawValue == "👍" {
-            self.init(baseEmoji: .plusOne, skinTones: nil)
-        } else if rawValue == "👍🏻" {
-            self.init(baseEmoji: .plusOne, skinTones: [.light])
-        } else if rawValue == "👍🏼" {
-            self.init(baseEmoji: .plusOne, skinTones: [.mediumLight])
-        } else if rawValue == "👍🏽" {
-            self.init(baseEmoji: .plusOne, skinTones: [.medium])
-        } else if rawValue == "👍🏾" {
-            self.init(baseEmoji: .plusOne, skinTones: [.mediumDark])
-        } else if rawValue == "👍🏿" {
-            self.init(baseEmoji: .plusOne, skinTones: [.dark])
-        } else if rawValue == "👎" {
-            self.init(baseEmoji: .negativeOne, skinTones: nil)
-        } else if rawValue == "👎🏻" {
-            self.init(baseEmoji: .negativeOne, skinTones: [.light])
-        } else if rawValue == "👎🏼" {
-            self.init(baseEmoji: .negativeOne, skinTones: [.mediumLight])
-        } else if rawValue == "👎🏽" {
-            self.init(baseEmoji: .negativeOne, skinTones: [.medium])
-        } else if rawValue == "👎🏾" {
-            self.init(baseEmoji: .negativeOne, skinTones: [.mediumDark])
-        } else if rawValue == "👎🏿" {
-            self.init(baseEmoji: .negativeOne, skinTones: [.dark])
-        } else if rawValue == "✊" {
-            self.init(baseEmoji: .fist, skinTones: nil)
-        } else if rawValue == "✊🏻" {
-            self.init(baseEmoji: .fist, skinTones: [.light])
-        } else if rawValue == "✊🏼" {
-            self.init(baseEmoji: .fist, skinTones: [.mediumLight])
-        } else if rawValue == "✊🏽" {
-            self.init(baseEmoji: .fist, skinTones: [.medium])
-        } else if rawValue == "✊🏾" {
-            self.init(baseEmoji: .fist, skinTones: [.mediumDark])
-        } else if rawValue == "✊🏿" {
-            self.init(baseEmoji: .fist, skinTones: [.dark])
-        } else if rawValue == "👊" {
-            self.init(baseEmoji: .facepunch, skinTones: nil)
-        } else if rawValue == "👊🏻" {
-            self.init(baseEmoji: .facepunch, skinTones: [.light])
-        } else if rawValue == "👊🏼" {
-            self.init(baseEmoji: .facepunch, skinTones: [.mediumLight])
-        } else if rawValue == "👊🏽" {
-            self.init(baseEmoji: .facepunch, skinTones: [.medium])
-        } else if rawValue == "👊🏾" {
-            self.init(baseEmoji: .facepunch, skinTones: [.mediumDark])
-        } else if rawValue == "👊🏿" {
-            self.init(baseEmoji: .facepunch, skinTones: [.dark])
-        } else if rawValue == "🤛" {
-            self.init(baseEmoji: .leftFacingFist, skinTones: nil)
-        } else if rawValue == "🤛🏻" {
-            self.init(baseEmoji: .leftFacingFist, skinTones: [.light])
-        } else if rawValue == "🤛🏼" {
-            self.init(baseEmoji: .leftFacingFist, skinTones: [.mediumLight])
-        } else if rawValue == "🤛🏽" {
-            self.init(baseEmoji: .leftFacingFist, skinTones: [.medium])
-        } else if rawValue == "🤛🏾" {
-            self.init(baseEmoji: .leftFacingFist, skinTones: [.mediumDark])
-        } else if rawValue == "🤛🏿" {
-            self.init(baseEmoji: .leftFacingFist, skinTones: [.dark])
-        } else if rawValue == "🤜" {
-            self.init(baseEmoji: .rightFacingFist, skinTones: nil)
-        } else if rawValue == "🤜🏻" {
-            self.init(baseEmoji: .rightFacingFist, skinTones: [.light])
-        } else if rawValue == "🤜🏼" {
-            self.init(baseEmoji: .rightFacingFist, skinTones: [.mediumLight])
-        } else if rawValue == "🤜🏽" {
-            self.init(baseEmoji: .rightFacingFist, skinTones: [.medium])
-        } else if rawValue == "🤜🏾" {
-            self.init(baseEmoji: .rightFacingFist, skinTones: [.mediumDark])
-        } else if rawValue == "🤜🏿" {
-            self.init(baseEmoji: .rightFacingFist, skinTones: [.dark])
-        } else if rawValue == "👏" {
-            self.init(baseEmoji: .clap, skinTones: nil)
-        } else if rawValue == "👏🏻" {
-            self.init(baseEmoji: .clap, skinTones: [.light])
-        } else if rawValue == "👏🏼" {
-            self.init(baseEmoji: .clap, skinTones: [.mediumLight])
-        } else if rawValue == "👏🏽" {
-            self.init(baseEmoji: .clap, skinTones: [.medium])
-        } else if rawValue == "👏🏾" {
-            self.init(baseEmoji: .clap, skinTones: [.mediumDark])
-        } else if rawValue == "👏🏿" {
-            self.init(baseEmoji: .clap, skinTones: [.dark])
-        } else if rawValue == "🙌" {
-            self.init(baseEmoji: .raisedHands, skinTones: nil)
-        } else if rawValue == "🙌🏻" {
-            self.init(baseEmoji: .raisedHands, skinTones: [.light])
-        } else if rawValue == "🙌🏼" {
-            self.init(baseEmoji: .raisedHands, skinTones: [.mediumLight])
-        } else if rawValue == "🙌🏽" {
-            self.init(baseEmoji: .raisedHands, skinTones: [.medium])
-        } else if rawValue == "🙌🏾" {
-            self.init(baseEmoji: .raisedHands, skinTones: [.mediumDark])
-        } else if rawValue == "🙌🏿" {
-            self.init(baseEmoji: .raisedHands, skinTones: [.dark])
-        } else if rawValue == "🫶" {
-            self.init(baseEmoji: .heartHands, skinTones: nil)
-        } else if rawValue == "🫶🏻" {
-            self.init(baseEmoji: .heartHands, skinTones: [.light])
-        } else if rawValue == "🫶🏼" {
-            self.init(baseEmoji: .heartHands, skinTones: [.mediumLight])
-        } else if rawValue == "🫶🏽" {
-            self.init(baseEmoji: .heartHands, skinTones: [.medium])
-        } else if rawValue == "🫶🏾" {
-            self.init(baseEmoji: .heartHands, skinTones: [.mediumDark])
-        } else if rawValue == "🫶🏿" {
-            self.init(baseEmoji: .heartHands, skinTones: [.dark])
-        } else if rawValue == "👐" {
-            self.init(baseEmoji: .openHands, skinTones: nil)
-        } else if rawValue == "👐🏻" {
-            self.init(baseEmoji: .openHands, skinTones: [.light])
-        } else if rawValue == "👐🏼" {
-            self.init(baseEmoji: .openHands, skinTones: [.mediumLight])
-        } else if rawValue == "👐🏽" {
-            self.init(baseEmoji: .openHands, skinTones: [.medium])
-        } else if rawValue == "👐🏾" {
-            self.init(baseEmoji: .openHands, skinTones: [.mediumDark])
-        } else if rawValue == "👐🏿" {
-            self.init(baseEmoji: .openHands, skinTones: [.dark])
-        } else if rawValue == "🤲" {
-            self.init(baseEmoji: .palmsUpTogether, skinTones: nil)
-        } else if rawValue == "🤲🏻" {
-            self.init(baseEmoji: .palmsUpTogether, skinTones: [.light])
-        } else if rawValue == "🤲🏼" {
-            self.init(baseEmoji: .palmsUpTogether, skinTones: [.mediumLight])
-        } else if rawValue == "🤲🏽" {
-            self.init(baseEmoji: .palmsUpTogether, skinTones: [.medium])
-        } else if rawValue == "🤲🏾" {
-            self.init(baseEmoji: .palmsUpTogether, skinTones: [.mediumDark])
-        } else if rawValue == "🤲🏿" {
-            self.init(baseEmoji: .palmsUpTogether, skinTones: [.dark])
-        } else if rawValue == "🤝" {
-            self.init(baseEmoji: .handshake, skinTones: nil)
-        } else if rawValue == "🤝🏻" {
-            self.init(baseEmoji: .handshake, skinTones: [.light])
-        } else if rawValue == "🫱🏻‍🫲🏼" {
-            self.init(baseEmoji: .handshake, skinTones: [.light, .mediumLight])
-        } else if rawValue == "🫱🏻‍🫲🏽" {
-            self.init(baseEmoji: .handshake, skinTones: [.light, .medium])
-        } else if rawValue == "🫱🏻‍🫲🏾" {
-            self.init(baseEmoji: .handshake, skinTones: [.light, .mediumDark])
-        } else if rawValue == "🫱🏻‍🫲🏿" {
-            self.init(baseEmoji: .handshake, skinTones: [.light, .dark])
-        } else if rawValue == "🤝🏼" {
-            self.init(baseEmoji: .handshake, skinTones: [.mediumLight])
-        } else if rawValue == "🫱🏼‍🫲🏻" {
-            self.init(baseEmoji: .handshake, skinTones: [.mediumLight, .light])
-        } else if rawValue == "🫱🏼‍🫲🏽" {
-            self.init(baseEmoji: .handshake, skinTones: [.mediumLight, .medium])
-        } else if rawValue == "🫱🏼‍🫲🏾" {
-            self.init(baseEmoji: .handshake, skinTones: [.mediumLight, .mediumDark])
-        } else if rawValue == "🫱🏼‍🫲🏿" {
-            self.init(baseEmoji: .handshake, skinTones: [.mediumLight, .dark])
-        } else if rawValue == "🤝🏽" {
-            self.init(baseEmoji: .handshake, skinTones: [.medium])
-        } else if rawValue == "🫱🏽‍🫲🏻" {
-            self.init(baseEmoji: .handshake, skinTones: [.medium, .light])
-        } else if rawValue == "🫱🏽‍🫲🏼" {
-            self.init(baseEmoji: .handshake, skinTones: [.medium, .mediumLight])
-        } else if rawValue == "🫱🏽‍🫲🏾" {
-            self.init(baseEmoji: .handshake, skinTones: [.medium, .mediumDark])
-        } else if rawValue == "🫱🏽‍🫲🏿" {
-            self.init(baseEmoji: .handshake, skinTones: [.medium, .dark])
-        } else if rawValue == "🤝🏾" {
-            self.init(baseEmoji: .handshake, skinTones: [.mediumDark])
-        } else if rawValue == "🫱🏾‍🫲🏻" {
-            self.init(baseEmoji: .handshake, skinTones: [.mediumDark, .light])
-        } else if rawValue == "🫱🏾‍🫲🏼" {
-            self.init(baseEmoji: .handshake, skinTones: [.mediumDark, .mediumLight])
-        } else if rawValue == "🫱🏾‍🫲🏽" {
-            self.init(baseEmoji: .handshake, skinTones: [.mediumDark, .medium])
-        } else if rawValue == "🫱🏾‍🫲🏿" {
-            self.init(baseEmoji: .handshake, skinTones: [.mediumDark, .dark])
-        } else if rawValue == "🤝🏿" {
-            self.init(baseEmoji: .handshake, skinTones: [.dark])
-        } else if rawValue == "🫱🏿‍🫲🏻" {
-            self.init(baseEmoji: .handshake, skinTones: [.dark, .light])
-        } else if rawValue == "🫱🏿‍🫲🏼" {
-            self.init(baseEmoji: .handshake, skinTones: [.dark, .mediumLight])
-        } else if rawValue == "🫱🏿‍🫲🏽" {
-            self.init(baseEmoji: .handshake, skinTones: [.dark, .medium])
-        } else if rawValue == "🫱🏿‍🫲🏾" {
-            self.init(baseEmoji: .handshake, skinTones: [.dark, .mediumDark])
-        } else if rawValue == "🙏" {
-            self.init(baseEmoji: .pray, skinTones: nil)
-        } else if rawValue == "🙏🏻" {
-            self.init(baseEmoji: .pray, skinTones: [.light])
-        } else if rawValue == "🙏🏼" {
-            self.init(baseEmoji: .pray, skinTones: [.mediumLight])
-        } else if rawValue == "🙏🏽" {
-            self.init(baseEmoji: .pray, skinTones: [.medium])
-        } else if rawValue == "🙏🏾" {
-            self.init(baseEmoji: .pray, skinTones: [.mediumDark])
-        } else if rawValue == "🙏🏿" {
-            self.init(baseEmoji: .pray, skinTones: [.dark])
-        } else if rawValue == "✍️" {
-            self.init(baseEmoji: .writingHand, skinTones: nil)
-        } else if rawValue == "✍🏻" {
-            self.init(baseEmoji: .writingHand, skinTones: [.light])
-        } else if rawValue == "✍🏼" {
-            self.init(baseEmoji: .writingHand, skinTones: [.mediumLight])
-        } else if rawValue == "✍🏽" {
-            self.init(baseEmoji: .writingHand, skinTones: [.medium])
-        } else if rawValue == "✍🏾" {
-            self.init(baseEmoji: .writingHand, skinTones: [.mediumDark])
-        } else if rawValue == "✍🏿" {
-            self.init(baseEmoji: .writingHand, skinTones: [.dark])
-        } else if rawValue == "💅" {
-            self.init(baseEmoji: .nailCare, skinTones: nil)
-        } else if rawValue == "💅🏻" {
-            self.init(baseEmoji: .nailCare, skinTones: [.light])
-        } else if rawValue == "💅🏼" {
-            self.init(baseEmoji: .nailCare, skinTones: [.mediumLight])
-        } else if rawValue == "💅🏽" {
-            self.init(baseEmoji: .nailCare, skinTones: [.medium])
-        } else if rawValue == "💅🏾" {
-            self.init(baseEmoji: .nailCare, skinTones: [.mediumDark])
-        } else if rawValue == "💅🏿" {
-            self.init(baseEmoji: .nailCare, skinTones: [.dark])
-        } else if rawValue == "🤳" {
-            self.init(baseEmoji: .selfie, skinTones: nil)
-        } else if rawValue == "🤳🏻" {
-            self.init(baseEmoji: .selfie, skinTones: [.light])
-        } else if rawValue == "🤳🏼" {
-            self.init(baseEmoji: .selfie, skinTones: [.mediumLight])
-        } else if rawValue == "🤳🏽" {
-            self.init(baseEmoji: .selfie, skinTones: [.medium])
-        } else if rawValue == "🤳🏾" {
-            self.init(baseEmoji: .selfie, skinTones: [.mediumDark])
-        } else if rawValue == "🤳🏿" {
-            self.init(baseEmoji: .selfie, skinTones: [.dark])
-        } else if rawValue == "💪" {
-            self.init(baseEmoji: .muscle, skinTones: nil)
-        } else if rawValue == "💪🏻" {
-            self.init(baseEmoji: .muscle, skinTones: [.light])
-        } else if rawValue == "💪🏼" {
-            self.init(baseEmoji: .muscle, skinTones: [.mediumLight])
-        } else if rawValue == "💪🏽" {
-            self.init(baseEmoji: .muscle, skinTones: [.medium])
-        } else if rawValue == "💪🏾" {
-            self.init(baseEmoji: .muscle, skinTones: [.mediumDark])
-        } else if rawValue == "💪🏿" {
-            self.init(baseEmoji: .muscle, skinTones: [.dark])
-        } else if rawValue == "🦾" {
-            self.init(baseEmoji: .mechanicalArm, skinTones: nil)
-        } else if rawValue == "🦿" {
-            self.init(baseEmoji: .mechanicalLeg, skinTones: nil)
-        } else if rawValue == "🦵" {
-            self.init(baseEmoji: .leg, skinTones: nil)
-        } else if rawValue == "🦵🏻" {
-            self.init(baseEmoji: .leg, skinTones: [.light])
-        } else if rawValue == "🦵🏼" {
-            self.init(baseEmoji: .leg, skinTones: [.mediumLight])
-        } else if rawValue == "🦵🏽" {
-            self.init(baseEmoji: .leg, skinTones: [.medium])
-        } else if rawValue == "🦵🏾" {
-            self.init(baseEmoji: .leg, skinTones: [.mediumDark])
-        } else if rawValue == "🦵🏿" {
-            self.init(baseEmoji: .leg, skinTones: [.dark])
-        } else if rawValue == "🦶" {
-            self.init(baseEmoji: .foot, skinTones: nil)
-        } else if rawValue == "🦶🏻" {
-            self.init(baseEmoji: .foot, skinTones: [.light])
-        } else if rawValue == "🦶🏼" {
-            self.init(baseEmoji: .foot, skinTones: [.mediumLight])
-        } else if rawValue == "🦶🏽" {
-            self.init(baseEmoji: .foot, skinTones: [.medium])
-        } else if rawValue == "🦶🏾" {
-            self.init(baseEmoji: .foot, skinTones: [.mediumDark])
-        } else if rawValue == "🦶🏿" {
-            self.init(baseEmoji: .foot, skinTones: [.dark])
-        } else if rawValue == "👂" {
-            self.init(baseEmoji: .ear, skinTones: nil)
-        } else if rawValue == "👂🏻" {
-            self.init(baseEmoji: .ear, skinTones: [.light])
-        } else if rawValue == "👂🏼" {
-            self.init(baseEmoji: .ear, skinTones: [.mediumLight])
-        } else if rawValue == "👂🏽" {
-            self.init(baseEmoji: .ear, skinTones: [.medium])
-        } else if rawValue == "👂🏾" {
-            self.init(baseEmoji: .ear, skinTones: [.mediumDark])
-        } else if rawValue == "👂🏿" {
-            self.init(baseEmoji: .ear, skinTones: [.dark])
-        } else if rawValue == "🦻" {
-            self.init(baseEmoji: .earWithHearingAid, skinTones: nil)
-        } else if rawValue == "🦻🏻" {
-            self.init(baseEmoji: .earWithHearingAid, skinTones: [.light])
-        } else if rawValue == "🦻🏼" {
-            self.init(baseEmoji: .earWithHearingAid, skinTones: [.mediumLight])
-        } else if rawValue == "🦻🏽" {
-            self.init(baseEmoji: .earWithHearingAid, skinTones: [.medium])
-        } else if rawValue == "🦻🏾" {
-            self.init(baseEmoji: .earWithHearingAid, skinTones: [.mediumDark])
-        } else if rawValue == "🦻🏿" {
-            self.init(baseEmoji: .earWithHearingAid, skinTones: [.dark])
-        } else if rawValue == "👃" {
-            self.init(baseEmoji: .nose, skinTones: nil)
-        } else if rawValue == "👃🏻" {
-            self.init(baseEmoji: .nose, skinTones: [.light])
-        } else if rawValue == "👃🏼" {
-            self.init(baseEmoji: .nose, skinTones: [.mediumLight])
-        } else if rawValue == "👃🏽" {
-            self.init(baseEmoji: .nose, skinTones: [.medium])
-        } else if rawValue == "👃🏾" {
-            self.init(baseEmoji: .nose, skinTones: [.mediumDark])
-        } else if rawValue == "👃🏿" {
-            self.init(baseEmoji: .nose, skinTones: [.dark])
-        } else if rawValue == "🧠" {
-            self.init(baseEmoji: .brain, skinTones: nil)
-        } else if rawValue == "🫀" {
-            self.init(baseEmoji: .anatomicalHeart, skinTones: nil)
-        } else if rawValue == "🫁" {
-            self.init(baseEmoji: .lungs, skinTones: nil)
-        } else if rawValue == "🦷" {
-            self.init(baseEmoji: .tooth, skinTones: nil)
-        } else if rawValue == "🦴" {
-            self.init(baseEmoji: .bone, skinTones: nil)
-        } else if rawValue == "👀" {
-            self.init(baseEmoji: .eyes, skinTones: nil)
-        } else if rawValue == "👁️" {
-            self.init(baseEmoji: .eye, skinTones: nil)
-        } else if rawValue == "👅" {
-            self.init(baseEmoji: .tongue, skinTones: nil)
-        } else if rawValue == "👄" {
-            self.init(baseEmoji: .lips, skinTones: nil)
-        } else if rawValue == "🫦" {
-            self.init(baseEmoji: .bitingLip, skinTones: nil)
-        } else if rawValue == "👶" {
-            self.init(baseEmoji: .baby, skinTones: nil)
-        } else if rawValue == "👶🏻" {
-            self.init(baseEmoji: .baby, skinTones: [.light])
-        } else if rawValue == "👶🏼" {
-            self.init(baseEmoji: .baby, skinTones: [.mediumLight])
-        } else if rawValue == "👶🏽" {
-            self.init(baseEmoji: .baby, skinTones: [.medium])
-        } else if rawValue == "👶🏾" {
-            self.init(baseEmoji: .baby, skinTones: [.mediumDark])
-        } else if rawValue == "👶🏿" {
-            self.init(baseEmoji: .baby, skinTones: [.dark])
-        } else if rawValue == "🧒" {
-            self.init(baseEmoji: .child, skinTones: nil)
-        } else if rawValue == "🧒🏻" {
-            self.init(baseEmoji: .child, skinTones: [.light])
-        } else if rawValue == "🧒🏼" {
-            self.init(baseEmoji: .child, skinTones: [.mediumLight])
-        } else if rawValue == "🧒🏽" {
-            self.init(baseEmoji: .child, skinTones: [.medium])
-        } else if rawValue == "🧒🏾" {
-            self.init(baseEmoji: .child, skinTones: [.mediumDark])
-        } else if rawValue == "🧒🏿" {
-            self.init(baseEmoji: .child, skinTones: [.dark])
-        } else if rawValue == "👦" {
-            self.init(baseEmoji: .boy, skinTones: nil)
-        } else if rawValue == "👦🏻" {
-            self.init(baseEmoji: .boy, skinTones: [.light])
-        } else if rawValue == "👦🏼" {
-            self.init(baseEmoji: .boy, skinTones: [.mediumLight])
-        } else if rawValue == "👦🏽" {
-            self.init(baseEmoji: .boy, skinTones: [.medium])
-        } else if rawValue == "👦🏾" {
-            self.init(baseEmoji: .boy, skinTones: [.mediumDark])
-        } else if rawValue == "👦🏿" {
-            self.init(baseEmoji: .boy, skinTones: [.dark])
-        } else if rawValue == "👧" {
-            self.init(baseEmoji: .girl, skinTones: nil)
-        } else if rawValue == "👧🏻" {
-            self.init(baseEmoji: .girl, skinTones: [.light])
-        } else if rawValue == "👧🏼" {
-            self.init(baseEmoji: .girl, skinTones: [.mediumLight])
-        } else if rawValue == "👧🏽" {
-            self.init(baseEmoji: .girl, skinTones: [.medium])
-        } else if rawValue == "👧🏾" {
-            self.init(baseEmoji: .girl, skinTones: [.mediumDark])
-        } else if rawValue == "👧🏿" {
-            self.init(baseEmoji: .girl, skinTones: [.dark])
-        } else if rawValue == "🧑" {
-            self.init(baseEmoji: .adult, skinTones: nil)
-        } else if rawValue == "🧑🏻" {
-            self.init(baseEmoji: .adult, skinTones: [.light])
-        } else if rawValue == "🧑🏼" {
-            self.init(baseEmoji: .adult, skinTones: [.mediumLight])
-        } else if rawValue == "🧑🏽" {
-            self.init(baseEmoji: .adult, skinTones: [.medium])
-        } else if rawValue == "🧑🏾" {
-            self.init(baseEmoji: .adult, skinTones: [.mediumDark])
-        } else if rawValue == "🧑🏿" {
-            self.init(baseEmoji: .adult, skinTones: [.dark])
-        } else if rawValue == "👱" {
-            self.init(baseEmoji: .personWithBlondHair, skinTones: nil)
-        } else if rawValue == "👱🏻" {
-            self.init(baseEmoji: .personWithBlondHair, skinTones: [.light])
-        } else if rawValue == "👱🏼" {
-            self.init(baseEmoji: .personWithBlondHair, skinTones: [.mediumLight])
-        } else if rawValue == "👱🏽" {
-            self.init(baseEmoji: .personWithBlondHair, skinTones: [.medium])
-        } else if rawValue == "👱🏾" {
-            self.init(baseEmoji: .personWithBlondHair, skinTones: [.mediumDark])
-        } else if rawValue == "👱🏿" {
-            self.init(baseEmoji: .personWithBlondHair, skinTones: [.dark])
-        } else if rawValue == "👨" {
-            self.init(baseEmoji: .man, skinTones: nil)
-        } else if rawValue == "👨🏻" {
-            self.init(baseEmoji: .man, skinTones: [.light])
-        } else if rawValue == "👨🏼" {
-            self.init(baseEmoji: .man, skinTones: [.mediumLight])
-        } else if rawValue == "👨🏽" {
-            self.init(baseEmoji: .man, skinTones: [.medium])
-        } else if rawValue == "👨🏾" {
-            self.init(baseEmoji: .man, skinTones: [.mediumDark])
-        } else if rawValue == "👨🏿" {
-            self.init(baseEmoji: .man, skinTones: [.dark])
-        } else if rawValue == "🧔" {
-            self.init(baseEmoji: .beardedPerson, skinTones: nil)
-        } else if rawValue == "🧔🏻" {
-            self.init(baseEmoji: .beardedPerson, skinTones: [.light])
-        } else if rawValue == "🧔🏼" {
-            self.init(baseEmoji: .beardedPerson, skinTones: [.mediumLight])
-        } else if rawValue == "🧔🏽" {
-            self.init(baseEmoji: .beardedPerson, skinTones: [.medium])
-        } else if rawValue == "🧔🏾" {
-            self.init(baseEmoji: .beardedPerson, skinTones: [.mediumDark])
-        } else if rawValue == "🧔🏿" {
-            self.init(baseEmoji: .beardedPerson, skinTones: [.dark])
-        } else if rawValue == "🧔‍♂️" {
-            self.init(baseEmoji: .manWithBeard, skinTones: nil)
-        } else if rawValue == "🧔🏻‍♂️" {
-            self.init(baseEmoji: .manWithBeard, skinTones: [.light])
-        } else if rawValue == "🧔🏼‍♂️" {
-            self.init(baseEmoji: .manWithBeard, skinTones: [.mediumLight])
-        } else if rawValue == "🧔🏽‍♂️" {
-            self.init(baseEmoji: .manWithBeard, skinTones: [.medium])
-        } else if rawValue == "🧔🏾‍♂️" {
-            self.init(baseEmoji: .manWithBeard, skinTones: [.mediumDark])
-        } else if rawValue == "🧔🏿‍♂️" {
-            self.init(baseEmoji: .manWithBeard, skinTones: [.dark])
-        } else if rawValue == "🧔‍♀️" {
-            self.init(baseEmoji: .womanWithBeard, skinTones: nil)
-        } else if rawValue == "🧔🏻‍♀️" {
-            self.init(baseEmoji: .womanWithBeard, skinTones: [.light])
-        } else if rawValue == "🧔🏼‍♀️" {
-            self.init(baseEmoji: .womanWithBeard, skinTones: [.mediumLight])
-        } else if rawValue == "🧔🏽‍♀️" {
-            self.init(baseEmoji: .womanWithBeard, skinTones: [.medium])
-        } else if rawValue == "🧔🏾‍♀️" {
-            self.init(baseEmoji: .womanWithBeard, skinTones: [.mediumDark])
-        } else if rawValue == "🧔🏿‍♀️" {
-            self.init(baseEmoji: .womanWithBeard, skinTones: [.dark])
-        } else if rawValue == "👨‍🦰" {
-            self.init(baseEmoji: .redHairedMan, skinTones: nil)
-        } else if rawValue == "👨🏻‍🦰" {
-            self.init(baseEmoji: .redHairedMan, skinTones: [.light])
-        } else if rawValue == "👨🏼‍🦰" {
-            self.init(baseEmoji: .redHairedMan, skinTones: [.mediumLight])
-        } else if rawValue == "👨🏽‍🦰" {
-            self.init(baseEmoji: .redHairedMan, skinTones: [.medium])
-        } else if rawValue == "👨🏾‍🦰" {
-            self.init(baseEmoji: .redHairedMan, skinTones: [.mediumDark])
-        } else if rawValue == "👨🏿‍🦰" {
-            self.init(baseEmoji: .redHairedMan, skinTones: [.dark])
-        } else if rawValue == "👨‍🦱" {
-            self.init(baseEmoji: .curlyHairedMan, skinTones: nil)
-        } else if rawValue == "👨🏻‍🦱" {
-            self.init(baseEmoji: .curlyHairedMan, skinTones: [.light])
-        } else if rawValue == "👨🏼‍🦱" {
-            self.init(baseEmoji: .curlyHairedMan, skinTones: [.mediumLight])
-        } else if rawValue == "👨🏽‍🦱" {
-            self.init(baseEmoji: .curlyHairedMan, skinTones: [.medium])
-        } else if rawValue == "👨🏾‍🦱" {
-            self.init(baseEmoji: .curlyHairedMan, skinTones: [.mediumDark])
-        } else if rawValue == "👨🏿‍🦱" {
-            self.init(baseEmoji: .curlyHairedMan, skinTones: [.dark])
-        } else if rawValue == "👨‍🦳" {
-            self.init(baseEmoji: .whiteHairedMan, skinTones: nil)
-        } else if rawValue == "👨🏻‍🦳" {
-            self.init(baseEmoji: .whiteHairedMan, skinTones: [.light])
-        } else if rawValue == "👨🏼‍🦳" {
-            self.init(baseEmoji: .whiteHairedMan, skinTones: [.mediumLight])
-        } else if rawValue == "👨🏽‍🦳" {
-            self.init(baseEmoji: .whiteHairedMan, skinTones: [.medium])
-        } else if rawValue == "👨🏾‍🦳" {
-            self.init(baseEmoji: .whiteHairedMan, skinTones: [.mediumDark])
-        } else if rawValue == "👨🏿‍🦳" {
-            self.init(baseEmoji: .whiteHairedMan, skinTones: [.dark])
-        } else if rawValue == "👨‍🦲" {
-            self.init(baseEmoji: .baldMan, skinTones: nil)
-        } else if rawValue == "👨🏻‍🦲" {
-            self.init(baseEmoji: .baldMan, skinTones: [.light])
-        } else if rawValue == "👨🏼‍🦲" {
-            self.init(baseEmoji: .baldMan, skinTones: [.mediumLight])
-        } else if rawValue == "👨🏽‍🦲" {
-            self.init(baseEmoji: .baldMan, skinTones: [.medium])
-        } else if rawValue == "👨🏾‍🦲" {
-            self.init(baseEmoji: .baldMan, skinTones: [.mediumDark])
-        } else if rawValue == "👨🏿‍🦲" {
-            self.init(baseEmoji: .baldMan, skinTones: [.dark])
-        } else if rawValue == "👩" {
-            self.init(baseEmoji: .woman, skinTones: nil)
-        } else if rawValue == "👩🏻" {
-            self.init(baseEmoji: .woman, skinTones: [.light])
-        } else if rawValue == "👩🏼" {
-            self.init(baseEmoji: .woman, skinTones: [.mediumLight])
-        } else if rawValue == "👩🏽" {
-            self.init(baseEmoji: .woman, skinTones: [.medium])
-        } else if rawValue == "👩🏾" {
-            self.init(baseEmoji: .woman, skinTones: [.mediumDark])
-        } else if rawValue == "👩🏿" {
-            self.init(baseEmoji: .woman, skinTones: [.dark])
-        } else if rawValue == "👩‍🦰" {
-            self.init(baseEmoji: .redHairedWoman, skinTones: nil)
-        } else if rawValue == "👩🏻‍🦰" {
-            self.init(baseEmoji: .redHairedWoman, skinTones: [.light])
-        } else if rawValue == "👩🏼‍🦰" {
-            self.init(baseEmoji: .redHairedWoman, skinTones: [.mediumLight])
-        } else if rawValue == "👩🏽‍🦰" {
-            self.init(baseEmoji: .redHairedWoman, skinTones: [.medium])
-        } else if rawValue == "👩🏾‍🦰" {
-            self.init(baseEmoji: .redHairedWoman, skinTones: [.mediumDark])
-        } else if rawValue == "👩🏿‍🦰" {
-            self.init(baseEmoji: .redHairedWoman, skinTones: [.dark])
-        } else if rawValue == "🧑‍🦰" {
-            self.init(baseEmoji: .redHairedPerson, skinTones: nil)
-        } else if rawValue == "🧑🏻‍🦰" {
-            self.init(baseEmoji: .redHairedPerson, skinTones: [.light])
-        } else if rawValue == "🧑🏼‍🦰" {
-            self.init(baseEmoji: .redHairedPerson, skinTones: [.mediumLight])
-        } else if rawValue == "🧑🏽‍🦰" {
-            self.init(baseEmoji: .redHairedPerson, skinTones: [.medium])
-        } else if rawValue == "🧑🏾‍🦰" {
-            self.init(baseEmoji: .redHairedPerson, skinTones: [.mediumDark])
-        } else if rawValue == "🧑🏿‍🦰" {
-            self.init(baseEmoji: .redHairedPerson, skinTones: [.dark])
-        } else if rawValue == "👩‍🦱" {
-            self.init(baseEmoji: .curlyHairedWoman, skinTones: nil)
-        } else if rawValue == "👩🏻‍🦱" {
-            self.init(baseEmoji: .curlyHairedWoman, skinTones: [.light])
-        } else if rawValue == "👩🏼‍🦱" {
-            self.init(baseEmoji: .curlyHairedWoman, skinTones: [.mediumLight])
-        } else if rawValue == "👩🏽‍🦱" {
-            self.init(baseEmoji: .curlyHairedWoman, skinTones: [.medium])
-        } else if rawValue == "👩🏾‍🦱" {
-            self.init(baseEmoji: .curlyHairedWoman, skinTones: [.mediumDark])
-        } else if rawValue == "👩🏿‍🦱" {
-            self.init(baseEmoji: .curlyHairedWoman, skinTones: [.dark])
-        } else if rawValue == "🧑‍🦱" {
-            self.init(baseEmoji: .curlyHairedPerson, skinTones: nil)
-        } else if rawValue == "🧑🏻‍🦱" {
-            self.init(baseEmoji: .curlyHairedPerson, skinTones: [.light])
-        } else if rawValue == "🧑🏼‍🦱" {
-            self.init(baseEmoji: .curlyHairedPerson, skinTones: [.mediumLight])
-        } else if rawValue == "🧑🏽‍🦱" {
-            self.init(baseEmoji: .curlyHairedPerson, skinTones: [.medium])
-        } else if rawValue == "🧑🏾‍🦱" {
-            self.init(baseEmoji: .curlyHairedPerson, skinTones: [.mediumDark])
-        } else if rawValue == "🧑🏿‍🦱" {
-            self.init(baseEmoji: .curlyHairedPerson, skinTones: [.dark])
-        } else if rawValue == "👩‍🦳" {
-            self.init(baseEmoji: .whiteHairedWoman, skinTones: nil)
-        } else if rawValue == "👩🏻‍🦳" {
-            self.init(baseEmoji: .whiteHairedWoman, skinTones: [.light])
-        } else if rawValue == "👩🏼‍🦳" {
-            self.init(baseEmoji: .whiteHairedWoman, skinTones: [.mediumLight])
-        } else if rawValue == "👩🏽‍🦳" {
-            self.init(baseEmoji: .whiteHairedWoman, skinTones: [.medium])
-        } else if rawValue == "👩🏾‍🦳" {
-            self.init(baseEmoji: .whiteHairedWoman, skinTones: [.mediumDark])
-        } else if rawValue == "👩🏿‍🦳" {
-            self.init(baseEmoji: .whiteHairedWoman, skinTones: [.dark])
-        } else if rawValue == "🧑‍🦳" {
-            self.init(baseEmoji: .whiteHairedPerson, skinTones: nil)
-        } else if rawValue == "🧑🏻‍🦳" {
-            self.init(baseEmoji: .whiteHairedPerson, skinTones: [.light])
-        } else if rawValue == "🧑🏼‍🦳" {
-            self.init(baseEmoji: .whiteHairedPerson, skinTones: [.mediumLight])
-        } else if rawValue == "🧑🏽‍🦳" {
-            self.init(baseEmoji: .whiteHairedPerson, skinTones: [.medium])
-        } else if rawValue == "🧑🏾‍🦳" {
-            self.init(baseEmoji: .whiteHairedPerson, skinTones: [.mediumDark])
-        } else if rawValue == "🧑🏿‍🦳" {
-            self.init(baseEmoji: .whiteHairedPerson, skinTones: [.dark])
-        } else if rawValue == "👩‍🦲" {
-            self.init(baseEmoji: .baldWoman, skinTones: nil)
-        } else if rawValue == "👩🏻‍🦲" {
-            self.init(baseEmoji: .baldWoman, skinTones: [.light])
-        } else if rawValue == "👩🏼‍🦲" {
-            self.init(baseEmoji: .baldWoman, skinTones: [.mediumLight])
-        } else if rawValue == "👩🏽‍🦲" {
-            self.init(baseEmoji: .baldWoman, skinTones: [.medium])
-        } else if rawValue == "👩🏾‍🦲" {
-            self.init(baseEmoji: .baldWoman, skinTones: [.mediumDark])
-        } else if rawValue == "👩🏿‍🦲" {
-            self.init(baseEmoji: .baldWoman, skinTones: [.dark])
-        } else if rawValue == "🧑‍🦲" {
-            self.init(baseEmoji: .baldPerson, skinTones: nil)
-        } else if rawValue == "🧑🏻‍🦲" {
-            self.init(baseEmoji: .baldPerson, skinTones: [.light])
-        } else if rawValue == "🧑🏼‍🦲" {
-            self.init(baseEmoji: .baldPerson, skinTones: [.mediumLight])
-        } else if rawValue == "🧑🏽‍🦲" {
-            self.init(baseEmoji: .baldPerson, skinTones: [.medium])
-        } else if rawValue == "🧑🏾‍🦲" {
-            self.init(baseEmoji: .baldPerson, skinTones: [.mediumDark])
-        } else if rawValue == "🧑🏿‍🦲" {
-            self.init(baseEmoji: .baldPerson, skinTones: [.dark])
-        } else if rawValue == "👱‍♀️" {
-            self.init(baseEmoji: .blondHairedWoman, skinTones: nil)
-        } else if rawValue == "👱🏻‍♀️" {
-            self.init(baseEmoji: .blondHairedWoman, skinTones: [.light])
-        } else if rawValue == "👱🏼‍♀️" {
-            self.init(baseEmoji: .blondHairedWoman, skinTones: [.mediumLight])
-        } else if rawValue == "👱🏽‍♀️" {
-            self.init(baseEmoji: .blondHairedWoman, skinTones: [.medium])
-        } else if rawValue == "👱🏾‍♀️" {
-            self.init(baseEmoji: .blondHairedWoman, skinTones: [.mediumDark])
-        } else if rawValue == "👱🏿‍♀️" {
-            self.init(baseEmoji: .blondHairedWoman, skinTones: [.dark])
-        } else if rawValue == "👱‍♂️" {
-            self.init(baseEmoji: .blondHairedMan, skinTones: nil)
-        } else if rawValue == "👱🏻‍♂️" {
-            self.init(baseEmoji: .blondHairedMan, skinTones: [.light])
-        } else if rawValue == "👱🏼‍♂️" {
-            self.init(baseEmoji: .blondHairedMan, skinTones: [.mediumLight])
-        } else if rawValue == "👱🏽‍♂️" {
-            self.init(baseEmoji: .blondHairedMan, skinTones: [.medium])
-        } else if rawValue == "👱🏾‍♂️" {
-            self.init(baseEmoji: .blondHairedMan, skinTones: [.mediumDark])
-        } else if rawValue == "👱🏿‍♂️" {
-            self.init(baseEmoji: .blondHairedMan, skinTones: [.dark])
-        } else if rawValue == "🧓" {
-            self.init(baseEmoji: .olderAdult, skinTones: nil)
-        } else if rawValue == "🧓🏻" {
-            self.init(baseEmoji: .olderAdult, skinTones: [.light])
-        } else if rawValue == "🧓🏼" {
-            self.init(baseEmoji: .olderAdult, skinTones: [.mediumLight])
-        } else if rawValue == "🧓🏽" {
-            self.init(baseEmoji: .olderAdult, skinTones: [.medium])
-        } else if rawValue == "🧓🏾" {
-            self.init(baseEmoji: .olderAdult, skinTones: [.mediumDark])
-        } else if rawValue == "🧓🏿" {
-            self.init(baseEmoji: .olderAdult, skinTones: [.dark])
-        } else if rawValue == "👴" {
-            self.init(baseEmoji: .olderMan, skinTones: nil)
-        } else if rawValue == "👴🏻" {
-            self.init(baseEmoji: .olderMan, skinTones: [.light])
-        } else if rawValue == "👴🏼" {
-            self.init(baseEmoji: .olderMan, skinTones: [.mediumLight])
-        } else if rawValue == "👴🏽" {
-            self.init(baseEmoji: .olderMan, skinTones: [.medium])
-        } else if rawValue == "👴🏾" {
-            self.init(baseEmoji: .olderMan, skinTones: [.mediumDark])
-        } else if rawValue == "👴🏿" {
-            self.init(baseEmoji: .olderMan, skinTones: [.dark])
-        } else if rawValue == "👵" {
-            self.init(baseEmoji: .olderWoman, skinTones: nil)
-        } else if rawValue == "👵🏻" {
-            self.init(baseEmoji: .olderWoman, skinTones: [.light])
-        } else if rawValue == "👵🏼" {
-            self.init(baseEmoji: .olderWoman, skinTones: [.mediumLight])
-        } else if rawValue == "👵🏽" {
-            self.init(baseEmoji: .olderWoman, skinTones: [.medium])
-        } else if rawValue == "👵🏾" {
-            self.init(baseEmoji: .olderWoman, skinTones: [.mediumDark])
-        } else if rawValue == "👵🏿" {
-            self.init(baseEmoji: .olderWoman, skinTones: [.dark])
-        } else if rawValue == "🙍" {
-            self.init(baseEmoji: .personFrowning, skinTones: nil)
-        } else if rawValue == "🙍🏻" {
-            self.init(baseEmoji: .personFrowning, skinTones: [.light])
-        } else if rawValue == "🙍🏼" {
-            self.init(baseEmoji: .personFrowning, skinTones: [.mediumLight])
-        } else if rawValue == "🙍🏽" {
-            self.init(baseEmoji: .personFrowning, skinTones: [.medium])
-        } else if rawValue == "🙍🏾" {
-            self.init(baseEmoji: .personFrowning, skinTones: [.mediumDark])
-        } else if rawValue == "🙍🏿" {
-            self.init(baseEmoji: .personFrowning, skinTones: [.dark])
-        } else if rawValue == "🙍‍♂️" {
-            self.init(baseEmoji: .manFrowning, skinTones: nil)
-        } else if rawValue == "🙍🏻‍♂️" {
-            self.init(baseEmoji: .manFrowning, skinTones: [.light])
-        } else if rawValue == "🙍🏼‍♂️" {
-            self.init(baseEmoji: .manFrowning, skinTones: [.mediumLight])
-        } else if rawValue == "🙍🏽‍♂️" {
-            self.init(baseEmoji: .manFrowning, skinTones: [.medium])
-        } else if rawValue == "🙍🏾‍♂️" {
-            self.init(baseEmoji: .manFrowning, skinTones: [.mediumDark])
-        } else if rawValue == "🙍🏿‍♂️" {
-            self.init(baseEmoji: .manFrowning, skinTones: [.dark])
-        } else if rawValue == "🙍‍♀️" {
-            self.init(baseEmoji: .womanFrowning, skinTones: nil)
-        } else if rawValue == "🙍🏻‍♀️" {
-            self.init(baseEmoji: .womanFrowning, skinTones: [.light])
-        } else if rawValue == "🙍🏼‍♀️" {
-            self.init(baseEmoji: .womanFrowning, skinTones: [.mediumLight])
-        } else if rawValue == "🙍🏽‍♀️" {
-            self.init(baseEmoji: .womanFrowning, skinTones: [.medium])
-        } else if rawValue == "🙍🏾‍♀️" {
-            self.init(baseEmoji: .womanFrowning, skinTones: [.mediumDark])
-        } else if rawValue == "🙍🏿‍♀️" {
-            self.init(baseEmoji: .womanFrowning, skinTones: [.dark])
-        } else if rawValue == "🙎" {
-            self.init(baseEmoji: .personWithPoutingFace, skinTones: nil)
-        } else if rawValue == "🙎🏻" {
-            self.init(baseEmoji: .personWithPoutingFace, skinTones: [.light])
-        } else if rawValue == "🙎🏼" {
-            self.init(baseEmoji: .personWithPoutingFace, skinTones: [.mediumLight])
-        } else if rawValue == "🙎🏽" {
-            self.init(baseEmoji: .personWithPoutingFace, skinTones: [.medium])
-        } else if rawValue == "🙎🏾" {
-            self.init(baseEmoji: .personWithPoutingFace, skinTones: [.mediumDark])
-        } else if rawValue == "🙎🏿" {
-            self.init(baseEmoji: .personWithPoutingFace, skinTones: [.dark])
-        } else if rawValue == "🙎‍♂️" {
-            self.init(baseEmoji: .manPouting, skinTones: nil)
-        } else if rawValue == "🙎🏻‍♂️" {
-            self.init(baseEmoji: .manPouting, skinTones: [.light])
-        } else if rawValue == "🙎🏼‍♂️" {
-            self.init(baseEmoji: .manPouting, skinTones: [.mediumLight])
-        } else if rawValue == "🙎🏽‍♂️" {
-            self.init(baseEmoji: .manPouting, skinTones: [.medium])
-        } else if rawValue == "🙎🏾‍♂️" {
-            self.init(baseEmoji: .manPouting, skinTones: [.mediumDark])
-        } else if rawValue == "🙎🏿‍♂️" {
-            self.init(baseEmoji: .manPouting, skinTones: [.dark])
-        } else if rawValue == "🙎‍♀️" {
-            self.init(baseEmoji: .womanPouting, skinTones: nil)
-        } else if rawValue == "🙎🏻‍♀️" {
-            self.init(baseEmoji: .womanPouting, skinTones: [.light])
-        } else if rawValue == "🙎🏼‍♀️" {
-            self.init(baseEmoji: .womanPouting, skinTones: [.mediumLight])
-        } else if rawValue == "🙎🏽‍♀️" {
-            self.init(baseEmoji: .womanPouting, skinTones: [.medium])
-        } else if rawValue == "🙎🏾‍♀️" {
-            self.init(baseEmoji: .womanPouting, skinTones: [.mediumDark])
-        } else if rawValue == "🙎🏿‍♀️" {
-            self.init(baseEmoji: .womanPouting, skinTones: [.dark])
-        } else if rawValue == "🙅" {
-            self.init(baseEmoji: .noGood, skinTones: nil)
-        } else if rawValue == "🙅🏻" {
-            self.init(baseEmoji: .noGood, skinTones: [.light])
-        } else if rawValue == "🙅🏼" {
-            self.init(baseEmoji: .noGood, skinTones: [.mediumLight])
-        } else if rawValue == "🙅🏽" {
-            self.init(baseEmoji: .noGood, skinTones: [.medium])
-        } else if rawValue == "🙅🏾" {
-            self.init(baseEmoji: .noGood, skinTones: [.mediumDark])
-        } else if rawValue == "🙅🏿" {
-            self.init(baseEmoji: .noGood, skinTones: [.dark])
-        } else if rawValue == "🙅‍♂️" {
-            self.init(baseEmoji: .manGesturingNo, skinTones: nil)
-        } else if rawValue == "🙅🏻‍♂️" {
-            self.init(baseEmoji: .manGesturingNo, skinTones: [.light])
-        } else if rawValue == "🙅🏼‍♂️" {
-            self.init(baseEmoji: .manGesturingNo, skinTones: [.mediumLight])
-        } else if rawValue == "🙅🏽‍♂️" {
-            self.init(baseEmoji: .manGesturingNo, skinTones: [.medium])
-        } else if rawValue == "🙅🏾‍♂️" {
-            self.init(baseEmoji: .manGesturingNo, skinTones: [.mediumDark])
-        } else if rawValue == "🙅🏿‍♂️" {
-            self.init(baseEmoji: .manGesturingNo, skinTones: [.dark])
-        } else if rawValue == "🙅‍♀️" {
-            self.init(baseEmoji: .womanGesturingNo, skinTones: nil)
-        } else if rawValue == "🙅🏻‍♀️" {
-            self.init(baseEmoji: .womanGesturingNo, skinTones: [.light])
-        } else if rawValue == "🙅🏼‍♀️" {
-            self.init(baseEmoji: .womanGesturingNo, skinTones: [.mediumLight])
-        } else if rawValue == "🙅🏽‍♀️" {
-            self.init(baseEmoji: .womanGesturingNo, skinTones: [.medium])
-        } else if rawValue == "🙅🏾‍♀️" {
-            self.init(baseEmoji: .womanGesturingNo, skinTones: [.mediumDark])
-        } else if rawValue == "🙅🏿‍♀️" {
-            self.init(baseEmoji: .womanGesturingNo, skinTones: [.dark])
-        } else if rawValue == "🙆" {
-            self.init(baseEmoji: .okWoman, skinTones: nil)
-        } else if rawValue == "🙆🏻" {
-            self.init(baseEmoji: .okWoman, skinTones: [.light])
-        } else if rawValue == "🙆🏼" {
-            self.init(baseEmoji: .okWoman, skinTones: [.mediumLight])
-        } else if rawValue == "🙆🏽" {
-            self.init(baseEmoji: .okWoman, skinTones: [.medium])
-        } else if rawValue == "🙆🏾" {
-            self.init(baseEmoji: .okWoman, skinTones: [.mediumDark])
-        } else if rawValue == "🙆🏿" {
-            self.init(baseEmoji: .okWoman, skinTones: [.dark])
-        } else if rawValue == "🙆‍♂️" {
-            self.init(baseEmoji: .manGesturingOk, skinTones: nil)
-        } else if rawValue == "🙆🏻‍♂️" {
-            self.init(baseEmoji: .manGesturingOk, skinTones: [.light])
-        } else if rawValue == "🙆🏼‍♂️" {
-            self.init(baseEmoji: .manGesturingOk, skinTones: [.mediumLight])
-        } else if rawValue == "🙆🏽‍♂️" {
-            self.init(baseEmoji: .manGesturingOk, skinTones: [.medium])
-        } else if rawValue == "🙆🏾‍♂️" {
-            self.init(baseEmoji: .manGesturingOk, skinTones: [.mediumDark])
-        } else if rawValue == "🙆🏿‍♂️" {
-            self.init(baseEmoji: .manGesturingOk, skinTones: [.dark])
-        } else if rawValue == "🙆‍♀️" {
-            self.init(baseEmoji: .womanGesturingOk, skinTones: nil)
-        } else if rawValue == "🙆🏻‍♀️" {
-            self.init(baseEmoji: .womanGesturingOk, skinTones: [.light])
-        } else if rawValue == "🙆🏼‍♀️" {
-            self.init(baseEmoji: .womanGesturingOk, skinTones: [.mediumLight])
-        } else if rawValue == "🙆🏽‍♀️" {
-            self.init(baseEmoji: .womanGesturingOk, skinTones: [.medium])
-        } else if rawValue == "🙆🏾‍♀️" {
-            self.init(baseEmoji: .womanGesturingOk, skinTones: [.mediumDark])
-        } else if rawValue == "🙆🏿‍♀️" {
-            self.init(baseEmoji: .womanGesturingOk, skinTones: [.dark])
-        } else if rawValue == "💁" {
-            self.init(baseEmoji: .informationDeskPerson, skinTones: nil)
-        } else if rawValue == "💁🏻" {
-            self.init(baseEmoji: .informationDeskPerson, skinTones: [.light])
-        } else if rawValue == "💁🏼" {
-            self.init(baseEmoji: .informationDeskPerson, skinTones: [.mediumLight])
-        } else if rawValue == "💁🏽" {
-            self.init(baseEmoji: .informationDeskPerson, skinTones: [.medium])
-        } else if rawValue == "💁🏾" {
-            self.init(baseEmoji: .informationDeskPerson, skinTones: [.mediumDark])
-        } else if rawValue == "💁🏿" {
-            self.init(baseEmoji: .informationDeskPerson, skinTones: [.dark])
-        } else if rawValue == "💁‍♂️" {
-            self.init(baseEmoji: .manTippingHand, skinTones: nil)
-        } else if rawValue == "💁🏻‍♂️" {
-            self.init(baseEmoji: .manTippingHand, skinTones: [.light])
-        } else if rawValue == "💁🏼‍♂️" {
-            self.init(baseEmoji: .manTippingHand, skinTones: [.mediumLight])
-        } else if rawValue == "💁🏽‍♂️" {
-            self.init(baseEmoji: .manTippingHand, skinTones: [.medium])
-        } else if rawValue == "💁🏾‍♂️" {
-            self.init(baseEmoji: .manTippingHand, skinTones: [.mediumDark])
-        } else if rawValue == "💁🏿‍♂️" {
-            self.init(baseEmoji: .manTippingHand, skinTones: [.dark])
-        } else if rawValue == "💁‍♀️" {
-            self.init(baseEmoji: .womanTippingHand, skinTones: nil)
-        } else if rawValue == "💁🏻‍♀️" {
-            self.init(baseEmoji: .womanTippingHand, skinTones: [.light])
-        } else if rawValue == "💁🏼‍♀️" {
-            self.init(baseEmoji: .womanTippingHand, skinTones: [.mediumLight])
-        } else if rawValue == "💁🏽‍♀️" {
-            self.init(baseEmoji: .womanTippingHand, skinTones: [.medium])
-        } else if rawValue == "💁🏾‍♀️" {
-            self.init(baseEmoji: .womanTippingHand, skinTones: [.mediumDark])
-        } else if rawValue == "💁🏿‍♀️" {
-            self.init(baseEmoji: .womanTippingHand, skinTones: [.dark])
-        } else if rawValue == "🙋" {
-            self.init(baseEmoji: .raisingHand, skinTones: nil)
-        } else if rawValue == "🙋🏻" {
-            self.init(baseEmoji: .raisingHand, skinTones: [.light])
-        } else if rawValue == "🙋🏼" {
-            self.init(baseEmoji: .raisingHand, skinTones: [.mediumLight])
-        } else if rawValue == "🙋🏽" {
-            self.init(baseEmoji: .raisingHand, skinTones: [.medium])
-        } else if rawValue == "🙋🏾" {
-            self.init(baseEmoji: .raisingHand, skinTones: [.mediumDark])
-        } else if rawValue == "🙋🏿" {
-            self.init(baseEmoji: .raisingHand, skinTones: [.dark])
-        } else if rawValue == "🙋‍♂️" {
-            self.init(baseEmoji: .manRaisingHand, skinTones: nil)
-        } else if rawValue == "🙋🏻‍♂️" {
-            self.init(baseEmoji: .manRaisingHand, skinTones: [.light])
-        } else if rawValue == "🙋🏼‍♂️" {
-            self.init(baseEmoji: .manRaisingHand, skinTones: [.mediumLight])
-        } else if rawValue == "🙋🏽‍♂️" {
-            self.init(baseEmoji: .manRaisingHand, skinTones: [.medium])
-        } else if rawValue == "🙋🏾‍♂️" {
-            self.init(baseEmoji: .manRaisingHand, skinTones: [.mediumDark])
-        } else if rawValue == "🙋🏿‍♂️" {
-            self.init(baseEmoji: .manRaisingHand, skinTones: [.dark])
-        } else if rawValue == "🙋‍♀️" {
-            self.init(baseEmoji: .womanRaisingHand, skinTones: nil)
-        } else if rawValue == "🙋🏻‍♀️" {
-            self.init(baseEmoji: .womanRaisingHand, skinTones: [.light])
-        } else if rawValue == "🙋🏼‍♀️" {
-            self.init(baseEmoji: .womanRaisingHand, skinTones: [.mediumLight])
-        } else if rawValue == "🙋🏽‍♀️" {
-            self.init(baseEmoji: .womanRaisingHand, skinTones: [.medium])
-        } else if rawValue == "🙋🏾‍♀️" {
-            self.init(baseEmoji: .womanRaisingHand, skinTones: [.mediumDark])
-        } else if rawValue == "🙋🏿‍♀️" {
-            self.init(baseEmoji: .womanRaisingHand, skinTones: [.dark])
-        } else if rawValue == "🧏" {
-            self.init(baseEmoji: .deafPerson, skinTones: nil)
-        } else if rawValue == "🧏🏻" {
-            self.init(baseEmoji: .deafPerson, skinTones: [.light])
-        } else if rawValue == "🧏🏼" {
-            self.init(baseEmoji: .deafPerson, skinTones: [.mediumLight])
-        } else if rawValue == "🧏🏽" {
-            self.init(baseEmoji: .deafPerson, skinTones: [.medium])
-        } else if rawValue == "🧏🏾" {
-            self.init(baseEmoji: .deafPerson, skinTones: [.mediumDark])
-        } else if rawValue == "🧏🏿" {
-            self.init(baseEmoji: .deafPerson, skinTones: [.dark])
-        } else if rawValue == "🧏‍♂️" {
-            self.init(baseEmoji: .deafMan, skinTones: nil)
-        } else if rawValue == "🧏🏻‍♂️" {
-            self.init(baseEmoji: .deafMan, skinTones: [.light])
-        } else if rawValue == "🧏🏼‍♂️" {
-            self.init(baseEmoji: .deafMan, skinTones: [.mediumLight])
-        } else if rawValue == "🧏🏽‍♂️" {
-            self.init(baseEmoji: .deafMan, skinTones: [.medium])
-        } else if rawValue == "🧏🏾‍♂️" {
-            self.init(baseEmoji: .deafMan, skinTones: [.mediumDark])
-        } else if rawValue == "🧏🏿‍♂️" {
-            self.init(baseEmoji: .deafMan, skinTones: [.dark])
-        } else if rawValue == "🧏‍♀️" {
-            self.init(baseEmoji: .deafWoman, skinTones: nil)
-        } else if rawValue == "🧏🏻‍♀️" {
-            self.init(baseEmoji: .deafWoman, skinTones: [.light])
-        } else if rawValue == "🧏🏼‍♀️" {
-            self.init(baseEmoji: .deafWoman, skinTones: [.mediumLight])
-        } else if rawValue == "🧏🏽‍♀️" {
-            self.init(baseEmoji: .deafWoman, skinTones: [.medium])
-        } else if rawValue == "🧏🏾‍♀️" {
-            self.init(baseEmoji: .deafWoman, skinTones: [.mediumDark])
-        } else if rawValue == "🧏🏿‍♀️" {
-            self.init(baseEmoji: .deafWoman, skinTones: [.dark])
-        } else if rawValue == "🙇" {
-            self.init(baseEmoji: .bow, skinTones: nil)
-        } else if rawValue == "🙇🏻" {
-            self.init(baseEmoji: .bow, skinTones: [.light])
-        } else if rawValue == "🙇🏼" {
-            self.init(baseEmoji: .bow, skinTones: [.mediumLight])
-        } else if rawValue == "🙇🏽" {
-            self.init(baseEmoji: .bow, skinTones: [.medium])
-        } else if rawValue == "🙇🏾" {
-            self.init(baseEmoji: .bow, skinTones: [.mediumDark])
-        } else if rawValue == "🙇🏿" {
-            self.init(baseEmoji: .bow, skinTones: [.dark])
-        } else if rawValue == "🙇‍♂️" {
-            self.init(baseEmoji: .manBowing, skinTones: nil)
-        } else if rawValue == "🙇🏻‍♂️" {
-            self.init(baseEmoji: .manBowing, skinTones: [.light])
-        } else if rawValue == "🙇🏼‍♂️" {
-            self.init(baseEmoji: .manBowing, skinTones: [.mediumLight])
-        } else if rawValue == "🙇🏽‍♂️" {
-            self.init(baseEmoji: .manBowing, skinTones: [.medium])
-        } else if rawValue == "🙇🏾‍♂️" {
-            self.init(baseEmoji: .manBowing, skinTones: [.mediumDark])
-        } else if rawValue == "🙇🏿‍♂️" {
-            self.init(baseEmoji: .manBowing, skinTones: [.dark])
-        } else if rawValue == "🙇‍♀️" {
-            self.init(baseEmoji: .womanBowing, skinTones: nil)
-        } else if rawValue == "🙇🏻‍♀️" {
-            self.init(baseEmoji: .womanBowing, skinTones: [.light])
-        } else if rawValue == "🙇🏼‍♀️" {
-            self.init(baseEmoji: .womanBowing, skinTones: [.mediumLight])
-        } else if rawValue == "🙇🏽‍♀️" {
-            self.init(baseEmoji: .womanBowing, skinTones: [.medium])
-        } else if rawValue == "🙇🏾‍♀️" {
-            self.init(baseEmoji: .womanBowing, skinTones: [.mediumDark])
-        } else if rawValue == "🙇🏿‍♀️" {
-            self.init(baseEmoji: .womanBowing, skinTones: [.dark])
-        } else if rawValue == "🤦" {
-            self.init(baseEmoji: .facePalm, skinTones: nil)
-        } else if rawValue == "🤦🏻" {
-            self.init(baseEmoji: .facePalm, skinTones: [.light])
-        } else if rawValue == "🤦🏼" {
-            self.init(baseEmoji: .facePalm, skinTones: [.mediumLight])
-        } else if rawValue == "🤦🏽" {
-            self.init(baseEmoji: .facePalm, skinTones: [.medium])
-        } else if rawValue == "🤦🏾" {
-            self.init(baseEmoji: .facePalm, skinTones: [.mediumDark])
-        } else if rawValue == "🤦🏿" {
-            self.init(baseEmoji: .facePalm, skinTones: [.dark])
-        } else if rawValue == "🤦‍♂️" {
-            self.init(baseEmoji: .manFacepalming, skinTones: nil)
-        } else if rawValue == "🤦🏻‍♂️" {
-            self.init(baseEmoji: .manFacepalming, skinTones: [.light])
-        } else if rawValue == "🤦🏼‍♂️" {
-            self.init(baseEmoji: .manFacepalming, skinTones: [.mediumLight])
-        } else if rawValue == "🤦🏽‍♂️" {
-            self.init(baseEmoji: .manFacepalming, skinTones: [.medium])
-        } else if rawValue == "🤦🏾‍♂️" {
-            self.init(baseEmoji: .manFacepalming, skinTones: [.mediumDark])
-        } else if rawValue == "🤦🏿‍♂️" {
-            self.init(baseEmoji: .manFacepalming, skinTones: [.dark])
-        } else if rawValue == "🤦‍♀️" {
-            self.init(baseEmoji: .womanFacepalming, skinTones: nil)
-        } else if rawValue == "🤦🏻‍♀️" {
-            self.init(baseEmoji: .womanFacepalming, skinTones: [.light])
-        } else if rawValue == "🤦🏼‍♀️" {
-            self.init(baseEmoji: .womanFacepalming, skinTones: [.mediumLight])
-        } else if rawValue == "🤦🏽‍♀️" {
-            self.init(baseEmoji: .womanFacepalming, skinTones: [.medium])
-        } else if rawValue == "🤦🏾‍♀️" {
-            self.init(baseEmoji: .womanFacepalming, skinTones: [.mediumDark])
-        } else if rawValue == "🤦🏿‍♀️" {
-            self.init(baseEmoji: .womanFacepalming, skinTones: [.dark])
-        } else if rawValue == "🤷" {
-            self.init(baseEmoji: .shrug, skinTones: nil)
-        } else if rawValue == "🤷🏻" {
-            self.init(baseEmoji: .shrug, skinTones: [.light])
-        } else if rawValue == "🤷🏼" {
-            self.init(baseEmoji: .shrug, skinTones: [.mediumLight])
-        } else if rawValue == "🤷🏽" {
-            self.init(baseEmoji: .shrug, skinTones: [.medium])
-        } else if rawValue == "🤷🏾" {
-            self.init(baseEmoji: .shrug, skinTones: [.mediumDark])
-        } else if rawValue == "🤷🏿" {
-            self.init(baseEmoji: .shrug, skinTones: [.dark])
-        } else if rawValue == "🤷‍♂️" {
-            self.init(baseEmoji: .manShrugging, skinTones: nil)
-        } else if rawValue == "🤷🏻‍♂️" {
-            self.init(baseEmoji: .manShrugging, skinTones: [.light])
-        } else if rawValue == "🤷🏼‍♂️" {
-            self.init(baseEmoji: .manShrugging, skinTones: [.mediumLight])
-        } else if rawValue == "🤷🏽‍♂️" {
-            self.init(baseEmoji: .manShrugging, skinTones: [.medium])
-        } else if rawValue == "🤷🏾‍♂️" {
-            self.init(baseEmoji: .manShrugging, skinTones: [.mediumDark])
-        } else if rawValue == "🤷🏿‍♂️" {
-            self.init(baseEmoji: .manShrugging, skinTones: [.dark])
-        } else if rawValue == "🤷‍♀️" {
-            self.init(baseEmoji: .womanShrugging, skinTones: nil)
-        } else if rawValue == "🤷🏻‍♀️" {
-            self.init(baseEmoji: .womanShrugging, skinTones: [.light])
-        } else if rawValue == "🤷🏼‍♀️" {
-            self.init(baseEmoji: .womanShrugging, skinTones: [.mediumLight])
-        } else if rawValue == "🤷🏽‍♀️" {
-            self.init(baseEmoji: .womanShrugging, skinTones: [.medium])
-        } else if rawValue == "🤷🏾‍♀️" {
-            self.init(baseEmoji: .womanShrugging, skinTones: [.mediumDark])
-        } else if rawValue == "🤷🏿‍♀️" {
-            self.init(baseEmoji: .womanShrugging, skinTones: [.dark])
-        } else if rawValue == "🧑‍⚕️" {
-            self.init(baseEmoji: .healthWorker, skinTones: nil)
-        } else if rawValue == "🧑🏻‍⚕️" {
-            self.init(baseEmoji: .healthWorker, skinTones: [.light])
-        } else if rawValue == "🧑🏼‍⚕️" {
-            self.init(baseEmoji: .healthWorker, skinTones: [.mediumLight])
-        } else if rawValue == "🧑🏽‍⚕️" {
-            self.init(baseEmoji: .healthWorker, skinTones: [.medium])
-        } else if rawValue == "🧑🏾‍⚕️" {
-            self.init(baseEmoji: .healthWorker, skinTones: [.mediumDark])
-        } else if rawValue == "🧑🏿‍⚕️" {
-            self.init(baseEmoji: .healthWorker, skinTones: [.dark])
-        } else if rawValue == "👨‍⚕️" {
-            self.init(baseEmoji: .maleDoctor, skinTones: nil)
-        } else if rawValue == "👨🏻‍⚕️" {
-            self.init(baseEmoji: .maleDoctor, skinTones: [.light])
-        } else if rawValue == "👨🏼‍⚕️" {
-            self.init(baseEmoji: .maleDoctor, skinTones: [.mediumLight])
-        } else if rawValue == "👨🏽‍⚕️" {
-            self.init(baseEmoji: .maleDoctor, skinTones: [.medium])
-        } else if rawValue == "👨🏾‍⚕️" {
-            self.init(baseEmoji: .maleDoctor, skinTones: [.mediumDark])
-        } else if rawValue == "👨🏿‍⚕️" {
-            self.init(baseEmoji: .maleDoctor, skinTones: [.dark])
-        } else if rawValue == "👩‍⚕️" {
-            self.init(baseEmoji: .femaleDoctor, skinTones: nil)
-        } else if rawValue == "👩🏻‍⚕️" {
-            self.init(baseEmoji: .femaleDoctor, skinTones: [.light])
-        } else if rawValue == "👩🏼‍⚕️" {
-            self.init(baseEmoji: .femaleDoctor, skinTones: [.mediumLight])
-        } else if rawValue == "👩🏽‍⚕️" {
-            self.init(baseEmoji: .femaleDoctor, skinTones: [.medium])
-        } else if rawValue == "👩🏾‍⚕️" {
-            self.init(baseEmoji: .femaleDoctor, skinTones: [.mediumDark])
-        } else if rawValue == "👩🏿‍⚕️" {
-            self.init(baseEmoji: .femaleDoctor, skinTones: [.dark])
-        } else if rawValue == "🧑‍🎓" {
-            self.init(baseEmoji: .student, skinTones: nil)
-        } else if rawValue == "🧑🏻‍🎓" {
-            self.init(baseEmoji: .student, skinTones: [.light])
-        } else if rawValue == "🧑🏼‍🎓" {
-            self.init(baseEmoji: .student, skinTones: [.mediumLight])
-        } else if rawValue == "🧑🏽‍🎓" {
-            self.init(baseEmoji: .student, skinTones: [.medium])
-        } else if rawValue == "🧑🏾‍🎓" {
-            self.init(baseEmoji: .student, skinTones: [.mediumDark])
-        } else if rawValue == "🧑🏿‍🎓" {
-            self.init(baseEmoji: .student, skinTones: [.dark])
-        } else if rawValue == "👨‍🎓" {
-            self.init(baseEmoji: .maleStudent, skinTones: nil)
-        } else if rawValue == "👨🏻‍🎓" {
-            self.init(baseEmoji: .maleStudent, skinTones: [.light])
-        } else if rawValue == "👨🏼‍🎓" {
-            self.init(baseEmoji: .maleStudent, skinTones: [.mediumLight])
-        } else if rawValue == "👨🏽‍🎓" {
-            self.init(baseEmoji: .maleStudent, skinTones: [.medium])
-        } else if rawValue == "👨🏾‍🎓" {
-            self.init(baseEmoji: .maleStudent, skinTones: [.mediumDark])
-        } else if rawValue == "👨🏿‍🎓" {
-            self.init(baseEmoji: .maleStudent, skinTones: [.dark])
-        } else if rawValue == "👩‍🎓" {
-            self.init(baseEmoji: .femaleStudent, skinTones: nil)
-        } else if rawValue == "👩🏻‍🎓" {
-            self.init(baseEmoji: .femaleStudent, skinTones: [.light])
-        } else if rawValue == "👩🏼‍🎓" {
-            self.init(baseEmoji: .femaleStudent, skinTones: [.mediumLight])
-        } else if rawValue == "👩🏽‍🎓" {
-            self.init(baseEmoji: .femaleStudent, skinTones: [.medium])
-        } else if rawValue == "👩🏾‍🎓" {
-            self.init(baseEmoji: .femaleStudent, skinTones: [.mediumDark])
-        } else if rawValue == "👩🏿‍🎓" {
-            self.init(baseEmoji: .femaleStudent, skinTones: [.dark])
-        } else if rawValue == "🧑‍🏫" {
-            self.init(baseEmoji: .teacher, skinTones: nil)
-        } else if rawValue == "🧑🏻‍🏫" {
-            self.init(baseEmoji: .teacher, skinTones: [.light])
-        } else if rawValue == "🧑🏼‍🏫" {
-            self.init(baseEmoji: .teacher, skinTones: [.mediumLight])
-        } else if rawValue == "🧑🏽‍🏫" {
-            self.init(baseEmoji: .teacher, skinTones: [.medium])
-        } else if rawValue == "🧑🏾‍🏫" {
-            self.init(baseEmoji: .teacher, skinTones: [.mediumDark])
-        } else if rawValue == "🧑🏿‍🏫" {
-            self.init(baseEmoji: .teacher, skinTones: [.dark])
-        } else if rawValue == "👨‍🏫" {
-            self.init(baseEmoji: .maleTeacher, skinTones: nil)
-        } else if rawValue == "👨🏻‍🏫" {
-            self.init(baseEmoji: .maleTeacher, skinTones: [.light])
-        } else if rawValue == "👨🏼‍🏫" {
-            self.init(baseEmoji: .maleTeacher, skinTones: [.mediumLight])
-        } else if rawValue == "👨🏽‍🏫" {
-            self.init(baseEmoji: .maleTeacher, skinTones: [.medium])
-        } else if rawValue == "👨🏾‍🏫" {
-            self.init(baseEmoji: .maleTeacher, skinTones: [.mediumDark])
-        } else if rawValue == "👨🏿‍🏫" {
-            self.init(baseEmoji: .maleTeacher, skinTones: [.dark])
-        } else if rawValue == "👩‍🏫" {
-            self.init(baseEmoji: .femaleTeacher, skinTones: nil)
-        } else if rawValue == "👩🏻‍🏫" {
-            self.init(baseEmoji: .femaleTeacher, skinTones: [.light])
-        } else if rawValue == "👩🏼‍🏫" {
-            self.init(baseEmoji: .femaleTeacher, skinTones: [.mediumLight])
-        } else if rawValue == "👩🏽‍🏫" {
-            self.init(baseEmoji: .femaleTeacher, skinTones: [.medium])
-        } else if rawValue == "👩🏾‍🏫" {
-            self.init(baseEmoji: .femaleTeacher, skinTones: [.mediumDark])
-        } else if rawValue == "👩🏿‍🏫" {
-            self.init(baseEmoji: .femaleTeacher, skinTones: [.dark])
-        } else if rawValue == "🧑‍⚖️" {
-            self.init(baseEmoji: .judge, skinTones: nil)
-        } else if rawValue == "🧑🏻‍⚖️" {
-            self.init(baseEmoji: .judge, skinTones: [.light])
-        } else if rawValue == "🧑🏼‍⚖️" {
-            self.init(baseEmoji: .judge, skinTones: [.mediumLight])
-        } else if rawValue == "🧑🏽‍⚖️" {
-            self.init(baseEmoji: .judge, skinTones: [.medium])
-        } else if rawValue == "🧑🏾‍⚖️" {
-            self.init(baseEmoji: .judge, skinTones: [.mediumDark])
-        } else if rawValue == "🧑🏿‍⚖️" {
-            self.init(baseEmoji: .judge, skinTones: [.dark])
-        } else if rawValue == "👨‍⚖️" {
-            self.init(baseEmoji: .maleJudge, skinTones: nil)
-        } else if rawValue == "👨🏻‍⚖️" {
-            self.init(baseEmoji: .maleJudge, skinTones: [.light])
-        } else if rawValue == "👨🏼‍⚖️" {
-            self.init(baseEmoji: .maleJudge, skinTones: [.mediumLight])
-        } else if rawValue == "👨🏽‍⚖️" {
-            self.init(baseEmoji: .maleJudge, skinTones: [.medium])
-        } else if rawValue == "👨🏾‍⚖️" {
-            self.init(baseEmoji: .maleJudge, skinTones: [.mediumDark])
-        } else if rawValue == "👨🏿‍⚖️" {
-            self.init(baseEmoji: .maleJudge, skinTones: [.dark])
-        } else if rawValue == "👩‍⚖️" {
-            self.init(baseEmoji: .femaleJudge, skinTones: nil)
-        } else if rawValue == "👩🏻‍⚖️" {
-            self.init(baseEmoji: .femaleJudge, skinTones: [.light])
-        } else if rawValue == "👩🏼‍⚖️" {
-            self.init(baseEmoji: .femaleJudge, skinTones: [.mediumLight])
-        } else if rawValue == "👩🏽‍⚖️" {
-            self.init(baseEmoji: .femaleJudge, skinTones: [.medium])
-        } else if rawValue == "👩🏾‍⚖️" {
-            self.init(baseEmoji: .femaleJudge, skinTones: [.mediumDark])
-        } else if rawValue == "👩🏿‍⚖️" {
-            self.init(baseEmoji: .femaleJudge, skinTones: [.dark])
-        } else if rawValue == "🧑‍🌾" {
-            self.init(baseEmoji: .farmer, skinTones: nil)
-        } else if rawValue == "🧑🏻‍🌾" {
-            self.init(baseEmoji: .farmer, skinTones: [.light])
-        } else if rawValue == "🧑🏼‍🌾" {
-            self.init(baseEmoji: .farmer, skinTones: [.mediumLight])
-        } else if rawValue == "🧑🏽‍🌾" {
-            self.init(baseEmoji: .farmer, skinTones: [.medium])
-        } else if rawValue == "🧑🏾‍🌾" {
-            self.init(baseEmoji: .farmer, skinTones: [.mediumDark])
-        } else if rawValue == "🧑🏿‍🌾" {
-            self.init(baseEmoji: .farmer, skinTones: [.dark])
-        } else if rawValue == "👨‍🌾" {
-            self.init(baseEmoji: .maleFarmer, skinTones: nil)
-        } else if rawValue == "👨🏻‍🌾" {
-            self.init(baseEmoji: .maleFarmer, skinTones: [.light])
-        } else if rawValue == "👨🏼‍🌾" {
-            self.init(baseEmoji: .maleFarmer, skinTones: [.mediumLight])
-        } else if rawValue == "👨🏽‍🌾" {
-            self.init(baseEmoji: .maleFarmer, skinTones: [.medium])
-        } else if rawValue == "👨🏾‍🌾" {
-            self.init(baseEmoji: .maleFarmer, skinTones: [.mediumDark])
-        } else if rawValue == "👨🏿‍🌾" {
-            self.init(baseEmoji: .maleFarmer, skinTones: [.dark])
-        } else if rawValue == "👩‍🌾" {
-            self.init(baseEmoji: .femaleFarmer, skinTones: nil)
-        } else if rawValue == "👩🏻‍🌾" {
-            self.init(baseEmoji: .femaleFarmer, skinTones: [.light])
-        } else if rawValue == "👩🏼‍🌾" {
-            self.init(baseEmoji: .femaleFarmer, skinTones: [.mediumLight])
-        } else if rawValue == "👩🏽‍🌾" {
-            self.init(baseEmoji: .femaleFarmer, skinTones: [.medium])
-        } else if rawValue == "👩🏾‍🌾" {
-            self.init(baseEmoji: .femaleFarmer, skinTones: [.mediumDark])
-        } else if rawValue == "👩🏿‍🌾" {
-            self.init(baseEmoji: .femaleFarmer, skinTones: [.dark])
-        } else if rawValue == "🧑‍🍳" {
-            self.init(baseEmoji: .cook, skinTones: nil)
-        } else if rawValue == "🧑🏻‍🍳" {
-            self.init(baseEmoji: .cook, skinTones: [.light])
-        } else if rawValue == "🧑🏼‍🍳" {
-            self.init(baseEmoji: .cook, skinTones: [.mediumLight])
-        } else if rawValue == "🧑🏽‍🍳" {
-            self.init(baseEmoji: .cook, skinTones: [.medium])
-        } else if rawValue == "🧑🏾‍🍳" {
-            self.init(baseEmoji: .cook, skinTones: [.mediumDark])
-        } else if rawValue == "🧑🏿‍🍳" {
-            self.init(baseEmoji: .cook, skinTones: [.dark])
-        } else if rawValue == "👨‍🍳" {
-            self.init(baseEmoji: .maleCook, skinTones: nil)
-        } else if rawValue == "👨🏻‍🍳" {
-            self.init(baseEmoji: .maleCook, skinTones: [.light])
-        } else if rawValue == "👨🏼‍🍳" {
-            self.init(baseEmoji: .maleCook, skinTones: [.mediumLight])
-        } else if rawValue == "👨🏽‍🍳" {
-            self.init(baseEmoji: .maleCook, skinTones: [.medium])
-        } else if rawValue == "👨🏾‍🍳" {
-            self.init(baseEmoji: .maleCook, skinTones: [.mediumDark])
-        } else if rawValue == "👨🏿‍🍳" {
-            self.init(baseEmoji: .maleCook, skinTones: [.dark])
-        } else if rawValue == "👩‍🍳" {
-            self.init(baseEmoji: .femaleCook, skinTones: nil)
-        } else if rawValue == "👩🏻‍🍳" {
-            self.init(baseEmoji: .femaleCook, skinTones: [.light])
-        } else if rawValue == "👩🏼‍🍳" {
-            self.init(baseEmoji: .femaleCook, skinTones: [.mediumLight])
-        } else if rawValue == "👩🏽‍🍳" {
-            self.init(baseEmoji: .femaleCook, skinTones: [.medium])
-        } else if rawValue == "👩🏾‍🍳" {
-            self.init(baseEmoji: .femaleCook, skinTones: [.mediumDark])
-        } else if rawValue == "👩🏿‍🍳" {
-            self.init(baseEmoji: .femaleCook, skinTones: [.dark])
-        } else if rawValue == "🧑‍🔧" {
-            self.init(baseEmoji: .mechanic, skinTones: nil)
-        } else if rawValue == "🧑🏻‍🔧" {
-            self.init(baseEmoji: .mechanic, skinTones: [.light])
-        } else if rawValue == "🧑🏼‍🔧" {
-            self.init(baseEmoji: .mechanic, skinTones: [.mediumLight])
-        } else if rawValue == "🧑🏽‍🔧" {
-            self.init(baseEmoji: .mechanic, skinTones: [.medium])
-        } else if rawValue == "🧑🏾‍🔧" {
-            self.init(baseEmoji: .mechanic, skinTones: [.mediumDark])
-        } else if rawValue == "🧑🏿‍🔧" {
-            self.init(baseEmoji: .mechanic, skinTones: [.dark])
-        } else if rawValue == "👨‍🔧" {
-            self.init(baseEmoji: .maleMechanic, skinTones: nil)
-        } else if rawValue == "👨🏻‍🔧" {
-            self.init(baseEmoji: .maleMechanic, skinTones: [.light])
-        } else if rawValue == "👨🏼‍🔧" {
-            self.init(baseEmoji: .maleMechanic, skinTones: [.mediumLight])
-        } else if rawValue == "👨🏽‍🔧" {
-            self.init(baseEmoji: .maleMechanic, skinTones: [.medium])
-        } else if rawValue == "👨🏾‍🔧" {
-            self.init(baseEmoji: .maleMechanic, skinTones: [.mediumDark])
-        } else if rawValue == "👨🏿‍🔧" {
-            self.init(baseEmoji: .maleMechanic, skinTones: [.dark])
-        } else if rawValue == "👩‍🔧" {
-            self.init(baseEmoji: .femaleMechanic, skinTones: nil)
-        } else if rawValue == "👩🏻‍🔧" {
-            self.init(baseEmoji: .femaleMechanic, skinTones: [.light])
-        } else if rawValue == "👩🏼‍🔧" {
-            self.init(baseEmoji: .femaleMechanic, skinTones: [.mediumLight])
-        } else if rawValue == "👩🏽‍🔧" {
-            self.init(baseEmoji: .femaleMechanic, skinTones: [.medium])
-        } else if rawValue == "👩🏾‍🔧" {
-            self.init(baseEmoji: .femaleMechanic, skinTones: [.mediumDark])
-        } else if rawValue == "👩🏿‍🔧" {
-            self.init(baseEmoji: .femaleMechanic, skinTones: [.dark])
-        } else if rawValue == "🧑‍🏭" {
-            self.init(baseEmoji: .factoryWorker, skinTones: nil)
-        } else if rawValue == "🧑🏻‍🏭" {
-            self.init(baseEmoji: .factoryWorker, skinTones: [.light])
-        } else if rawValue == "🧑🏼‍🏭" {
-            self.init(baseEmoji: .factoryWorker, skinTones: [.mediumLight])
-        } else if rawValue == "🧑🏽‍🏭" {
-            self.init(baseEmoji: .factoryWorker, skinTones: [.medium])
-        } else if rawValue == "🧑🏾‍🏭" {
-            self.init(baseEmoji: .factoryWorker, skinTones: [.mediumDark])
-        } else if rawValue == "🧑🏿‍🏭" {
-            self.init(baseEmoji: .factoryWorker, skinTones: [.dark])
-        } else if rawValue == "👨‍🏭" {
-            self.init(baseEmoji: .maleFactoryWorker, skinTones: nil)
-        } else if rawValue == "👨🏻‍🏭" {
-            self.init(baseEmoji: .maleFactoryWorker, skinTones: [.light])
-        } else if rawValue == "👨🏼‍🏭" {
-            self.init(baseEmoji: .maleFactoryWorker, skinTones: [.mediumLight])
-        } else if rawValue == "👨🏽‍🏭" {
-            self.init(baseEmoji: .maleFactoryWorker, skinTones: [.medium])
-        } else if rawValue == "👨🏾‍🏭" {
-            self.init(baseEmoji: .maleFactoryWorker, skinTones: [.mediumDark])
-        } else if rawValue == "👨🏿‍🏭" {
-            self.init(baseEmoji: .maleFactoryWorker, skinTones: [.dark])
-        } else if rawValue == "👩‍🏭" {
-            self.init(baseEmoji: .femaleFactoryWorker, skinTones: nil)
-        } else if rawValue == "👩🏻‍🏭" {
-            self.init(baseEmoji: .femaleFactoryWorker, skinTones: [.light])
-        } else if rawValue == "👩🏼‍🏭" {
-            self.init(baseEmoji: .femaleFactoryWorker, skinTones: [.mediumLight])
-        } else if rawValue == "👩🏽‍🏭" {
-            self.init(baseEmoji: .femaleFactoryWorker, skinTones: [.medium])
-        } else if rawValue == "👩🏾‍🏭" {
-            self.init(baseEmoji: .femaleFactoryWorker, skinTones: [.mediumDark])
-        } else if rawValue == "👩🏿‍🏭" {
-            self.init(baseEmoji: .femaleFactoryWorker, skinTones: [.dark])
-        } else if rawValue == "🧑‍💼" {
-            self.init(baseEmoji: .officeWorker, skinTones: nil)
-        } else if rawValue == "🧑🏻‍💼" {
-            self.init(baseEmoji: .officeWorker, skinTones: [.light])
-        } else if rawValue == "🧑🏼‍💼" {
-            self.init(baseEmoji: .officeWorker, skinTones: [.mediumLight])
-        } else if rawValue == "🧑🏽‍💼" {
-            self.init(baseEmoji: .officeWorker, skinTones: [.medium])
-        } else if rawValue == "🧑🏾‍💼" {
-            self.init(baseEmoji: .officeWorker, skinTones: [.mediumDark])
-        } else if rawValue == "🧑🏿‍💼" {
-            self.init(baseEmoji: .officeWorker, skinTones: [.dark])
-        } else if rawValue == "👨‍💼" {
-            self.init(baseEmoji: .maleOfficeWorker, skinTones: nil)
-        } else if rawValue == "👨🏻‍💼" {
-            self.init(baseEmoji: .maleOfficeWorker, skinTones: [.light])
-        } else if rawValue == "👨🏼‍💼" {
-            self.init(baseEmoji: .maleOfficeWorker, skinTones: [.mediumLight])
-        } else if rawValue == "👨🏽‍💼" {
-            self.init(baseEmoji: .maleOfficeWorker, skinTones: [.medium])
-        } else if rawValue == "👨🏾‍💼" {
-            self.init(baseEmoji: .maleOfficeWorker, skinTones: [.mediumDark])
-        } else if rawValue == "👨🏿‍💼" {
-            self.init(baseEmoji: .maleOfficeWorker, skinTones: [.dark])
-        } else if rawValue == "👩‍💼" {
-            self.init(baseEmoji: .femaleOfficeWorker, skinTones: nil)
-        } else if rawValue == "👩🏻‍💼" {
-            self.init(baseEmoji: .femaleOfficeWorker, skinTones: [.light])
-        } else if rawValue == "👩🏼‍💼" {
-            self.init(baseEmoji: .femaleOfficeWorker, skinTones: [.mediumLight])
-        } else if rawValue == "👩🏽‍💼" {
-            self.init(baseEmoji: .femaleOfficeWorker, skinTones: [.medium])
-        } else if rawValue == "👩🏾‍💼" {
-            self.init(baseEmoji: .femaleOfficeWorker, skinTones: [.mediumDark])
-        } else if rawValue == "👩🏿‍💼" {
-            self.init(baseEmoji: .femaleOfficeWorker, skinTones: [.dark])
-        } else if rawValue == "🧑‍🔬" {
-            self.init(baseEmoji: .scientist, skinTones: nil)
-        } else if rawValue == "🧑🏻‍🔬" {
-            self.init(baseEmoji: .scientist, skinTones: [.light])
-        } else if rawValue == "🧑🏼‍🔬" {
-            self.init(baseEmoji: .scientist, skinTones: [.mediumLight])
-        } else if rawValue == "🧑🏽‍🔬" {
-            self.init(baseEmoji: .scientist, skinTones: [.medium])
-        } else if rawValue == "🧑🏾‍🔬" {
-            self.init(baseEmoji: .scientist, skinTones: [.mediumDark])
-        } else if rawValue == "🧑🏿‍🔬" {
-            self.init(baseEmoji: .scientist, skinTones: [.dark])
-        } else if rawValue == "👨‍🔬" {
-            self.init(baseEmoji: .maleScientist, skinTones: nil)
-        } else if rawValue == "👨🏻‍🔬" {
-            self.init(baseEmoji: .maleScientist, skinTones: [.light])
-        } else if rawValue == "👨🏼‍🔬" {
-            self.init(baseEmoji: .maleScientist, skinTones: [.mediumLight])
-        } else if rawValue == "👨🏽‍🔬" {
-            self.init(baseEmoji: .maleScientist, skinTones: [.medium])
-        } else if rawValue == "👨🏾‍🔬" {
-            self.init(baseEmoji: .maleScientist, skinTones: [.mediumDark])
-        } else if rawValue == "👨🏿‍🔬" {
-            self.init(baseEmoji: .maleScientist, skinTones: [.dark])
-        } else if rawValue == "👩‍🔬" {
-            self.init(baseEmoji: .femaleScientist, skinTones: nil)
-        } else if rawValue == "👩🏻‍🔬" {
-            self.init(baseEmoji: .femaleScientist, skinTones: [.light])
-        } else if rawValue == "👩🏼‍🔬" {
-            self.init(baseEmoji: .femaleScientist, skinTones: [.mediumLight])
-        } else if rawValue == "👩🏽‍🔬" {
-            self.init(baseEmoji: .femaleScientist, skinTones: [.medium])
-        } else if rawValue == "👩🏾‍🔬" {
-            self.init(baseEmoji: .femaleScientist, skinTones: [.mediumDark])
-        } else if rawValue == "👩🏿‍🔬" {
-            self.init(baseEmoji: .femaleScientist, skinTones: [.dark])
-        } else if rawValue == "🧑‍💻" {
-            self.init(baseEmoji: .technologist, skinTones: nil)
-        } else if rawValue == "🧑🏻‍💻" {
-            self.init(baseEmoji: .technologist, skinTones: [.light])
-        } else if rawValue == "🧑🏼‍💻" {
-            self.init(baseEmoji: .technologist, skinTones: [.mediumLight])
-        } else if rawValue == "🧑🏽‍💻" {
-            self.init(baseEmoji: .technologist, skinTones: [.medium])
-        } else if rawValue == "🧑🏾‍💻" {
-            self.init(baseEmoji: .technologist, skinTones: [.mediumDark])
-        } else if rawValue == "🧑🏿‍💻" {
-            self.init(baseEmoji: .technologist, skinTones: [.dark])
-        } else if rawValue == "👨‍💻" {
-            self.init(baseEmoji: .maleTechnologist, skinTones: nil)
-        } else if rawValue == "👨🏻‍💻" {
-            self.init(baseEmoji: .maleTechnologist, skinTones: [.light])
-        } else if rawValue == "👨🏼‍💻" {
-            self.init(baseEmoji: .maleTechnologist, skinTones: [.mediumLight])
-        } else if rawValue == "👨🏽‍💻" {
-            self.init(baseEmoji: .maleTechnologist, skinTones: [.medium])
-        } else if rawValue == "👨🏾‍💻" {
-            self.init(baseEmoji: .maleTechnologist, skinTones: [.mediumDark])
-        } else if rawValue == "👨🏿‍💻" {
-            self.init(baseEmoji: .maleTechnologist, skinTones: [.dark])
-        } else if rawValue == "👩‍💻" {
-            self.init(baseEmoji: .femaleTechnologist, skinTones: nil)
-        } else if rawValue == "👩🏻‍💻" {
-            self.init(baseEmoji: .femaleTechnologist, skinTones: [.light])
-        } else if rawValue == "👩🏼‍💻" {
-            self.init(baseEmoji: .femaleTechnologist, skinTones: [.mediumLight])
-        } else if rawValue == "👩🏽‍💻" {
-            self.init(baseEmoji: .femaleTechnologist, skinTones: [.medium])
-        } else if rawValue == "👩🏾‍💻" {
-            self.init(baseEmoji: .femaleTechnologist, skinTones: [.mediumDark])
-        } else if rawValue == "👩🏿‍💻" {
-            self.init(baseEmoji: .femaleTechnologist, skinTones: [.dark])
-        } else if rawValue == "🧑‍🎤" {
-            self.init(baseEmoji: .singer, skinTones: nil)
-        } else if rawValue == "🧑🏻‍🎤" {
-            self.init(baseEmoji: .singer, skinTones: [.light])
-        } else if rawValue == "🧑🏼‍🎤" {
-            self.init(baseEmoji: .singer, skinTones: [.mediumLight])
-        } else if rawValue == "🧑🏽‍🎤" {
-            self.init(baseEmoji: .singer, skinTones: [.medium])
-        } else if rawValue == "🧑🏾‍🎤" {
-            self.init(baseEmoji: .singer, skinTones: [.mediumDark])
-        } else if rawValue == "🧑🏿‍🎤" {
-            self.init(baseEmoji: .singer, skinTones: [.dark])
-        } else if rawValue == "👨‍🎤" {
-            self.init(baseEmoji: .maleSinger, skinTones: nil)
-        } else if rawValue == "👨🏻‍🎤" {
-            self.init(baseEmoji: .maleSinger, skinTones: [.light])
-        } else if rawValue == "👨🏼‍🎤" {
-            self.init(baseEmoji: .maleSinger, skinTones: [.mediumLight])
-        } else if rawValue == "👨🏽‍🎤" {
-            self.init(baseEmoji: .maleSinger, skinTones: [.medium])
-        } else if rawValue == "👨🏾‍🎤" {
-            self.init(baseEmoji: .maleSinger, skinTones: [.mediumDark])
-        } else if rawValue == "👨🏿‍🎤" {
-            self.init(baseEmoji: .maleSinger, skinTones: [.dark])
-        } else if rawValue == "👩‍🎤" {
-            self.init(baseEmoji: .femaleSinger, skinTones: nil)
-        } else if rawValue == "👩🏻‍🎤" {
-            self.init(baseEmoji: .femaleSinger, skinTones: [.light])
-        } else if rawValue == "👩🏼‍🎤" {
-            self.init(baseEmoji: .femaleSinger, skinTones: [.mediumLight])
-        } else if rawValue == "👩🏽‍🎤" {
-            self.init(baseEmoji: .femaleSinger, skinTones: [.medium])
-        } else if rawValue == "👩🏾‍🎤" {
-            self.init(baseEmoji: .femaleSinger, skinTones: [.mediumDark])
-        } else if rawValue == "👩🏿‍🎤" {
-            self.init(baseEmoji: .femaleSinger, skinTones: [.dark])
-        } else if rawValue == "🧑‍🎨" {
-            self.init(baseEmoji: .artist, skinTones: nil)
-        } else if rawValue == "🧑🏻‍🎨" {
-            self.init(baseEmoji: .artist, skinTones: [.light])
-        } else if rawValue == "🧑🏼‍🎨" {
-            self.init(baseEmoji: .artist, skinTones: [.mediumLight])
-        } else if rawValue == "🧑🏽‍🎨" {
-            self.init(baseEmoji: .artist, skinTones: [.medium])
-        } else if rawValue == "🧑🏾‍🎨" {
-            self.init(baseEmoji: .artist, skinTones: [.mediumDark])
-        } else if rawValue == "🧑🏿‍🎨" {
-            self.init(baseEmoji: .artist, skinTones: [.dark])
-        } else if rawValue == "👨‍🎨" {
-            self.init(baseEmoji: .maleArtist, skinTones: nil)
-        } else if rawValue == "👨🏻‍🎨" {
-            self.init(baseEmoji: .maleArtist, skinTones: [.light])
-        } else if rawValue == "👨🏼‍🎨" {
-            self.init(baseEmoji: .maleArtist, skinTones: [.mediumLight])
-        } else if rawValue == "👨🏽‍🎨" {
-            self.init(baseEmoji: .maleArtist, skinTones: [.medium])
-        } else if rawValue == "👨🏾‍🎨" {
-            self.init(baseEmoji: .maleArtist, skinTones: [.mediumDark])
-        } else if rawValue == "👨🏿‍🎨" {
-            self.init(baseEmoji: .maleArtist, skinTones: [.dark])
-        } else if rawValue == "👩‍🎨" {
-            self.init(baseEmoji: .femaleArtist, skinTones: nil)
-        } else if rawValue == "👩🏻‍🎨" {
-            self.init(baseEmoji: .femaleArtist, skinTones: [.light])
-        } else if rawValue == "👩🏼‍🎨" {
-            self.init(baseEmoji: .femaleArtist, skinTones: [.mediumLight])
-        } else if rawValue == "👩🏽‍🎨" {
-            self.init(baseEmoji: .femaleArtist, skinTones: [.medium])
-        } else if rawValue == "👩🏾‍🎨" {
-            self.init(baseEmoji: .femaleArtist, skinTones: [.mediumDark])
-        } else if rawValue == "👩🏿‍🎨" {
-            self.init(baseEmoji: .femaleArtist, skinTones: [.dark])
-        } else if rawValue == "🧑‍✈️" {
-            self.init(baseEmoji: .pilot, skinTones: nil)
-        } else if rawValue == "🧑🏻‍✈️" {
-            self.init(baseEmoji: .pilot, skinTones: [.light])
-        } else if rawValue == "🧑🏼‍✈️" {
-            self.init(baseEmoji: .pilot, skinTones: [.mediumLight])
-        } else if rawValue == "🧑🏽‍✈️" {
-            self.init(baseEmoji: .pilot, skinTones: [.medium])
-        } else if rawValue == "🧑🏾‍✈️" {
-            self.init(baseEmoji: .pilot, skinTones: [.mediumDark])
-        } else if rawValue == "🧑🏿‍✈️" {
-            self.init(baseEmoji: .pilot, skinTones: [.dark])
-        } else if rawValue == "👨‍✈️" {
-            self.init(baseEmoji: .malePilot, skinTones: nil)
-        } else if rawValue == "👨🏻‍✈️" {
-            self.init(baseEmoji: .malePilot, skinTones: [.light])
-        } else if rawValue == "👨🏼‍✈️" {
-            self.init(baseEmoji: .malePilot, skinTones: [.mediumLight])
-        } else if rawValue == "👨🏽‍✈️" {
-            self.init(baseEmoji: .malePilot, skinTones: [.medium])
-        } else if rawValue == "👨🏾‍✈️" {
-            self.init(baseEmoji: .malePilot, skinTones: [.mediumDark])
-        } else if rawValue == "👨🏿‍✈️" {
-            self.init(baseEmoji: .malePilot, skinTones: [.dark])
-        } else if rawValue == "👩‍✈️" {
-            self.init(baseEmoji: .femalePilot, skinTones: nil)
-        } else if rawValue == "👩🏻‍✈️" {
-            self.init(baseEmoji: .femalePilot, skinTones: [.light])
-        } else if rawValue == "👩🏼‍✈️" {
-            self.init(baseEmoji: .femalePilot, skinTones: [.mediumLight])
-        } else if rawValue == "👩🏽‍✈️" {
-            self.init(baseEmoji: .femalePilot, skinTones: [.medium])
-        } else if rawValue == "👩🏾‍✈️" {
-            self.init(baseEmoji: .femalePilot, skinTones: [.mediumDark])
-        } else if rawValue == "👩🏿‍✈️" {
-            self.init(baseEmoji: .femalePilot, skinTones: [.dark])
-        } else if rawValue == "🧑‍🚀" {
-            self.init(baseEmoji: .astronaut, skinTones: nil)
-        } else if rawValue == "🧑🏻‍🚀" {
-            self.init(baseEmoji: .astronaut, skinTones: [.light])
-        } else if rawValue == "🧑🏼‍🚀" {
-            self.init(baseEmoji: .astronaut, skinTones: [.mediumLight])
-        } else if rawValue == "🧑🏽‍🚀" {
-            self.init(baseEmoji: .astronaut, skinTones: [.medium])
-        } else if rawValue == "🧑🏾‍🚀" {
-            self.init(baseEmoji: .astronaut, skinTones: [.mediumDark])
-        } else if rawValue == "🧑🏿‍🚀" {
-            self.init(baseEmoji: .astronaut, skinTones: [.dark])
-        } else if rawValue == "👨‍🚀" {
-            self.init(baseEmoji: .maleAstronaut, skinTones: nil)
-        } else if rawValue == "👨🏻‍🚀" {
-            self.init(baseEmoji: .maleAstronaut, skinTones: [.light])
-        } else if rawValue == "👨🏼‍🚀" {
-            self.init(baseEmoji: .maleAstronaut, skinTones: [.mediumLight])
-        } else if rawValue == "👨🏽‍🚀" {
-            self.init(baseEmoji: .maleAstronaut, skinTones: [.medium])
-        } else if rawValue == "👨🏾‍🚀" {
-            self.init(baseEmoji: .maleAstronaut, skinTones: [.mediumDark])
-        } else if rawValue == "👨🏿‍🚀" {
-            self.init(baseEmoji: .maleAstronaut, skinTones: [.dark])
-        } else if rawValue == "👩‍🚀" {
-            self.init(baseEmoji: .femaleAstronaut, skinTones: nil)
-        } else if rawValue == "👩🏻‍🚀" {
-            self.init(baseEmoji: .femaleAstronaut, skinTones: [.light])
-        } else if rawValue == "👩🏼‍🚀" {
-            self.init(baseEmoji: .femaleAstronaut, skinTones: [.mediumLight])
-        } else if rawValue == "👩🏽‍🚀" {
-            self.init(baseEmoji: .femaleAstronaut, skinTones: [.medium])
-        } else if rawValue == "👩🏾‍🚀" {
-            self.init(baseEmoji: .femaleAstronaut, skinTones: [.mediumDark])
-        } else if rawValue == "👩🏿‍🚀" {
-            self.init(baseEmoji: .femaleAstronaut, skinTones: [.dark])
-        } else if rawValue == "🧑‍🚒" {
-            self.init(baseEmoji: .firefighter, skinTones: nil)
-        } else if rawValue == "🧑🏻‍🚒" {
-            self.init(baseEmoji: .firefighter, skinTones: [.light])
-        } else if rawValue == "🧑🏼‍🚒" {
-            self.init(baseEmoji: .firefighter, skinTones: [.mediumLight])
-        } else if rawValue == "🧑🏽‍🚒" {
-            self.init(baseEmoji: .firefighter, skinTones: [.medium])
-        } else if rawValue == "🧑🏾‍🚒" {
-            self.init(baseEmoji: .firefighter, skinTones: [.mediumDark])
-        } else if rawValue == "🧑🏿‍🚒" {
-            self.init(baseEmoji: .firefighter, skinTones: [.dark])
-        } else if rawValue == "👨‍🚒" {
-            self.init(baseEmoji: .maleFirefighter, skinTones: nil)
-        } else if rawValue == "👨🏻‍🚒" {
-            self.init(baseEmoji: .maleFirefighter, skinTones: [.light])
-        } else if rawValue == "👨🏼‍🚒" {
-            self.init(baseEmoji: .maleFirefighter, skinTones: [.mediumLight])
-        } else if rawValue == "👨🏽‍🚒" {
-            self.init(baseEmoji: .maleFirefighter, skinTones: [.medium])
-        } else if rawValue == "👨🏾‍🚒" {
-            self.init(baseEmoji: .maleFirefighter, skinTones: [.mediumDark])
-        } else if rawValue == "👨🏿‍🚒" {
-            self.init(baseEmoji: .maleFirefighter, skinTones: [.dark])
-        } else if rawValue == "👩‍🚒" {
-            self.init(baseEmoji: .femaleFirefighter, skinTones: nil)
-        } else if rawValue == "👩🏻‍🚒" {
-            self.init(baseEmoji: .femaleFirefighter, skinTones: [.light])
-        } else if rawValue == "👩🏼‍🚒" {
-            self.init(baseEmoji: .femaleFirefighter, skinTones: [.mediumLight])
-        } else if rawValue == "👩🏽‍🚒" {
-            self.init(baseEmoji: .femaleFirefighter, skinTones: [.medium])
-        } else if rawValue == "👩🏾‍🚒" {
-            self.init(baseEmoji: .femaleFirefighter, skinTones: [.mediumDark])
-        } else if rawValue == "👩🏿‍🚒" {
-            self.init(baseEmoji: .femaleFirefighter, skinTones: [.dark])
-        } else if rawValue == "👮" {
-            self.init(baseEmoji: .cop, skinTones: nil)
-        } else if rawValue == "👮🏻" {
-            self.init(baseEmoji: .cop, skinTones: [.light])
-        } else if rawValue == "👮🏼" {
-            self.init(baseEmoji: .cop, skinTones: [.mediumLight])
-        } else if rawValue == "👮🏽" {
-            self.init(baseEmoji: .cop, skinTones: [.medium])
-        } else if rawValue == "👮🏾" {
-            self.init(baseEmoji: .cop, skinTones: [.mediumDark])
-        } else if rawValue == "👮🏿" {
-            self.init(baseEmoji: .cop, skinTones: [.dark])
-        } else if rawValue == "👮‍♂️" {
-            self.init(baseEmoji: .malePoliceOfficer, skinTones: nil)
-        } else if rawValue == "👮🏻‍♂️" {
-            self.init(baseEmoji: .malePoliceOfficer, skinTones: [.light])
-        } else if rawValue == "👮🏼‍♂️" {
-            self.init(baseEmoji: .malePoliceOfficer, skinTones: [.mediumLight])
-        } else if rawValue == "👮🏽‍♂️" {
-            self.init(baseEmoji: .malePoliceOfficer, skinTones: [.medium])
-        } else if rawValue == "👮🏾‍♂️" {
-            self.init(baseEmoji: .malePoliceOfficer, skinTones: [.mediumDark])
-        } else if rawValue == "👮🏿‍♂️" {
-            self.init(baseEmoji: .malePoliceOfficer, skinTones: [.dark])
-        } else if rawValue == "👮‍♀️" {
-            self.init(baseEmoji: .femalePoliceOfficer, skinTones: nil)
-        } else if rawValue == "👮🏻‍♀️" {
-            self.init(baseEmoji: .femalePoliceOfficer, skinTones: [.light])
-        } else if rawValue == "👮🏼‍♀️" {
-            self.init(baseEmoji: .femalePoliceOfficer, skinTones: [.mediumLight])
-        } else if rawValue == "👮🏽‍♀️" {
-            self.init(baseEmoji: .femalePoliceOfficer, skinTones: [.medium])
-        } else if rawValue == "👮🏾‍♀️" {
-            self.init(baseEmoji: .femalePoliceOfficer, skinTones: [.mediumDark])
-        } else if rawValue == "👮🏿‍♀️" {
-            self.init(baseEmoji: .femalePoliceOfficer, skinTones: [.dark])
-        } else if rawValue == "🕵️" {
-            self.init(baseEmoji: .sleuthOrSpy, skinTones: nil)
-        } else if rawValue == "🕵🏻" {
-            self.init(baseEmoji: .sleuthOrSpy, skinTones: [.light])
-        } else if rawValue == "🕵🏼" {
-            self.init(baseEmoji: .sleuthOrSpy, skinTones: [.mediumLight])
-        } else if rawValue == "🕵🏽" {
-            self.init(baseEmoji: .sleuthOrSpy, skinTones: [.medium])
-        } else if rawValue == "🕵🏾" {
-            self.init(baseEmoji: .sleuthOrSpy, skinTones: [.mediumDark])
-        } else if rawValue == "🕵🏿" {
-            self.init(baseEmoji: .sleuthOrSpy, skinTones: [.dark])
-        } else if rawValue == "🕵️‍♂️" {
-            self.init(baseEmoji: .maleDetective, skinTones: nil)
-        } else if rawValue == "🕵🏻‍♂️" {
-            self.init(baseEmoji: .maleDetective, skinTones: [.light])
-        } else if rawValue == "🕵🏼‍♂️" {
-            self.init(baseEmoji: .maleDetective, skinTones: [.mediumLight])
-        } else if rawValue == "🕵🏽‍♂️" {
-            self.init(baseEmoji: .maleDetective, skinTones: [.medium])
-        } else if rawValue == "🕵🏾‍♂️" {
-            self.init(baseEmoji: .maleDetective, skinTones: [.mediumDark])
-        } else if rawValue == "🕵🏿‍♂️" {
-            self.init(baseEmoji: .maleDetective, skinTones: [.dark])
-        } else if rawValue == "🕵️‍♀️" {
-            self.init(baseEmoji: .femaleDetective, skinTones: nil)
-        } else if rawValue == "🕵🏻‍♀️" {
-            self.init(baseEmoji: .femaleDetective, skinTones: [.light])
-        } else if rawValue == "🕵🏼‍♀️" {
-            self.init(baseEmoji: .femaleDetective, skinTones: [.mediumLight])
-        } else if rawValue == "🕵🏽‍♀️" {
-            self.init(baseEmoji: .femaleDetective, skinTones: [.medium])
-        } else if rawValue == "🕵🏾‍♀️" {
-            self.init(baseEmoji: .femaleDetective, skinTones: [.mediumDark])
-        } else if rawValue == "🕵🏿‍♀️" {
-            self.init(baseEmoji: .femaleDetective, skinTones: [.dark])
-        } else if rawValue == "💂" {
-            self.init(baseEmoji: .guardsman, skinTones: nil)
-        } else if rawValue == "💂🏻" {
-            self.init(baseEmoji: .guardsman, skinTones: [.light])
-        } else if rawValue == "💂🏼" {
-            self.init(baseEmoji: .guardsman, skinTones: [.mediumLight])
-        } else if rawValue == "💂🏽" {
-            self.init(baseEmoji: .guardsman, skinTones: [.medium])
-        } else if rawValue == "💂🏾" {
-            self.init(baseEmoji: .guardsman, skinTones: [.mediumDark])
-        } else if rawValue == "💂🏿" {
-            self.init(baseEmoji: .guardsman, skinTones: [.dark])
-        } else if rawValue == "💂‍♂️" {
-            self.init(baseEmoji: .maleGuard, skinTones: nil)
-        } else if rawValue == "💂🏻‍♂️" {
-            self.init(baseEmoji: .maleGuard, skinTones: [.light])
-        } else if rawValue == "💂🏼‍♂️" {
-            self.init(baseEmoji: .maleGuard, skinTones: [.mediumLight])
-        } else if rawValue == "💂🏽‍♂️" {
-            self.init(baseEmoji: .maleGuard, skinTones: [.medium])
-        } else if rawValue == "💂🏾‍♂️" {
-            self.init(baseEmoji: .maleGuard, skinTones: [.mediumDark])
-        } else if rawValue == "💂🏿‍♂️" {
-            self.init(baseEmoji: .maleGuard, skinTones: [.dark])
-        } else if rawValue == "💂‍♀️" {
-            self.init(baseEmoji: .femaleGuard, skinTones: nil)
-        } else if rawValue == "💂🏻‍♀️" {
-            self.init(baseEmoji: .femaleGuard, skinTones: [.light])
-        } else if rawValue == "💂🏼‍♀️" {
-            self.init(baseEmoji: .femaleGuard, skinTones: [.mediumLight])
-        } else if rawValue == "💂🏽‍♀️" {
-            self.init(baseEmoji: .femaleGuard, skinTones: [.medium])
-        } else if rawValue == "💂🏾‍♀️" {
-            self.init(baseEmoji: .femaleGuard, skinTones: [.mediumDark])
-        } else if rawValue == "💂🏿‍♀️" {
-            self.init(baseEmoji: .femaleGuard, skinTones: [.dark])
-        } else if rawValue == "🥷" {
-            self.init(baseEmoji: .ninja, skinTones: nil)
-        } else if rawValue == "🥷🏻" {
-            self.init(baseEmoji: .ninja, skinTones: [.light])
-        } else if rawValue == "🥷🏼" {
-            self.init(baseEmoji: .ninja, skinTones: [.mediumLight])
-        } else if rawValue == "🥷🏽" {
-            self.init(baseEmoji: .ninja, skinTones: [.medium])
-        } else if rawValue == "🥷🏾" {
-            self.init(baseEmoji: .ninja, skinTones: [.mediumDark])
-        } else if rawValue == "🥷🏿" {
-            self.init(baseEmoji: .ninja, skinTones: [.dark])
-        } else if rawValue == "👷" {
-            self.init(baseEmoji: .constructionWorker, skinTones: nil)
-        } else if rawValue == "👷🏻" {
-            self.init(baseEmoji: .constructionWorker, skinTones: [.light])
-        } else if rawValue == "👷🏼" {
-            self.init(baseEmoji: .constructionWorker, skinTones: [.mediumLight])
-        } else if rawValue == "👷🏽" {
-            self.init(baseEmoji: .constructionWorker, skinTones: [.medium])
-        } else if rawValue == "👷🏾" {
-            self.init(baseEmoji: .constructionWorker, skinTones: [.mediumDark])
-        } else if rawValue == "👷🏿" {
-            self.init(baseEmoji: .constructionWorker, skinTones: [.dark])
-        } else if rawValue == "👷‍♂️" {
-            self.init(baseEmoji: .maleConstructionWorker, skinTones: nil)
-        } else if rawValue == "👷🏻‍♂️" {
-            self.init(baseEmoji: .maleConstructionWorker, skinTones: [.light])
-        } else if rawValue == "👷🏼‍♂️" {
-            self.init(baseEmoji: .maleConstructionWorker, skinTones: [.mediumLight])
-        } else if rawValue == "👷🏽‍♂️" {
-            self.init(baseEmoji: .maleConstructionWorker, skinTones: [.medium])
-        } else if rawValue == "👷🏾‍♂️" {
-            self.init(baseEmoji: .maleConstructionWorker, skinTones: [.mediumDark])
-        } else if rawValue == "👷🏿‍♂️" {
-            self.init(baseEmoji: .maleConstructionWorker, skinTones: [.dark])
-        } else if rawValue == "👷‍♀️" {
-            self.init(baseEmoji: .femaleConstructionWorker, skinTones: nil)
-        } else if rawValue == "👷🏻‍♀️" {
-            self.init(baseEmoji: .femaleConstructionWorker, skinTones: [.light])
-        } else if rawValue == "👷🏼‍♀️" {
-            self.init(baseEmoji: .femaleConstructionWorker, skinTones: [.mediumLight])
-        } else if rawValue == "👷🏽‍♀️" {
-            self.init(baseEmoji: .femaleConstructionWorker, skinTones: [.medium])
-        } else if rawValue == "👷🏾‍♀️" {
-            self.init(baseEmoji: .femaleConstructionWorker, skinTones: [.mediumDark])
-        } else if rawValue == "👷🏿‍♀️" {
-            self.init(baseEmoji: .femaleConstructionWorker, skinTones: [.dark])
-        } else if rawValue == "🫅" {
-            self.init(baseEmoji: .personWithCrown, skinTones: nil)
-        } else if rawValue == "🫅🏻" {
-            self.init(baseEmoji: .personWithCrown, skinTones: [.light])
-        } else if rawValue == "🫅🏼" {
-            self.init(baseEmoji: .personWithCrown, skinTones: [.mediumLight])
-        } else if rawValue == "🫅🏽" {
-            self.init(baseEmoji: .personWithCrown, skinTones: [.medium])
-        } else if rawValue == "🫅🏾" {
-            self.init(baseEmoji: .personWithCrown, skinTones: [.mediumDark])
-        } else if rawValue == "🫅🏿" {
-            self.init(baseEmoji: .personWithCrown, skinTones: [.dark])
-        } else if rawValue == "🤴" {
-            self.init(baseEmoji: .prince, skinTones: nil)
-        } else if rawValue == "🤴🏻" {
-            self.init(baseEmoji: .prince, skinTones: [.light])
-        } else if rawValue == "🤴🏼" {
-            self.init(baseEmoji: .prince, skinTones: [.mediumLight])
-        } else if rawValue == "🤴🏽" {
-            self.init(baseEmoji: .prince, skinTones: [.medium])
-        } else if rawValue == "🤴🏾" {
-            self.init(baseEmoji: .prince, skinTones: [.mediumDark])
-        } else if rawValue == "🤴🏿" {
-            self.init(baseEmoji: .prince, skinTones: [.dark])
-        } else if rawValue == "👸" {
-            self.init(baseEmoji: .princess, skinTones: nil)
-        } else if rawValue == "👸🏻" {
-            self.init(baseEmoji: .princess, skinTones: [.light])
-        } else if rawValue == "👸🏼" {
-            self.init(baseEmoji: .princess, skinTones: [.mediumLight])
-        } else if rawValue == "👸🏽" {
-            self.init(baseEmoji: .princess, skinTones: [.medium])
-        } else if rawValue == "👸🏾" {
-            self.init(baseEmoji: .princess, skinTones: [.mediumDark])
-        } else if rawValue == "👸🏿" {
-            self.init(baseEmoji: .princess, skinTones: [.dark])
-        } else if rawValue == "👳" {
-            self.init(baseEmoji: .manWithTurban, skinTones: nil)
-        } else if rawValue == "👳🏻" {
-            self.init(baseEmoji: .manWithTurban, skinTones: [.light])
-        } else if rawValue == "👳🏼" {
-            self.init(baseEmoji: .manWithTurban, skinTones: [.mediumLight])
-        } else if rawValue == "👳🏽" {
-            self.init(baseEmoji: .manWithTurban, skinTones: [.medium])
-        } else if rawValue == "👳🏾" {
-            self.init(baseEmoji: .manWithTurban, skinTones: [.mediumDark])
-        } else if rawValue == "👳🏿" {
-            self.init(baseEmoji: .manWithTurban, skinTones: [.dark])
-        } else if rawValue == "👳‍♂️" {
-            self.init(baseEmoji: .manWearingTurban, skinTones: nil)
-        } else if rawValue == "👳🏻‍♂️" {
-            self.init(baseEmoji: .manWearingTurban, skinTones: [.light])
-        } else if rawValue == "👳🏼‍♂️" {
-            self.init(baseEmoji: .manWearingTurban, skinTones: [.mediumLight])
-        } else if rawValue == "👳🏽‍♂️" {
-            self.init(baseEmoji: .manWearingTurban, skinTones: [.medium])
-        } else if rawValue == "👳🏾‍♂️" {
-            self.init(baseEmoji: .manWearingTurban, skinTones: [.mediumDark])
-        } else if rawValue == "👳🏿‍♂️" {
-            self.init(baseEmoji: .manWearingTurban, skinTones: [.dark])
-        } else if rawValue == "👳‍♀️" {
-            self.init(baseEmoji: .womanWearingTurban, skinTones: nil)
-        } else if rawValue == "👳🏻‍♀️" {
-            self.init(baseEmoji: .womanWearingTurban, skinTones: [.light])
-        } else if rawValue == "👳🏼‍♀️" {
-            self.init(baseEmoji: .womanWearingTurban, skinTones: [.mediumLight])
-        } else if rawValue == "👳🏽‍♀️" {
-            self.init(baseEmoji: .womanWearingTurban, skinTones: [.medium])
-        } else if rawValue == "👳🏾‍♀️" {
-            self.init(baseEmoji: .womanWearingTurban, skinTones: [.mediumDark])
-        } else if rawValue == "👳🏿‍♀️" {
-            self.init(baseEmoji: .womanWearingTurban, skinTones: [.dark])
-        } else if rawValue == "👲" {
-            self.init(baseEmoji: .manWithGuaPiMao, skinTones: nil)
-        } else if rawValue == "👲🏻" {
-            self.init(baseEmoji: .manWithGuaPiMao, skinTones: [.light])
-        } else if rawValue == "👲🏼" {
-            self.init(baseEmoji: .manWithGuaPiMao, skinTones: [.mediumLight])
-        } else if rawValue == "👲🏽" {
-            self.init(baseEmoji: .manWithGuaPiMao, skinTones: [.medium])
-        } else if rawValue == "👲🏾" {
-            self.init(baseEmoji: .manWithGuaPiMao, skinTones: [.mediumDark])
-        } else if rawValue == "👲🏿" {
-            self.init(baseEmoji: .manWithGuaPiMao, skinTones: [.dark])
-        } else if rawValue == "🧕" {
-            self.init(baseEmoji: .personWithHeadscarf, skinTones: nil)
-        } else if rawValue == "🧕🏻" {
-            self.init(baseEmoji: .personWithHeadscarf, skinTones: [.light])
-        } else if rawValue == "🧕🏼" {
-            self.init(baseEmoji: .personWithHeadscarf, skinTones: [.mediumLight])
-        } else if rawValue == "🧕🏽" {
-            self.init(baseEmoji: .personWithHeadscarf, skinTones: [.medium])
-        } else if rawValue == "🧕🏾" {
-            self.init(baseEmoji: .personWithHeadscarf, skinTones: [.mediumDark])
-        } else if rawValue == "🧕🏿" {
-            self.init(baseEmoji: .personWithHeadscarf, skinTones: [.dark])
-        } else if rawValue == "🤵" {
-            self.init(baseEmoji: .personInTuxedo, skinTones: nil)
-        } else if rawValue == "🤵🏻" {
-            self.init(baseEmoji: .personInTuxedo, skinTones: [.light])
-        } else if rawValue == "🤵🏼" {
-            self.init(baseEmoji: .personInTuxedo, skinTones: [.mediumLight])
-        } else if rawValue == "🤵🏽" {
-            self.init(baseEmoji: .personInTuxedo, skinTones: [.medium])
-        } else if rawValue == "🤵🏾" {
-            self.init(baseEmoji: .personInTuxedo, skinTones: [.mediumDark])
-        } else if rawValue == "🤵🏿" {
-            self.init(baseEmoji: .personInTuxedo, skinTones: [.dark])
-        } else if rawValue == "🤵‍♂️" {
-            self.init(baseEmoji: .manInTuxedo, skinTones: nil)
-        } else if rawValue == "🤵🏻‍♂️" {
-            self.init(baseEmoji: .manInTuxedo, skinTones: [.light])
-        } else if rawValue == "🤵🏼‍♂️" {
-            self.init(baseEmoji: .manInTuxedo, skinTones: [.mediumLight])
-        } else if rawValue == "🤵🏽‍♂️" {
-            self.init(baseEmoji: .manInTuxedo, skinTones: [.medium])
-        } else if rawValue == "🤵🏾‍♂️" {
-            self.init(baseEmoji: .manInTuxedo, skinTones: [.mediumDark])
-        } else if rawValue == "🤵🏿‍♂️" {
-            self.init(baseEmoji: .manInTuxedo, skinTones: [.dark])
-        } else if rawValue == "🤵‍♀️" {
-            self.init(baseEmoji: .womanInTuxedo, skinTones: nil)
-        } else if rawValue == "🤵🏻‍♀️" {
-            self.init(baseEmoji: .womanInTuxedo, skinTones: [.light])
-        } else if rawValue == "🤵🏼‍♀️" {
-            self.init(baseEmoji: .womanInTuxedo, skinTones: [.mediumLight])
-        } else if rawValue == "🤵🏽‍♀️" {
-            self.init(baseEmoji: .womanInTuxedo, skinTones: [.medium])
-        } else if rawValue == "🤵🏾‍♀️" {
-            self.init(baseEmoji: .womanInTuxedo, skinTones: [.mediumDark])
-        } else if rawValue == "🤵🏿‍♀️" {
-            self.init(baseEmoji: .womanInTuxedo, skinTones: [.dark])
-        } else if rawValue == "👰" {
-            self.init(baseEmoji: .brideWithVeil, skinTones: nil)
-        } else if rawValue == "👰🏻" {
-            self.init(baseEmoji: .brideWithVeil, skinTones: [.light])
-        } else if rawValue == "👰🏼" {
-            self.init(baseEmoji: .brideWithVeil, skinTones: [.mediumLight])
-        } else if rawValue == "👰🏽" {
-            self.init(baseEmoji: .brideWithVeil, skinTones: [.medium])
-        } else if rawValue == "👰🏾" {
-            self.init(baseEmoji: .brideWithVeil, skinTones: [.mediumDark])
-        } else if rawValue == "👰🏿" {
-            self.init(baseEmoji: .brideWithVeil, skinTones: [.dark])
-        } else if rawValue == "👰‍♂️" {
-            self.init(baseEmoji: .manWithVeil, skinTones: nil)
-        } else if rawValue == "👰🏻‍♂️" {
-            self.init(baseEmoji: .manWithVeil, skinTones: [.light])
-        } else if rawValue == "👰🏼‍♂️" {
-            self.init(baseEmoji: .manWithVeil, skinTones: [.mediumLight])
-        } else if rawValue == "👰🏽‍♂️" {
-            self.init(baseEmoji: .manWithVeil, skinTones: [.medium])
-        } else if rawValue == "👰🏾‍♂️" {
-            self.init(baseEmoji: .manWithVeil, skinTones: [.mediumDark])
-        } else if rawValue == "👰🏿‍♂️" {
-            self.init(baseEmoji: .manWithVeil, skinTones: [.dark])
-        } else if rawValue == "👰‍♀️" {
-            self.init(baseEmoji: .womanWithVeil, skinTones: nil)
-        } else if rawValue == "👰🏻‍♀️" {
-            self.init(baseEmoji: .womanWithVeil, skinTones: [.light])
-        } else if rawValue == "👰🏼‍♀️" {
-            self.init(baseEmoji: .womanWithVeil, skinTones: [.mediumLight])
-        } else if rawValue == "👰🏽‍♀️" {
-            self.init(baseEmoji: .womanWithVeil, skinTones: [.medium])
-        } else if rawValue == "👰🏾‍♀️" {
-            self.init(baseEmoji: .womanWithVeil, skinTones: [.mediumDark])
-        } else if rawValue == "👰🏿‍♀️" {
-            self.init(baseEmoji: .womanWithVeil, skinTones: [.dark])
-        } else if rawValue == "🤰" {
-            self.init(baseEmoji: .pregnantWoman, skinTones: nil)
-        } else if rawValue == "🤰🏻" {
-            self.init(baseEmoji: .pregnantWoman, skinTones: [.light])
-        } else if rawValue == "🤰🏼" {
-            self.init(baseEmoji: .pregnantWoman, skinTones: [.mediumLight])
-        } else if rawValue == "🤰🏽" {
-            self.init(baseEmoji: .pregnantWoman, skinTones: [.medium])
-        } else if rawValue == "🤰🏾" {
-            self.init(baseEmoji: .pregnantWoman, skinTones: [.mediumDark])
-        } else if rawValue == "🤰🏿" {
-            self.init(baseEmoji: .pregnantWoman, skinTones: [.dark])
-        } else if rawValue == "🫃" {
-            self.init(baseEmoji: .pregnantMan, skinTones: nil)
-        } else if rawValue == "🫃🏻" {
-            self.init(baseEmoji: .pregnantMan, skinTones: [.light])
-        } else if rawValue == "🫃🏼" {
-            self.init(baseEmoji: .pregnantMan, skinTones: [.mediumLight])
-        } else if rawValue == "🫃🏽" {
-            self.init(baseEmoji: .pregnantMan, skinTones: [.medium])
-        } else if rawValue == "🫃🏾" {
-            self.init(baseEmoji: .pregnantMan, skinTones: [.mediumDark])
-        } else if rawValue == "🫃🏿" {
-            self.init(baseEmoji: .pregnantMan, skinTones: [.dark])
-        } else if rawValue == "🫄" {
-            self.init(baseEmoji: .pregnantPerson, skinTones: nil)
-        } else if rawValue == "🫄🏻" {
-            self.init(baseEmoji: .pregnantPerson, skinTones: [.light])
-        } else if rawValue == "🫄🏼" {
-            self.init(baseEmoji: .pregnantPerson, skinTones: [.mediumLight])
-        } else if rawValue == "🫄🏽" {
-            self.init(baseEmoji: .pregnantPerson, skinTones: [.medium])
-        } else if rawValue == "🫄🏾" {
-            self.init(baseEmoji: .pregnantPerson, skinTones: [.mediumDark])
-        } else if rawValue == "🫄🏿" {
-            self.init(baseEmoji: .pregnantPerson, skinTones: [.dark])
-        } else if rawValue == "🤱" {
-            self.init(baseEmoji: .breastFeeding, skinTones: nil)
-        } else if rawValue == "🤱🏻" {
-            self.init(baseEmoji: .breastFeeding, skinTones: [.light])
-        } else if rawValue == "🤱🏼" {
-            self.init(baseEmoji: .breastFeeding, skinTones: [.mediumLight])
-        } else if rawValue == "🤱🏽" {
-            self.init(baseEmoji: .breastFeeding, skinTones: [.medium])
-        } else if rawValue == "🤱🏾" {
-            self.init(baseEmoji: .breastFeeding, skinTones: [.mediumDark])
-        } else if rawValue == "🤱🏿" {
-            self.init(baseEmoji: .breastFeeding, skinTones: [.dark])
-        } else if rawValue == "👩‍🍼" {
-            self.init(baseEmoji: .womanFeedingBaby, skinTones: nil)
-        } else if rawValue == "👩🏻‍🍼" {
-            self.init(baseEmoji: .womanFeedingBaby, skinTones: [.light])
-        } else if rawValue == "👩🏼‍🍼" {
-            self.init(baseEmoji: .womanFeedingBaby, skinTones: [.mediumLight])
-        } else if rawValue == "👩🏽‍🍼" {
-            self.init(baseEmoji: .womanFeedingBaby, skinTones: [.medium])
-        } else if rawValue == "👩🏾‍🍼" {
-            self.init(baseEmoji: .womanFeedingBaby, skinTones: [.mediumDark])
-        } else if rawValue == "👩🏿‍🍼" {
-            self.init(baseEmoji: .womanFeedingBaby, skinTones: [.dark])
-        } else if rawValue == "👨‍🍼" {
-            self.init(baseEmoji: .manFeedingBaby, skinTones: nil)
-        } else if rawValue == "👨🏻‍🍼" {
-            self.init(baseEmoji: .manFeedingBaby, skinTones: [.light])
-        } else if rawValue == "👨🏼‍🍼" {
-            self.init(baseEmoji: .manFeedingBaby, skinTones: [.mediumLight])
-        } else if rawValue == "👨🏽‍🍼" {
-            self.init(baseEmoji: .manFeedingBaby, skinTones: [.medium])
-        } else if rawValue == "👨🏾‍🍼" {
-            self.init(baseEmoji: .manFeedingBaby, skinTones: [.mediumDark])
-        } else if rawValue == "👨🏿‍🍼" {
-            self.init(baseEmoji: .manFeedingBaby, skinTones: [.dark])
-        } else if rawValue == "🧑‍🍼" {
-            self.init(baseEmoji: .personFeedingBaby, skinTones: nil)
-        } else if rawValue == "🧑🏻‍🍼" {
-            self.init(baseEmoji: .personFeedingBaby, skinTones: [.light])
-        } else if rawValue == "🧑🏼‍🍼" {
-            self.init(baseEmoji: .personFeedingBaby, skinTones: [.mediumLight])
-        } else if rawValue == "🧑🏽‍🍼" {
-            self.init(baseEmoji: .personFeedingBaby, skinTones: [.medium])
-        } else if rawValue == "🧑🏾‍🍼" {
-            self.init(baseEmoji: .personFeedingBaby, skinTones: [.mediumDark])
-        } else if rawValue == "🧑🏿‍🍼" {
-            self.init(baseEmoji: .personFeedingBaby, skinTones: [.dark])
-        } else if rawValue == "👼" {
-            self.init(baseEmoji: .angel, skinTones: nil)
-        } else if rawValue == "👼🏻" {
-            self.init(baseEmoji: .angel, skinTones: [.light])
-        } else if rawValue == "👼🏼" {
-            self.init(baseEmoji: .angel, skinTones: [.mediumLight])
-        } else if rawValue == "👼🏽" {
-            self.init(baseEmoji: .angel, skinTones: [.medium])
-        } else if rawValue == "👼🏾" {
-            self.init(baseEmoji: .angel, skinTones: [.mediumDark])
-        } else if rawValue == "👼🏿" {
-            self.init(baseEmoji: .angel, skinTones: [.dark])
-        } else if rawValue == "🎅" {
-            self.init(baseEmoji: .santa, skinTones: nil)
-        } else if rawValue == "🎅🏻" {
-            self.init(baseEmoji: .santa, skinTones: [.light])
-        } else if rawValue == "🎅🏼" {
-            self.init(baseEmoji: .santa, skinTones: [.mediumLight])
-        } else if rawValue == "🎅🏽" {
-            self.init(baseEmoji: .santa, skinTones: [.medium])
-        } else if rawValue == "🎅🏾" {
-            self.init(baseEmoji: .santa, skinTones: [.mediumDark])
-        } else if rawValue == "🎅🏿" {
-            self.init(baseEmoji: .santa, skinTones: [.dark])
-        } else if rawValue == "🤶" {
-            self.init(baseEmoji: .mrsClaus, skinTones: nil)
-        } else if rawValue == "🤶🏻" {
-            self.init(baseEmoji: .mrsClaus, skinTones: [.light])
-        } else if rawValue == "🤶🏼" {
-            self.init(baseEmoji: .mrsClaus, skinTones: [.mediumLight])
-        } else if rawValue == "🤶🏽" {
-            self.init(baseEmoji: .mrsClaus, skinTones: [.medium])
-        } else if rawValue == "🤶🏾" {
-            self.init(baseEmoji: .mrsClaus, skinTones: [.mediumDark])
-        } else if rawValue == "🤶🏿" {
-            self.init(baseEmoji: .mrsClaus, skinTones: [.dark])
-        } else if rawValue == "🧑‍🎄" {
-            self.init(baseEmoji: .mxClaus, skinTones: nil)
-        } else if rawValue == "🧑🏻‍🎄" {
-            self.init(baseEmoji: .mxClaus, skinTones: [.light])
-        } else if rawValue == "🧑🏼‍🎄" {
-            self.init(baseEmoji: .mxClaus, skinTones: [.mediumLight])
-        } else if rawValue == "🧑🏽‍🎄" {
-            self.init(baseEmoji: .mxClaus, skinTones: [.medium])
-        } else if rawValue == "🧑🏾‍🎄" {
-            self.init(baseEmoji: .mxClaus, skinTones: [.mediumDark])
-        } else if rawValue == "🧑🏿‍🎄" {
-            self.init(baseEmoji: .mxClaus, skinTones: [.dark])
-        } else if rawValue == "🦸" {
-            self.init(baseEmoji: .superhero, skinTones: nil)
-        } else if rawValue == "🦸🏻" {
-            self.init(baseEmoji: .superhero, skinTones: [.light])
-        } else if rawValue == "🦸🏼" {
-            self.init(baseEmoji: .superhero, skinTones: [.mediumLight])
-        } else if rawValue == "🦸🏽" {
-            self.init(baseEmoji: .superhero, skinTones: [.medium])
-        } else if rawValue == "🦸🏾" {
-            self.init(baseEmoji: .superhero, skinTones: [.mediumDark])
-        } else if rawValue == "🦸🏿" {
-            self.init(baseEmoji: .superhero, skinTones: [.dark])
-        } else if rawValue == "🦸‍♂️" {
-            self.init(baseEmoji: .maleSuperhero, skinTones: nil)
-        } else if rawValue == "🦸🏻‍♂️" {
-            self.init(baseEmoji: .maleSuperhero, skinTones: [.light])
-        } else if rawValue == "🦸🏼‍♂️" {
-            self.init(baseEmoji: .maleSuperhero, skinTones: [.mediumLight])
-        } else if rawValue == "🦸🏽‍♂️" {
-            self.init(baseEmoji: .maleSuperhero, skinTones: [.medium])
-        } else if rawValue == "🦸🏾‍♂️" {
-            self.init(baseEmoji: .maleSuperhero, skinTones: [.mediumDark])
-        } else if rawValue == "🦸🏿‍♂️" {
-            self.init(baseEmoji: .maleSuperhero, skinTones: [.dark])
-        } else if rawValue == "🦸‍♀️" {
-            self.init(baseEmoji: .femaleSuperhero, skinTones: nil)
-        } else if rawValue == "🦸🏻‍♀️" {
-            self.init(baseEmoji: .femaleSuperhero, skinTones: [.light])
-        } else if rawValue == "🦸🏼‍♀️" {
-            self.init(baseEmoji: .femaleSuperhero, skinTones: [.mediumLight])
-        } else if rawValue == "🦸🏽‍♀️" {
-            self.init(baseEmoji: .femaleSuperhero, skinTones: [.medium])
-        } else if rawValue == "🦸🏾‍♀️" {
-            self.init(baseEmoji: .femaleSuperhero, skinTones: [.mediumDark])
-        } else if rawValue == "🦸🏿‍♀️" {
-            self.init(baseEmoji: .femaleSuperhero, skinTones: [.dark])
-        } else if rawValue == "🦹" {
-            self.init(baseEmoji: .supervillain, skinTones: nil)
-        } else if rawValue == "🦹🏻" {
-            self.init(baseEmoji: .supervillain, skinTones: [.light])
-        } else if rawValue == "🦹🏼" {
-            self.init(baseEmoji: .supervillain, skinTones: [.mediumLight])
-        } else if rawValue == "🦹🏽" {
-            self.init(baseEmoji: .supervillain, skinTones: [.medium])
-        } else if rawValue == "🦹🏾" {
-            self.init(baseEmoji: .supervillain, skinTones: [.mediumDark])
-        } else if rawValue == "🦹🏿" {
-            self.init(baseEmoji: .supervillain, skinTones: [.dark])
-        } else if rawValue == "🦹‍♂️" {
-            self.init(baseEmoji: .maleSupervillain, skinTones: nil)
-        } else if rawValue == "🦹🏻‍♂️" {
-            self.init(baseEmoji: .maleSupervillain, skinTones: [.light])
-        } else if rawValue == "🦹🏼‍♂️" {
-            self.init(baseEmoji: .maleSupervillain, skinTones: [.mediumLight])
-        } else if rawValue == "🦹🏽‍♂️" {
-            self.init(baseEmoji: .maleSupervillain, skinTones: [.medium])
-        } else if rawValue == "🦹🏾‍♂️" {
-            self.init(baseEmoji: .maleSupervillain, skinTones: [.mediumDark])
-        } else if rawValue == "🦹🏿‍♂️" {
-            self.init(baseEmoji: .maleSupervillain, skinTones: [.dark])
-        } else if rawValue == "🦹‍♀️" {
-            self.init(baseEmoji: .femaleSupervillain, skinTones: nil)
-        } else if rawValue == "🦹🏻‍♀️" {
-            self.init(baseEmoji: .femaleSupervillain, skinTones: [.light])
-        } else if rawValue == "🦹🏼‍♀️" {
-            self.init(baseEmoji: .femaleSupervillain, skinTones: [.mediumLight])
-        } else if rawValue == "🦹🏽‍♀️" {
-            self.init(baseEmoji: .femaleSupervillain, skinTones: [.medium])
-        } else if rawValue == "🦹🏾‍♀️" {
-            self.init(baseEmoji: .femaleSupervillain, skinTones: [.mediumDark])
-        } else if rawValue == "🦹🏿‍♀️" {
-            self.init(baseEmoji: .femaleSupervillain, skinTones: [.dark])
-        } else if rawValue == "🧙" {
-            self.init(baseEmoji: .mage, skinTones: nil)
-        } else if rawValue == "🧙🏻" {
-            self.init(baseEmoji: .mage, skinTones: [.light])
-        } else if rawValue == "🧙🏼" {
-            self.init(baseEmoji: .mage, skinTones: [.mediumLight])
-        } else if rawValue == "🧙🏽" {
-            self.init(baseEmoji: .mage, skinTones: [.medium])
-        } else if rawValue == "🧙🏾" {
-            self.init(baseEmoji: .mage, skinTones: [.mediumDark])
-        } else if rawValue == "🧙🏿" {
-            self.init(baseEmoji: .mage, skinTones: [.dark])
-        } else if rawValue == "🧙‍♂️" {
-            self.init(baseEmoji: .maleMage, skinTones: nil)
-        } else if rawValue == "🧙🏻‍♂️" {
-            self.init(baseEmoji: .maleMage, skinTones: [.light])
-        } else if rawValue == "🧙🏼‍♂️" {
-            self.init(baseEmoji: .maleMage, skinTones: [.mediumLight])
-        } else if rawValue == "🧙🏽‍♂️" {
-            self.init(baseEmoji: .maleMage, skinTones: [.medium])
-        } else if rawValue == "🧙🏾‍♂️" {
-            self.init(baseEmoji: .maleMage, skinTones: [.mediumDark])
-        } else if rawValue == "🧙🏿‍♂️" {
-            self.init(baseEmoji: .maleMage, skinTones: [.dark])
-        } else if rawValue == "🧙‍♀️" {
-            self.init(baseEmoji: .femaleMage, skinTones: nil)
-        } else if rawValue == "🧙🏻‍♀️" {
-            self.init(baseEmoji: .femaleMage, skinTones: [.light])
-        } else if rawValue == "🧙🏼‍♀️" {
-            self.init(baseEmoji: .femaleMage, skinTones: [.mediumLight])
-        } else if rawValue == "🧙🏽‍♀️" {
-            self.init(baseEmoji: .femaleMage, skinTones: [.medium])
-        } else if rawValue == "🧙🏾‍♀️" {
-            self.init(baseEmoji: .femaleMage, skinTones: [.mediumDark])
-        } else if rawValue == "🧙🏿‍♀️" {
-            self.init(baseEmoji: .femaleMage, skinTones: [.dark])
-        } else if rawValue == "🧚" {
-            self.init(baseEmoji: .fairy, skinTones: nil)
-        } else if rawValue == "🧚🏻" {
-            self.init(baseEmoji: .fairy, skinTones: [.light])
-        } else if rawValue == "🧚🏼" {
-            self.init(baseEmoji: .fairy, skinTones: [.mediumLight])
-        } else if rawValue == "🧚🏽" {
-            self.init(baseEmoji: .fairy, skinTones: [.medium])
-        } else if rawValue == "🧚🏾" {
-            self.init(baseEmoji: .fairy, skinTones: [.mediumDark])
-        } else if rawValue == "🧚🏿" {
-            self.init(baseEmoji: .fairy, skinTones: [.dark])
-        } else if rawValue == "🧚‍♂️" {
-            self.init(baseEmoji: .maleFairy, skinTones: nil)
-        } else if rawValue == "🧚🏻‍♂️" {
-            self.init(baseEmoji: .maleFairy, skinTones: [.light])
-        } else if rawValue == "🧚🏼‍♂️" {
-            self.init(baseEmoji: .maleFairy, skinTones: [.mediumLight])
-        } else if rawValue == "🧚🏽‍♂️" {
-            self.init(baseEmoji: .maleFairy, skinTones: [.medium])
-        } else if rawValue == "🧚🏾‍♂️" {
-            self.init(baseEmoji: .maleFairy, skinTones: [.mediumDark])
-        } else if rawValue == "🧚🏿‍♂️" {
-            self.init(baseEmoji: .maleFairy, skinTones: [.dark])
-        } else if rawValue == "🧚‍♀️" {
-            self.init(baseEmoji: .femaleFairy, skinTones: nil)
-        } else if rawValue == "🧚🏻‍♀️" {
-            self.init(baseEmoji: .femaleFairy, skinTones: [.light])
-        } else if rawValue == "🧚🏼‍♀️" {
-            self.init(baseEmoji: .femaleFairy, skinTones: [.mediumLight])
-        } else if rawValue == "🧚🏽‍♀️" {
-            self.init(baseEmoji: .femaleFairy, skinTones: [.medium])
-        } else if rawValue == "🧚🏾‍♀️" {
-            self.init(baseEmoji: .femaleFairy, skinTones: [.mediumDark])
-        } else if rawValue == "🧚🏿‍♀️" {
-            self.init(baseEmoji: .femaleFairy, skinTones: [.dark])
-        } else if rawValue == "🧛" {
-            self.init(baseEmoji: .vampire, skinTones: nil)
-        } else if rawValue == "🧛🏻" {
-            self.init(baseEmoji: .vampire, skinTones: [.light])
-        } else if rawValue == "🧛🏼" {
-            self.init(baseEmoji: .vampire, skinTones: [.mediumLight])
-        } else if rawValue == "🧛🏽" {
-            self.init(baseEmoji: .vampire, skinTones: [.medium])
-        } else if rawValue == "🧛🏾" {
-            self.init(baseEmoji: .vampire, skinTones: [.mediumDark])
-        } else if rawValue == "🧛🏿" {
-            self.init(baseEmoji: .vampire, skinTones: [.dark])
-        } else if rawValue == "🧛‍♂️" {
-            self.init(baseEmoji: .maleVampire, skinTones: nil)
-        } else if rawValue == "🧛🏻‍♂️" {
-            self.init(baseEmoji: .maleVampire, skinTones: [.light])
-        } else if rawValue == "🧛🏼‍♂️" {
-            self.init(baseEmoji: .maleVampire, skinTones: [.mediumLight])
-        } else if rawValue == "🧛🏽‍♂️" {
-            self.init(baseEmoji: .maleVampire, skinTones: [.medium])
-        } else if rawValue == "🧛🏾‍♂️" {
-            self.init(baseEmoji: .maleVampire, skinTones: [.mediumDark])
-        } else if rawValue == "🧛🏿‍♂️" {
-            self.init(baseEmoji: .maleVampire, skinTones: [.dark])
-        } else if rawValue == "🧛‍♀️" {
-            self.init(baseEmoji: .femaleVampire, skinTones: nil)
-        } else if rawValue == "🧛🏻‍♀️" {
-            self.init(baseEmoji: .femaleVampire, skinTones: [.light])
-        } else if rawValue == "🧛🏼‍♀️" {
-            self.init(baseEmoji: .femaleVampire, skinTones: [.mediumLight])
-        } else if rawValue == "🧛🏽‍♀️" {
-            self.init(baseEmoji: .femaleVampire, skinTones: [.medium])
-        } else if rawValue == "🧛🏾‍♀️" {
-            self.init(baseEmoji: .femaleVampire, skinTones: [.mediumDark])
-        } else if rawValue == "🧛🏿‍♀️" {
-            self.init(baseEmoji: .femaleVampire, skinTones: [.dark])
-        } else if rawValue == "🧜" {
-            self.init(baseEmoji: .merperson, skinTones: nil)
-        } else if rawValue == "🧜🏻" {
-            self.init(baseEmoji: .merperson, skinTones: [.light])
-        } else if rawValue == "🧜🏼" {
-            self.init(baseEmoji: .merperson, skinTones: [.mediumLight])
-        } else if rawValue == "🧜🏽" {
-            self.init(baseEmoji: .merperson, skinTones: [.medium])
-        } else if rawValue == "🧜🏾" {
-            self.init(baseEmoji: .merperson, skinTones: [.mediumDark])
-        } else if rawValue == "🧜🏿" {
-            self.init(baseEmoji: .merperson, skinTones: [.dark])
-        } else if rawValue == "🧜‍♂️" {
-            self.init(baseEmoji: .merman, skinTones: nil)
-        } else if rawValue == "🧜🏻‍♂️" {
-            self.init(baseEmoji: .merman, skinTones: [.light])
-        } else if rawValue == "🧜🏼‍♂️" {
-            self.init(baseEmoji: .merman, skinTones: [.mediumLight])
-        } else if rawValue == "🧜🏽‍♂️" {
-            self.init(baseEmoji: .merman, skinTones: [.medium])
-        } else if rawValue == "🧜🏾‍♂️" {
-            self.init(baseEmoji: .merman, skinTones: [.mediumDark])
-        } else if rawValue == "🧜🏿‍♂️" {
-            self.init(baseEmoji: .merman, skinTones: [.dark])
-        } else if rawValue == "🧜‍♀️" {
-            self.init(baseEmoji: .mermaid, skinTones: nil)
-        } else if rawValue == "🧜🏻‍♀️" {
-            self.init(baseEmoji: .mermaid, skinTones: [.light])
-        } else if rawValue == "🧜🏼‍♀️" {
-            self.init(baseEmoji: .mermaid, skinTones: [.mediumLight])
-        } else if rawValue == "🧜🏽‍♀️" {
-            self.init(baseEmoji: .mermaid, skinTones: [.medium])
-        } else if rawValue == "🧜🏾‍♀️" {
-            self.init(baseEmoji: .mermaid, skinTones: [.mediumDark])
-        } else if rawValue == "🧜🏿‍♀️" {
-            self.init(baseEmoji: .mermaid, skinTones: [.dark])
-        } else if rawValue == "🧝" {
-            self.init(baseEmoji: .elf, skinTones: nil)
-        } else if rawValue == "🧝🏻" {
-            self.init(baseEmoji: .elf, skinTones: [.light])
-        } else if rawValue == "🧝🏼" {
-            self.init(baseEmoji: .elf, skinTones: [.mediumLight])
-        } else if rawValue == "🧝🏽" {
-            self.init(baseEmoji: .elf, skinTones: [.medium])
-        } else if rawValue == "🧝🏾" {
-            self.init(baseEmoji: .elf, skinTones: [.mediumDark])
-        } else if rawValue == "🧝🏿" {
-            self.init(baseEmoji: .elf, skinTones: [.dark])
-        } else if rawValue == "🧝‍♂️" {
-            self.init(baseEmoji: .maleElf, skinTones: nil)
-        } else if rawValue == "🧝🏻‍♂️" {
-            self.init(baseEmoji: .maleElf, skinTones: [.light])
-        } else if rawValue == "🧝🏼‍♂️" {
-            self.init(baseEmoji: .maleElf, skinTones: [.mediumLight])
-        } else if rawValue == "🧝🏽‍♂️" {
-            self.init(baseEmoji: .maleElf, skinTones: [.medium])
-        } else if rawValue == "🧝🏾‍♂️" {
-            self.init(baseEmoji: .maleElf, skinTones: [.mediumDark])
-        } else if rawValue == "🧝🏿‍♂️" {
-            self.init(baseEmoji: .maleElf, skinTones: [.dark])
-        } else if rawValue == "🧝‍♀️" {
-            self.init(baseEmoji: .femaleElf, skinTones: nil)
-        } else if rawValue == "🧝🏻‍♀️" {
-            self.init(baseEmoji: .femaleElf, skinTones: [.light])
-        } else if rawValue == "🧝🏼‍♀️" {
-            self.init(baseEmoji: .femaleElf, skinTones: [.mediumLight])
-        } else if rawValue == "🧝🏽‍♀️" {
-            self.init(baseEmoji: .femaleElf, skinTones: [.medium])
-        } else if rawValue == "🧝🏾‍♀️" {
-            self.init(baseEmoji: .femaleElf, skinTones: [.mediumDark])
-        } else if rawValue == "🧝🏿‍♀️" {
-            self.init(baseEmoji: .femaleElf, skinTones: [.dark])
-        } else if rawValue == "🧞" {
-            self.init(baseEmoji: .genie, skinTones: nil)
-        } else if rawValue == "🧞‍♂️" {
-            self.init(baseEmoji: .maleGenie, skinTones: nil)
-        } else if rawValue == "🧞‍♀️" {
-            self.init(baseEmoji: .femaleGenie, skinTones: nil)
-        } else if rawValue == "🧟" {
-            self.init(baseEmoji: .zombie, skinTones: nil)
-        } else if rawValue == "🧟‍♂️" {
-            self.init(baseEmoji: .maleZombie, skinTones: nil)
-        } else if rawValue == "🧟‍♀️" {
-            self.init(baseEmoji: .femaleZombie, skinTones: nil)
-        } else if rawValue == "🧌" {
-            self.init(baseEmoji: .troll, skinTones: nil)
-        } else if rawValue == "💆" {
-            self.init(baseEmoji: .massage, skinTones: nil)
-        } else if rawValue == "💆🏻" {
-            self.init(baseEmoji: .massage, skinTones: [.light])
-        } else if rawValue == "💆🏼" {
-            self.init(baseEmoji: .massage, skinTones: [.mediumLight])
-        } else if rawValue == "💆🏽" {
-            self.init(baseEmoji: .massage, skinTones: [.medium])
-        } else if rawValue == "💆🏾" {
-            self.init(baseEmoji: .massage, skinTones: [.mediumDark])
-        } else if rawValue == "💆🏿" {
-            self.init(baseEmoji: .massage, skinTones: [.dark])
-        } else if rawValue == "💆‍♂️" {
-            self.init(baseEmoji: .manGettingMassage, skinTones: nil)
-        } else if rawValue == "💆🏻‍♂️" {
-            self.init(baseEmoji: .manGettingMassage, skinTones: [.light])
-        } else if rawValue == "💆🏼‍♂️" {
-            self.init(baseEmoji: .manGettingMassage, skinTones: [.mediumLight])
-        } else if rawValue == "💆🏽‍♂️" {
-            self.init(baseEmoji: .manGettingMassage, skinTones: [.medium])
-        } else if rawValue == "💆🏾‍♂️" {
-            self.init(baseEmoji: .manGettingMassage, skinTones: [.mediumDark])
-        } else if rawValue == "💆🏿‍♂️" {
-            self.init(baseEmoji: .manGettingMassage, skinTones: [.dark])
-        } else if rawValue == "💆‍♀️" {
-            self.init(baseEmoji: .womanGettingMassage, skinTones: nil)
-        } else if rawValue == "💆🏻‍♀️" {
-            self.init(baseEmoji: .womanGettingMassage, skinTones: [.light])
-        } else if rawValue == "💆🏼‍♀️" {
-            self.init(baseEmoji: .womanGettingMassage, skinTones: [.mediumLight])
-        } else if rawValue == "💆🏽‍♀️" {
-            self.init(baseEmoji: .womanGettingMassage, skinTones: [.medium])
-        } else if rawValue == "💆🏾‍♀️" {
-            self.init(baseEmoji: .womanGettingMassage, skinTones: [.mediumDark])
-        } else if rawValue == "💆🏿‍♀️" {
-            self.init(baseEmoji: .womanGettingMassage, skinTones: [.dark])
-        } else if rawValue == "💇" {
-            self.init(baseEmoji: .haircut, skinTones: nil)
-        } else if rawValue == "💇🏻" {
-            self.init(baseEmoji: .haircut, skinTones: [.light])
-        } else if rawValue == "💇🏼" {
-            self.init(baseEmoji: .haircut, skinTones: [.mediumLight])
-        } else if rawValue == "💇🏽" {
-            self.init(baseEmoji: .haircut, skinTones: [.medium])
-        } else if rawValue == "💇🏾" {
-            self.init(baseEmoji: .haircut, skinTones: [.mediumDark])
-        } else if rawValue == "💇🏿" {
-            self.init(baseEmoji: .haircut, skinTones: [.dark])
-        } else if rawValue == "💇‍♂️" {
-            self.init(baseEmoji: .manGettingHaircut, skinTones: nil)
-        } else if rawValue == "💇🏻‍♂️" {
-            self.init(baseEmoji: .manGettingHaircut, skinTones: [.light])
-        } else if rawValue == "💇🏼‍♂️" {
-            self.init(baseEmoji: .manGettingHaircut, skinTones: [.mediumLight])
-        } else if rawValue == "💇🏽‍♂️" {
-            self.init(baseEmoji: .manGettingHaircut, skinTones: [.medium])
-        } else if rawValue == "💇🏾‍♂️" {
-            self.init(baseEmoji: .manGettingHaircut, skinTones: [.mediumDark])
-        } else if rawValue == "💇🏿‍♂️" {
-            self.init(baseEmoji: .manGettingHaircut, skinTones: [.dark])
-        } else if rawValue == "💇‍♀️" {
-            self.init(baseEmoji: .womanGettingHaircut, skinTones: nil)
-        } else if rawValue == "💇🏻‍♀️" {
-            self.init(baseEmoji: .womanGettingHaircut, skinTones: [.light])
-        } else if rawValue == "💇🏼‍♀️" {
-            self.init(baseEmoji: .womanGettingHaircut, skinTones: [.mediumLight])
-        } else if rawValue == "💇🏽‍♀️" {
-            self.init(baseEmoji: .womanGettingHaircut, skinTones: [.medium])
-        } else if rawValue == "💇🏾‍♀️" {
-            self.init(baseEmoji: .womanGettingHaircut, skinTones: [.mediumDark])
-        } else if rawValue == "💇🏿‍♀️" {
-            self.init(baseEmoji: .womanGettingHaircut, skinTones: [.dark])
-        } else if rawValue == "🚶" {
-            self.init(baseEmoji: .walking, skinTones: nil)
-        } else if rawValue == "🚶🏻" {
-            self.init(baseEmoji: .walking, skinTones: [.light])
-        } else if rawValue == "🚶🏼" {
-            self.init(baseEmoji: .walking, skinTones: [.mediumLight])
-        } else if rawValue == "🚶🏽" {
-            self.init(baseEmoji: .walking, skinTones: [.medium])
-        } else if rawValue == "🚶🏾" {
-            self.init(baseEmoji: .walking, skinTones: [.mediumDark])
-        } else if rawValue == "🚶🏿" {
-            self.init(baseEmoji: .walking, skinTones: [.dark])
-        } else if rawValue == "🚶‍♂️" {
-            self.init(baseEmoji: .manWalking, skinTones: nil)
-        } else if rawValue == "🚶🏻‍♂️" {
-            self.init(baseEmoji: .manWalking, skinTones: [.light])
-        } else if rawValue == "🚶🏼‍♂️" {
-            self.init(baseEmoji: .manWalking, skinTones: [.mediumLight])
-        } else if rawValue == "🚶🏽‍♂️" {
-            self.init(baseEmoji: .manWalking, skinTones: [.medium])
-        } else if rawValue == "🚶🏾‍♂️" {
-            self.init(baseEmoji: .manWalking, skinTones: [.mediumDark])
-        } else if rawValue == "🚶🏿‍♂️" {
-            self.init(baseEmoji: .manWalking, skinTones: [.dark])
-        } else if rawValue == "🚶‍♀️" {
-            self.init(baseEmoji: .womanWalking, skinTones: nil)
-        } else if rawValue == "🚶🏻‍♀️" {
-            self.init(baseEmoji: .womanWalking, skinTones: [.light])
-        } else if rawValue == "🚶🏼‍♀️" {
-            self.init(baseEmoji: .womanWalking, skinTones: [.mediumLight])
-        } else if rawValue == "🚶🏽‍♀️" {
-            self.init(baseEmoji: .womanWalking, skinTones: [.medium])
-        } else if rawValue == "🚶🏾‍♀️" {
-            self.init(baseEmoji: .womanWalking, skinTones: [.mediumDark])
-        } else if rawValue == "🚶🏿‍♀️" {
-            self.init(baseEmoji: .womanWalking, skinTones: [.dark])
-        } else if rawValue == "🧍" {
-            self.init(baseEmoji: .standingPerson, skinTones: nil)
-        } else if rawValue == "🧍🏻" {
-            self.init(baseEmoji: .standingPerson, skinTones: [.light])
-        } else if rawValue == "🧍🏼" {
-            self.init(baseEmoji: .standingPerson, skinTones: [.mediumLight])
-        } else if rawValue == "🧍🏽" {
-            self.init(baseEmoji: .standingPerson, skinTones: [.medium])
-        } else if rawValue == "🧍🏾" {
-            self.init(baseEmoji: .standingPerson, skinTones: [.mediumDark])
-        } else if rawValue == "🧍🏿" {
-            self.init(baseEmoji: .standingPerson, skinTones: [.dark])
-        } else if rawValue == "🧍‍♂️" {
-            self.init(baseEmoji: .manStanding, skinTones: nil)
-        } else if rawValue == "🧍🏻‍♂️" {
-            self.init(baseEmoji: .manStanding, skinTones: [.light])
-        } else if rawValue == "🧍🏼‍♂️" {
-            self.init(baseEmoji: .manStanding, skinTones: [.mediumLight])
-        } else if rawValue == "🧍🏽‍♂️" {
-            self.init(baseEmoji: .manStanding, skinTones: [.medium])
-        } else if rawValue == "🧍🏾‍♂️" {
-            self.init(baseEmoji: .manStanding, skinTones: [.mediumDark])
-        } else if rawValue == "🧍🏿‍♂️" {
-            self.init(baseEmoji: .manStanding, skinTones: [.dark])
-        } else if rawValue == "🧍‍♀️" {
-            self.init(baseEmoji: .womanStanding, skinTones: nil)
-        } else if rawValue == "🧍🏻‍♀️" {
-            self.init(baseEmoji: .womanStanding, skinTones: [.light])
-        } else if rawValue == "🧍🏼‍♀️" {
-            self.init(baseEmoji: .womanStanding, skinTones: [.mediumLight])
-        } else if rawValue == "🧍🏽‍♀️" {
-            self.init(baseEmoji: .womanStanding, skinTones: [.medium])
-        } else if rawValue == "🧍🏾‍♀️" {
-            self.init(baseEmoji: .womanStanding, skinTones: [.mediumDark])
-        } else if rawValue == "🧍🏿‍♀️" {
-            self.init(baseEmoji: .womanStanding, skinTones: [.dark])
-        } else if rawValue == "🧎" {
-            self.init(baseEmoji: .kneelingPerson, skinTones: nil)
-        } else if rawValue == "🧎🏻" {
-            self.init(baseEmoji: .kneelingPerson, skinTones: [.light])
-        } else if rawValue == "🧎🏼" {
-            self.init(baseEmoji: .kneelingPerson, skinTones: [.mediumLight])
-        } else if rawValue == "🧎🏽" {
-            self.init(baseEmoji: .kneelingPerson, skinTones: [.medium])
-        } else if rawValue == "🧎🏾" {
-            self.init(baseEmoji: .kneelingPerson, skinTones: [.mediumDark])
-        } else if rawValue == "🧎🏿" {
-            self.init(baseEmoji: .kneelingPerson, skinTones: [.dark])
-        } else if rawValue == "🧎‍♂️" {
-            self.init(baseEmoji: .manKneeling, skinTones: nil)
-        } else if rawValue == "🧎🏻‍♂️" {
-            self.init(baseEmoji: .manKneeling, skinTones: [.light])
-        } else if rawValue == "🧎🏼‍♂️" {
-            self.init(baseEmoji: .manKneeling, skinTones: [.mediumLight])
-        } else if rawValue == "🧎🏽‍♂️" {
-            self.init(baseEmoji: .manKneeling, skinTones: [.medium])
-        } else if rawValue == "🧎🏾‍♂️" {
-            self.init(baseEmoji: .manKneeling, skinTones: [.mediumDark])
-        } else if rawValue == "🧎🏿‍♂️" {
-            self.init(baseEmoji: .manKneeling, skinTones: [.dark])
-        } else if rawValue == "🧎‍♀️" {
-            self.init(baseEmoji: .womanKneeling, skinTones: nil)
-        } else if rawValue == "🧎🏻‍♀️" {
-            self.init(baseEmoji: .womanKneeling, skinTones: [.light])
-        } else if rawValue == "🧎🏼‍♀️" {
-            self.init(baseEmoji: .womanKneeling, skinTones: [.mediumLight])
-        } else if rawValue == "🧎🏽‍♀️" {
-            self.init(baseEmoji: .womanKneeling, skinTones: [.medium])
-        } else if rawValue == "🧎🏾‍♀️" {
-            self.init(baseEmoji: .womanKneeling, skinTones: [.mediumDark])
-        } else if rawValue == "🧎🏿‍♀️" {
-            self.init(baseEmoji: .womanKneeling, skinTones: [.dark])
-        } else if rawValue == "🧑‍🦯" {
-            self.init(baseEmoji: .personWithProbingCane, skinTones: nil)
-        } else if rawValue == "🧑🏻‍🦯" {
-            self.init(baseEmoji: .personWithProbingCane, skinTones: [.light])
-        } else if rawValue == "🧑🏼‍🦯" {
-            self.init(baseEmoji: .personWithProbingCane, skinTones: [.mediumLight])
-        } else if rawValue == "🧑🏽‍🦯" {
-            self.init(baseEmoji: .personWithProbingCane, skinTones: [.medium])
-        } else if rawValue == "🧑🏾‍🦯" {
-            self.init(baseEmoji: .personWithProbingCane, skinTones: [.mediumDark])
-        } else if rawValue == "🧑🏿‍🦯" {
-            self.init(baseEmoji: .personWithProbingCane, skinTones: [.dark])
-        } else if rawValue == "👨‍🦯" {
-            self.init(baseEmoji: .manWithProbingCane, skinTones: nil)
-        } else if rawValue == "👨🏻‍🦯" {
-            self.init(baseEmoji: .manWithProbingCane, skinTones: [.light])
-        } else if rawValue == "👨🏼‍🦯" {
-            self.init(baseEmoji: .manWithProbingCane, skinTones: [.mediumLight])
-        } else if rawValue == "👨🏽‍🦯" {
-            self.init(baseEmoji: .manWithProbingCane, skinTones: [.medium])
-        } else if rawValue == "👨🏾‍🦯" {
-            self.init(baseEmoji: .manWithProbingCane, skinTones: [.mediumDark])
-        } else if rawValue == "👨🏿‍🦯" {
-            self.init(baseEmoji: .manWithProbingCane, skinTones: [.dark])
-        } else if rawValue == "👩‍🦯" {
-            self.init(baseEmoji: .womanWithProbingCane, skinTones: nil)
-        } else if rawValue == "👩🏻‍🦯" {
-            self.init(baseEmoji: .womanWithProbingCane, skinTones: [.light])
-        } else if rawValue == "👩🏼‍🦯" {
-            self.init(baseEmoji: .womanWithProbingCane, skinTones: [.mediumLight])
-        } else if rawValue == "👩🏽‍🦯" {
-            self.init(baseEmoji: .womanWithProbingCane, skinTones: [.medium])
-        } else if rawValue == "👩🏾‍🦯" {
-            self.init(baseEmoji: .womanWithProbingCane, skinTones: [.mediumDark])
-        } else if rawValue == "👩🏿‍🦯" {
-            self.init(baseEmoji: .womanWithProbingCane, skinTones: [.dark])
-        } else if rawValue == "🧑‍🦼" {
-            self.init(baseEmoji: .personInMotorizedWheelchair, skinTones: nil)
-        } else if rawValue == "🧑🏻‍🦼" {
-            self.init(baseEmoji: .personInMotorizedWheelchair, skinTones: [.light])
-        } else if rawValue == "🧑🏼‍🦼" {
-            self.init(baseEmoji: .personInMotorizedWheelchair, skinTones: [.mediumLight])
-        } else if rawValue == "🧑🏽‍🦼" {
-            self.init(baseEmoji: .personInMotorizedWheelchair, skinTones: [.medium])
-        } else if rawValue == "🧑🏾‍🦼" {
-            self.init(baseEmoji: .personInMotorizedWheelchair, skinTones: [.mediumDark])
-        } else if rawValue == "🧑🏿‍🦼" {
-            self.init(baseEmoji: .personInMotorizedWheelchair, skinTones: [.dark])
-        } else if rawValue == "👨‍🦼" {
-            self.init(baseEmoji: .manInMotorizedWheelchair, skinTones: nil)
-        } else if rawValue == "👨🏻‍🦼" {
-            self.init(baseEmoji: .manInMotorizedWheelchair, skinTones: [.light])
-        } else if rawValue == "👨🏼‍🦼" {
-            self.init(baseEmoji: .manInMotorizedWheelchair, skinTones: [.mediumLight])
-        } else if rawValue == "👨🏽‍🦼" {
-            self.init(baseEmoji: .manInMotorizedWheelchair, skinTones: [.medium])
-        } else if rawValue == "👨🏾‍🦼" {
-            self.init(baseEmoji: .manInMotorizedWheelchair, skinTones: [.mediumDark])
-        } else if rawValue == "👨🏿‍🦼" {
-            self.init(baseEmoji: .manInMotorizedWheelchair, skinTones: [.dark])
-        } else if rawValue == "👩‍🦼" {
-            self.init(baseEmoji: .womanInMotorizedWheelchair, skinTones: nil)
-        } else if rawValue == "👩🏻‍🦼" {
-            self.init(baseEmoji: .womanInMotorizedWheelchair, skinTones: [.light])
-        } else if rawValue == "👩🏼‍🦼" {
-            self.init(baseEmoji: .womanInMotorizedWheelchair, skinTones: [.mediumLight])
-        } else if rawValue == "👩🏽‍🦼" {
-            self.init(baseEmoji: .womanInMotorizedWheelchair, skinTones: [.medium])
-        } else if rawValue == "👩🏾‍🦼" {
-            self.init(baseEmoji: .womanInMotorizedWheelchair, skinTones: [.mediumDark])
-        } else if rawValue == "👩🏿‍🦼" {
-            self.init(baseEmoji: .womanInMotorizedWheelchair, skinTones: [.dark])
-        } else if rawValue == "🧑‍🦽" {
-            self.init(baseEmoji: .personInManualWheelchair, skinTones: nil)
-        } else if rawValue == "🧑🏻‍🦽" {
-            self.init(baseEmoji: .personInManualWheelchair, skinTones: [.light])
-        } else if rawValue == "🧑🏼‍🦽" {
-            self.init(baseEmoji: .personInManualWheelchair, skinTones: [.mediumLight])
-        } else if rawValue == "🧑🏽‍🦽" {
-            self.init(baseEmoji: .personInManualWheelchair, skinTones: [.medium])
-        } else if rawValue == "🧑🏾‍🦽" {
-            self.init(baseEmoji: .personInManualWheelchair, skinTones: [.mediumDark])
-        } else if rawValue == "🧑🏿‍🦽" {
-            self.init(baseEmoji: .personInManualWheelchair, skinTones: [.dark])
-        } else if rawValue == "👨‍🦽" {
-            self.init(baseEmoji: .manInManualWheelchair, skinTones: nil)
-        } else if rawValue == "👨🏻‍🦽" {
-            self.init(baseEmoji: .manInManualWheelchair, skinTones: [.light])
-        } else if rawValue == "👨🏼‍🦽" {
-            self.init(baseEmoji: .manInManualWheelchair, skinTones: [.mediumLight])
-        } else if rawValue == "👨🏽‍🦽" {
-            self.init(baseEmoji: .manInManualWheelchair, skinTones: [.medium])
-        } else if rawValue == "👨🏾‍🦽" {
-            self.init(baseEmoji: .manInManualWheelchair, skinTones: [.mediumDark])
-        } else if rawValue == "👨🏿‍🦽" {
-            self.init(baseEmoji: .manInManualWheelchair, skinTones: [.dark])
-        } else if rawValue == "👩‍🦽" {
-            self.init(baseEmoji: .womanInManualWheelchair, skinTones: nil)
-        } else if rawValue == "👩🏻‍🦽" {
-            self.init(baseEmoji: .womanInManualWheelchair, skinTones: [.light])
-        } else if rawValue == "👩🏼‍🦽" {
-            self.init(baseEmoji: .womanInManualWheelchair, skinTones: [.mediumLight])
-        } else if rawValue == "👩🏽‍🦽" {
-            self.init(baseEmoji: .womanInManualWheelchair, skinTones: [.medium])
-        } else if rawValue == "👩🏾‍🦽" {
-            self.init(baseEmoji: .womanInManualWheelchair, skinTones: [.mediumDark])
-        } else if rawValue == "👩🏿‍🦽" {
-            self.init(baseEmoji: .womanInManualWheelchair, skinTones: [.dark])
-        } else if rawValue == "🏃" {
-            self.init(baseEmoji: .runner, skinTones: nil)
-        } else if rawValue == "🏃🏻" {
-            self.init(baseEmoji: .runner, skinTones: [.light])
-        } else if rawValue == "🏃🏼" {
-            self.init(baseEmoji: .runner, skinTones: [.mediumLight])
-        } else if rawValue == "🏃🏽" {
-            self.init(baseEmoji: .runner, skinTones: [.medium])
-        } else if rawValue == "🏃🏾" {
-            self.init(baseEmoji: .runner, skinTones: [.mediumDark])
-        } else if rawValue == "🏃🏿" {
-            self.init(baseEmoji: .runner, skinTones: [.dark])
-        } else if rawValue == "🏃‍♂️" {
-            self.init(baseEmoji: .manRunning, skinTones: nil)
-        } else if rawValue == "🏃🏻‍♂️" {
-            self.init(baseEmoji: .manRunning, skinTones: [.light])
-        } else if rawValue == "🏃🏼‍♂️" {
-            self.init(baseEmoji: .manRunning, skinTones: [.mediumLight])
-        } else if rawValue == "🏃🏽‍♂️" {
-            self.init(baseEmoji: .manRunning, skinTones: [.medium])
-        } else if rawValue == "🏃🏾‍♂️" {
-            self.init(baseEmoji: .manRunning, skinTones: [.mediumDark])
-        } else if rawValue == "🏃🏿‍♂️" {
-            self.init(baseEmoji: .manRunning, skinTones: [.dark])
-        } else if rawValue == "🏃‍♀️" {
-            self.init(baseEmoji: .womanRunning, skinTones: nil)
-        } else if rawValue == "🏃🏻‍♀️" {
-            self.init(baseEmoji: .womanRunning, skinTones: [.light])
-        } else if rawValue == "🏃🏼‍♀️" {
-            self.init(baseEmoji: .womanRunning, skinTones: [.mediumLight])
-        } else if rawValue == "🏃🏽‍♀️" {
-            self.init(baseEmoji: .womanRunning, skinTones: [.medium])
-        } else if rawValue == "🏃🏾‍♀️" {
-            self.init(baseEmoji: .womanRunning, skinTones: [.mediumDark])
-        } else if rawValue == "🏃🏿‍♀️" {
-            self.init(baseEmoji: .womanRunning, skinTones: [.dark])
-        } else if rawValue == "💃" {
-            self.init(baseEmoji: .dancer, skinTones: nil)
-        } else if rawValue == "💃🏻" {
-            self.init(baseEmoji: .dancer, skinTones: [.light])
-        } else if rawValue == "💃🏼" {
-            self.init(baseEmoji: .dancer, skinTones: [.mediumLight])
-        } else if rawValue == "💃🏽" {
-            self.init(baseEmoji: .dancer, skinTones: [.medium])
-        } else if rawValue == "💃🏾" {
-            self.init(baseEmoji: .dancer, skinTones: [.mediumDark])
-        } else if rawValue == "💃🏿" {
-            self.init(baseEmoji: .dancer, skinTones: [.dark])
-        } else if rawValue == "🕺" {
-            self.init(baseEmoji: .manDancing, skinTones: nil)
-        } else if rawValue == "🕺🏻" {
-            self.init(baseEmoji: .manDancing, skinTones: [.light])
-        } else if rawValue == "🕺🏼" {
-            self.init(baseEmoji: .manDancing, skinTones: [.mediumLight])
-        } else if rawValue == "🕺🏽" {
-            self.init(baseEmoji: .manDancing, skinTones: [.medium])
-        } else if rawValue == "🕺🏾" {
-            self.init(baseEmoji: .manDancing, skinTones: [.mediumDark])
-        } else if rawValue == "🕺🏿" {
-            self.init(baseEmoji: .manDancing, skinTones: [.dark])
-        } else if rawValue == "🕴️" {
-            self.init(baseEmoji: .manInBusinessSuitLevitating, skinTones: nil)
-        } else if rawValue == "🕴🏻" {
-            self.init(baseEmoji: .manInBusinessSuitLevitating, skinTones: [.light])
-        } else if rawValue == "🕴🏼" {
-            self.init(baseEmoji: .manInBusinessSuitLevitating, skinTones: [.mediumLight])
-        } else if rawValue == "🕴🏽" {
-            self.init(baseEmoji: .manInBusinessSuitLevitating, skinTones: [.medium])
-        } else if rawValue == "🕴🏾" {
-            self.init(baseEmoji: .manInBusinessSuitLevitating, skinTones: [.mediumDark])
-        } else if rawValue == "🕴🏿" {
-            self.init(baseEmoji: .manInBusinessSuitLevitating, skinTones: [.dark])
-        } else if rawValue == "👯" {
-            self.init(baseEmoji: .dancers, skinTones: nil)
-        } else if rawValue == "👯‍♂️" {
-            self.init(baseEmoji: .menWithBunnyEarsPartying, skinTones: nil)
-        } else if rawValue == "👯‍♀️" {
-            self.init(baseEmoji: .womenWithBunnyEarsPartying, skinTones: nil)
-        } else if rawValue == "🧖" {
-            self.init(baseEmoji: .personInSteamyRoom, skinTones: nil)
-        } else if rawValue == "🧖🏻" {
-            self.init(baseEmoji: .personInSteamyRoom, skinTones: [.light])
-        } else if rawValue == "🧖🏼" {
-            self.init(baseEmoji: .personInSteamyRoom, skinTones: [.mediumLight])
-        } else if rawValue == "🧖🏽" {
-            self.init(baseEmoji: .personInSteamyRoom, skinTones: [.medium])
-        } else if rawValue == "🧖🏾" {
-            self.init(baseEmoji: .personInSteamyRoom, skinTones: [.mediumDark])
-        } else if rawValue == "🧖🏿" {
-            self.init(baseEmoji: .personInSteamyRoom, skinTones: [.dark])
-        } else if rawValue == "🧖‍♂️" {
-            self.init(baseEmoji: .manInSteamyRoom, skinTones: nil)
-        } else if rawValue == "🧖🏻‍♂️" {
-            self.init(baseEmoji: .manInSteamyRoom, skinTones: [.light])
-        } else if rawValue == "🧖🏼‍♂️" {
-            self.init(baseEmoji: .manInSteamyRoom, skinTones: [.mediumLight])
-        } else if rawValue == "🧖🏽‍♂️" {
-            self.init(baseEmoji: .manInSteamyRoom, skinTones: [.medium])
-        } else if rawValue == "🧖🏾‍♂️" {
-            self.init(baseEmoji: .manInSteamyRoom, skinTones: [.mediumDark])
-        } else if rawValue == "🧖🏿‍♂️" {
-            self.init(baseEmoji: .manInSteamyRoom, skinTones: [.dark])
-        } else if rawValue == "🧖‍♀️" {
-            self.init(baseEmoji: .womanInSteamyRoom, skinTones: nil)
-        } else if rawValue == "🧖🏻‍♀️" {
-            self.init(baseEmoji: .womanInSteamyRoom, skinTones: [.light])
-        } else if rawValue == "🧖🏼‍♀️" {
-            self.init(baseEmoji: .womanInSteamyRoom, skinTones: [.mediumLight])
-        } else if rawValue == "🧖🏽‍♀️" {
-            self.init(baseEmoji: .womanInSteamyRoom, skinTones: [.medium])
-        } else if rawValue == "🧖🏾‍♀️" {
-            self.init(baseEmoji: .womanInSteamyRoom, skinTones: [.mediumDark])
-        } else if rawValue == "🧖🏿‍♀️" {
-            self.init(baseEmoji: .womanInSteamyRoom, skinTones: [.dark])
-        } else if rawValue == "🧗" {
-            self.init(baseEmoji: .personClimbing, skinTones: nil)
-        } else if rawValue == "🧗🏻" {
-            self.init(baseEmoji: .personClimbing, skinTones: [.light])
-        } else if rawValue == "🧗🏼" {
-            self.init(baseEmoji: .personClimbing, skinTones: [.mediumLight])
-        } else if rawValue == "🧗🏽" {
-            self.init(baseEmoji: .personClimbing, skinTones: [.medium])
-        } else if rawValue == "🧗🏾" {
-            self.init(baseEmoji: .personClimbing, skinTones: [.mediumDark])
-        } else if rawValue == "🧗🏿" {
-            self.init(baseEmoji: .personClimbing, skinTones: [.dark])
-        } else if rawValue == "🧗‍♂️" {
-            self.init(baseEmoji: .manClimbing, skinTones: nil)
-        } else if rawValue == "🧗🏻‍♂️" {
-            self.init(baseEmoji: .manClimbing, skinTones: [.light])
-        } else if rawValue == "🧗🏼‍♂️" {
-            self.init(baseEmoji: .manClimbing, skinTones: [.mediumLight])
-        } else if rawValue == "🧗🏽‍♂️" {
-            self.init(baseEmoji: .manClimbing, skinTones: [.medium])
-        } else if rawValue == "🧗🏾‍♂️" {
-            self.init(baseEmoji: .manClimbing, skinTones: [.mediumDark])
-        } else if rawValue == "🧗🏿‍♂️" {
-            self.init(baseEmoji: .manClimbing, skinTones: [.dark])
-        } else if rawValue == "🧗‍♀️" {
-            self.init(baseEmoji: .womanClimbing, skinTones: nil)
-        } else if rawValue == "🧗🏻‍♀️" {
-            self.init(baseEmoji: .womanClimbing, skinTones: [.light])
-        } else if rawValue == "🧗🏼‍♀️" {
-            self.init(baseEmoji: .womanClimbing, skinTones: [.mediumLight])
-        } else if rawValue == "🧗🏽‍♀️" {
-            self.init(baseEmoji: .womanClimbing, skinTones: [.medium])
-        } else if rawValue == "🧗🏾‍♀️" {
-            self.init(baseEmoji: .womanClimbing, skinTones: [.mediumDark])
-        } else if rawValue == "🧗🏿‍♀️" {
-            self.init(baseEmoji: .womanClimbing, skinTones: [.dark])
-        } else if rawValue == "🤺" {
-            self.init(baseEmoji: .fencer, skinTones: nil)
-        } else if rawValue == "🏇" {
-            self.init(baseEmoji: .horseRacing, skinTones: nil)
-        } else if rawValue == "🏇🏻" {
-            self.init(baseEmoji: .horseRacing, skinTones: [.light])
-        } else if rawValue == "🏇🏼" {
-            self.init(baseEmoji: .horseRacing, skinTones: [.mediumLight])
-        } else if rawValue == "🏇🏽" {
-            self.init(baseEmoji: .horseRacing, skinTones: [.medium])
-        } else if rawValue == "🏇🏾" {
-            self.init(baseEmoji: .horseRacing, skinTones: [.mediumDark])
-        } else if rawValue == "🏇🏿" {
-            self.init(baseEmoji: .horseRacing, skinTones: [.dark])
-        } else if rawValue == "⛷️" {
-            self.init(baseEmoji: .skier, skinTones: nil)
-        } else if rawValue == "🏂" {
-            self.init(baseEmoji: .snowboarder, skinTones: nil)
-        } else if rawValue == "🏂🏻" {
-            self.init(baseEmoji: .snowboarder, skinTones: [.light])
-        } else if rawValue == "🏂🏼" {
-            self.init(baseEmoji: .snowboarder, skinTones: [.mediumLight])
-        } else if rawValue == "🏂🏽" {
-            self.init(baseEmoji: .snowboarder, skinTones: [.medium])
-        } else if rawValue == "🏂🏾" {
-            self.init(baseEmoji: .snowboarder, skinTones: [.mediumDark])
-        } else if rawValue == "🏂🏿" {
-            self.init(baseEmoji: .snowboarder, skinTones: [.dark])
-        } else if rawValue == "🏌️" {
-            self.init(baseEmoji: .golfer, skinTones: nil)
-        } else if rawValue == "🏌🏻" {
-            self.init(baseEmoji: .golfer, skinTones: [.light])
-        } else if rawValue == "🏌🏼" {
-            self.init(baseEmoji: .golfer, skinTones: [.mediumLight])
-        } else if rawValue == "🏌🏽" {
-            self.init(baseEmoji: .golfer, skinTones: [.medium])
-        } else if rawValue == "🏌🏾" {
-            self.init(baseEmoji: .golfer, skinTones: [.mediumDark])
-        } else if rawValue == "🏌🏿" {
-            self.init(baseEmoji: .golfer, skinTones: [.dark])
-        } else if rawValue == "🏌️‍♂️" {
-            self.init(baseEmoji: .manGolfing, skinTones: nil)
-        } else if rawValue == "🏌🏻‍♂️" {
-            self.init(baseEmoji: .manGolfing, skinTones: [.light])
-        } else if rawValue == "🏌🏼‍♂️" {
-            self.init(baseEmoji: .manGolfing, skinTones: [.mediumLight])
-        } else if rawValue == "🏌🏽‍♂️" {
-            self.init(baseEmoji: .manGolfing, skinTones: [.medium])
-        } else if rawValue == "🏌🏾‍♂️" {
-            self.init(baseEmoji: .manGolfing, skinTones: [.mediumDark])
-        } else if rawValue == "🏌🏿‍♂️" {
-            self.init(baseEmoji: .manGolfing, skinTones: [.dark])
-        } else if rawValue == "🏌️‍♀️" {
-            self.init(baseEmoji: .womanGolfing, skinTones: nil)
-        } else if rawValue == "🏌🏻‍♀️" {
-            self.init(baseEmoji: .womanGolfing, skinTones: [.light])
-        } else if rawValue == "🏌🏼‍♀️" {
-            self.init(baseEmoji: .womanGolfing, skinTones: [.mediumLight])
-        } else if rawValue == "🏌🏽‍♀️" {
-            self.init(baseEmoji: .womanGolfing, skinTones: [.medium])
-        } else if rawValue == "🏌🏾‍♀️" {
-            self.init(baseEmoji: .womanGolfing, skinTones: [.mediumDark])
-        } else if rawValue == "🏌🏿‍♀️" {
-            self.init(baseEmoji: .womanGolfing, skinTones: [.dark])
-        } else if rawValue == "🏄" {
-            self.init(baseEmoji: .surfer, skinTones: nil)
-        } else if rawValue == "🏄🏻" {
-            self.init(baseEmoji: .surfer, skinTones: [.light])
-        } else if rawValue == "🏄🏼" {
-            self.init(baseEmoji: .surfer, skinTones: [.mediumLight])
-        } else if rawValue == "🏄🏽" {
-            self.init(baseEmoji: .surfer, skinTones: [.medium])
-        } else if rawValue == "🏄🏾" {
-            self.init(baseEmoji: .surfer, skinTones: [.mediumDark])
-        } else if rawValue == "🏄🏿" {
-            self.init(baseEmoji: .surfer, skinTones: [.dark])
-        } else if rawValue == "🏄‍♂️" {
-            self.init(baseEmoji: .manSurfing, skinTones: nil)
-        } else if rawValue == "🏄🏻‍♂️" {
-            self.init(baseEmoji: .manSurfing, skinTones: [.light])
-        } else if rawValue == "🏄🏼‍♂️" {
-            self.init(baseEmoji: .manSurfing, skinTones: [.mediumLight])
-        } else if rawValue == "🏄🏽‍♂️" {
-            self.init(baseEmoji: .manSurfing, skinTones: [.medium])
-        } else if rawValue == "🏄🏾‍♂️" {
-            self.init(baseEmoji: .manSurfing, skinTones: [.mediumDark])
-        } else if rawValue == "🏄🏿‍♂️" {
-            self.init(baseEmoji: .manSurfing, skinTones: [.dark])
-        } else if rawValue == "🏄‍♀️" {
-            self.init(baseEmoji: .womanSurfing, skinTones: nil)
-        } else if rawValue == "🏄🏻‍♀️" {
-            self.init(baseEmoji: .womanSurfing, skinTones: [.light])
-        } else if rawValue == "🏄🏼‍♀️" {
-            self.init(baseEmoji: .womanSurfing, skinTones: [.mediumLight])
-        } else if rawValue == "🏄🏽‍♀️" {
-            self.init(baseEmoji: .womanSurfing, skinTones: [.medium])
-        } else if rawValue == "🏄🏾‍♀️" {
-            self.init(baseEmoji: .womanSurfing, skinTones: [.mediumDark])
-        } else if rawValue == "🏄🏿‍♀️" {
-            self.init(baseEmoji: .womanSurfing, skinTones: [.dark])
-        } else if rawValue == "🚣" {
-            self.init(baseEmoji: .rowboat, skinTones: nil)
-        } else if rawValue == "🚣🏻" {
-            self.init(baseEmoji: .rowboat, skinTones: [.light])
-        } else if rawValue == "🚣🏼" {
-            self.init(baseEmoji: .rowboat, skinTones: [.mediumLight])
-        } else if rawValue == "🚣🏽" {
-            self.init(baseEmoji: .rowboat, skinTones: [.medium])
-        } else if rawValue == "🚣🏾" {
-            self.init(baseEmoji: .rowboat, skinTones: [.mediumDark])
-        } else if rawValue == "🚣🏿" {
-            self.init(baseEmoji: .rowboat, skinTones: [.dark])
-        } else if rawValue == "🚣‍♂️" {
-            self.init(baseEmoji: .manRowingBoat, skinTones: nil)
-        } else if rawValue == "🚣🏻‍♂️" {
-            self.init(baseEmoji: .manRowingBoat, skinTones: [.light])
-        } else if rawValue == "🚣🏼‍♂️" {
-            self.init(baseEmoji: .manRowingBoat, skinTones: [.mediumLight])
-        } else if rawValue == "🚣🏽‍♂️" {
-            self.init(baseEmoji: .manRowingBoat, skinTones: [.medium])
-        } else if rawValue == "🚣🏾‍♂️" {
-            self.init(baseEmoji: .manRowingBoat, skinTones: [.mediumDark])
-        } else if rawValue == "🚣🏿‍♂️" {
-            self.init(baseEmoji: .manRowingBoat, skinTones: [.dark])
-        } else if rawValue == "🚣‍♀️" {
-            self.init(baseEmoji: .womanRowingBoat, skinTones: nil)
-        } else if rawValue == "🚣🏻‍♀️" {
-            self.init(baseEmoji: .womanRowingBoat, skinTones: [.light])
-        } else if rawValue == "🚣🏼‍♀️" {
-            self.init(baseEmoji: .womanRowingBoat, skinTones: [.mediumLight])
-        } else if rawValue == "🚣🏽‍♀️" {
-            self.init(baseEmoji: .womanRowingBoat, skinTones: [.medium])
-        } else if rawValue == "🚣🏾‍♀️" {
-            self.init(baseEmoji: .womanRowingBoat, skinTones: [.mediumDark])
-        } else if rawValue == "🚣🏿‍♀️" {
-            self.init(baseEmoji: .womanRowingBoat, skinTones: [.dark])
-        } else if rawValue == "🏊" {
-            self.init(baseEmoji: .swimmer, skinTones: nil)
-        } else if rawValue == "🏊🏻" {
-            self.init(baseEmoji: .swimmer, skinTones: [.light])
-        } else if rawValue == "🏊🏼" {
-            self.init(baseEmoji: .swimmer, skinTones: [.mediumLight])
-        } else if rawValue == "🏊🏽" {
-            self.init(baseEmoji: .swimmer, skinTones: [.medium])
-        } else if rawValue == "🏊🏾" {
-            self.init(baseEmoji: .swimmer, skinTones: [.mediumDark])
-        } else if rawValue == "🏊🏿" {
-            self.init(baseEmoji: .swimmer, skinTones: [.dark])
-        } else if rawValue == "🏊‍♂️" {
-            self.init(baseEmoji: .manSwimming, skinTones: nil)
-        } else if rawValue == "🏊🏻‍♂️" {
-            self.init(baseEmoji: .manSwimming, skinTones: [.light])
-        } else if rawValue == "🏊🏼‍♂️" {
-            self.init(baseEmoji: .manSwimming, skinTones: [.mediumLight])
-        } else if rawValue == "🏊🏽‍♂️" {
-            self.init(baseEmoji: .manSwimming, skinTones: [.medium])
-        } else if rawValue == "🏊🏾‍♂️" {
-            self.init(baseEmoji: .manSwimming, skinTones: [.mediumDark])
-        } else if rawValue == "🏊🏿‍♂️" {
-            self.init(baseEmoji: .manSwimming, skinTones: [.dark])
-        } else if rawValue == "🏊‍♀️" {
-            self.init(baseEmoji: .womanSwimming, skinTones: nil)
-        } else if rawValue == "🏊🏻‍♀️" {
-            self.init(baseEmoji: .womanSwimming, skinTones: [.light])
-        } else if rawValue == "🏊🏼‍♀️" {
-            self.init(baseEmoji: .womanSwimming, skinTones: [.mediumLight])
-        } else if rawValue == "🏊🏽‍♀️" {
-            self.init(baseEmoji: .womanSwimming, skinTones: [.medium])
-        } else if rawValue == "🏊🏾‍♀️" {
-            self.init(baseEmoji: .womanSwimming, skinTones: [.mediumDark])
-        } else if rawValue == "🏊🏿‍♀️" {
-            self.init(baseEmoji: .womanSwimming, skinTones: [.dark])
-        } else if rawValue == "⛹️" {
-            self.init(baseEmoji: .personWithBall, skinTones: nil)
-        } else if rawValue == "⛹🏻" {
-            self.init(baseEmoji: .personWithBall, skinTones: [.light])
-        } else if rawValue == "⛹🏼" {
-            self.init(baseEmoji: .personWithBall, skinTones: [.mediumLight])
-        } else if rawValue == "⛹🏽" {
-            self.init(baseEmoji: .personWithBall, skinTones: [.medium])
-        } else if rawValue == "⛹🏾" {
-            self.init(baseEmoji: .personWithBall, skinTones: [.mediumDark])
-        } else if rawValue == "⛹🏿" {
-            self.init(baseEmoji: .personWithBall, skinTones: [.dark])
-        } else if rawValue == "⛹️‍♂️" {
-            self.init(baseEmoji: .manBouncingBall, skinTones: nil)
-        } else if rawValue == "⛹🏻‍♂️" {
-            self.init(baseEmoji: .manBouncingBall, skinTones: [.light])
-        } else if rawValue == "⛹🏼‍♂️" {
-            self.init(baseEmoji: .manBouncingBall, skinTones: [.mediumLight])
-        } else if rawValue == "⛹🏽‍♂️" {
-            self.init(baseEmoji: .manBouncingBall, skinTones: [.medium])
-        } else if rawValue == "⛹🏾‍♂️" {
-            self.init(baseEmoji: .manBouncingBall, skinTones: [.mediumDark])
-        } else if rawValue == "⛹🏿‍♂️" {
-            self.init(baseEmoji: .manBouncingBall, skinTones: [.dark])
-        } else if rawValue == "⛹️‍♀️" {
-            self.init(baseEmoji: .womanBouncingBall, skinTones: nil)
-        } else if rawValue == "⛹🏻‍♀️" {
-            self.init(baseEmoji: .womanBouncingBall, skinTones: [.light])
-        } else if rawValue == "⛹🏼‍♀️" {
-            self.init(baseEmoji: .womanBouncingBall, skinTones: [.mediumLight])
-        } else if rawValue == "⛹🏽‍♀️" {
-            self.init(baseEmoji: .womanBouncingBall, skinTones: [.medium])
-        } else if rawValue == "⛹🏾‍♀️" {
-            self.init(baseEmoji: .womanBouncingBall, skinTones: [.mediumDark])
-        } else if rawValue == "⛹🏿‍♀️" {
-            self.init(baseEmoji: .womanBouncingBall, skinTones: [.dark])
-        } else if rawValue == "🏋️" {
-            self.init(baseEmoji: .weightLifter, skinTones: nil)
-        } else if rawValue == "🏋🏻" {
-            self.init(baseEmoji: .weightLifter, skinTones: [.light])
-        } else if rawValue == "🏋🏼" {
-            self.init(baseEmoji: .weightLifter, skinTones: [.mediumLight])
-        } else if rawValue == "🏋🏽" {
-            self.init(baseEmoji: .weightLifter, skinTones: [.medium])
-        } else if rawValue == "🏋🏾" {
-            self.init(baseEmoji: .weightLifter, skinTones: [.mediumDark])
-        } else if rawValue == "🏋🏿" {
-            self.init(baseEmoji: .weightLifter, skinTones: [.dark])
-        } else if rawValue == "🏋️‍♂️" {
-            self.init(baseEmoji: .manLiftingWeights, skinTones: nil)
-        } else if rawValue == "🏋🏻‍♂️" {
-            self.init(baseEmoji: .manLiftingWeights, skinTones: [.light])
-        } else if rawValue == "🏋🏼‍♂️" {
-            self.init(baseEmoji: .manLiftingWeights, skinTones: [.mediumLight])
-        } else if rawValue == "🏋🏽‍♂️" {
-            self.init(baseEmoji: .manLiftingWeights, skinTones: [.medium])
-        } else if rawValue == "🏋🏾‍♂️" {
-            self.init(baseEmoji: .manLiftingWeights, skinTones: [.mediumDark])
-        } else if rawValue == "🏋🏿‍♂️" {
-            self.init(baseEmoji: .manLiftingWeights, skinTones: [.dark])
-        } else if rawValue == "🏋️‍♀️" {
-            self.init(baseEmoji: .womanLiftingWeights, skinTones: nil)
-        } else if rawValue == "🏋🏻‍♀️" {
-            self.init(baseEmoji: .womanLiftingWeights, skinTones: [.light])
-        } else if rawValue == "🏋🏼‍♀️" {
-            self.init(baseEmoji: .womanLiftingWeights, skinTones: [.mediumLight])
-        } else if rawValue == "🏋🏽‍♀️" {
-            self.init(baseEmoji: .womanLiftingWeights, skinTones: [.medium])
-        } else if rawValue == "🏋🏾‍♀️" {
-            self.init(baseEmoji: .womanLiftingWeights, skinTones: [.mediumDark])
-        } else if rawValue == "🏋🏿‍♀️" {
-            self.init(baseEmoji: .womanLiftingWeights, skinTones: [.dark])
-        } else if rawValue == "🚴" {
-            self.init(baseEmoji: .bicyclist, skinTones: nil)
-        } else if rawValue == "🚴🏻" {
-            self.init(baseEmoji: .bicyclist, skinTones: [.light])
-        } else if rawValue == "🚴🏼" {
-            self.init(baseEmoji: .bicyclist, skinTones: [.mediumLight])
-        } else if rawValue == "🚴🏽" {
-            self.init(baseEmoji: .bicyclist, skinTones: [.medium])
-        } else if rawValue == "🚴🏾" {
-            self.init(baseEmoji: .bicyclist, skinTones: [.mediumDark])
-        } else if rawValue == "🚴🏿" {
-            self.init(baseEmoji: .bicyclist, skinTones: [.dark])
-        } else if rawValue == "🚴‍♂️" {
-            self.init(baseEmoji: .manBiking, skinTones: nil)
-        } else if rawValue == "🚴🏻‍♂️" {
-            self.init(baseEmoji: .manBiking, skinTones: [.light])
-        } else if rawValue == "🚴🏼‍♂️" {
-            self.init(baseEmoji: .manBiking, skinTones: [.mediumLight])
-        } else if rawValue == "🚴🏽‍♂️" {
-            self.init(baseEmoji: .manBiking, skinTones: [.medium])
-        } else if rawValue == "🚴🏾‍♂️" {
-            self.init(baseEmoji: .manBiking, skinTones: [.mediumDark])
-        } else if rawValue == "🚴🏿‍♂️" {
-            self.init(baseEmoji: .manBiking, skinTones: [.dark])
-        } else if rawValue == "🚴‍♀️" {
-            self.init(baseEmoji: .womanBiking, skinTones: nil)
-        } else if rawValue == "🚴🏻‍♀️" {
-            self.init(baseEmoji: .womanBiking, skinTones: [.light])
-        } else if rawValue == "🚴🏼‍♀️" {
-            self.init(baseEmoji: .womanBiking, skinTones: [.mediumLight])
-        } else if rawValue == "🚴🏽‍♀️" {
-            self.init(baseEmoji: .womanBiking, skinTones: [.medium])
-        } else if rawValue == "🚴🏾‍♀️" {
-            self.init(baseEmoji: .womanBiking, skinTones: [.mediumDark])
-        } else if rawValue == "🚴🏿‍♀️" {
-            self.init(baseEmoji: .womanBiking, skinTones: [.dark])
-        } else if rawValue == "🚵" {
-            self.init(baseEmoji: .mountainBicyclist, skinTones: nil)
-        } else if rawValue == "🚵🏻" {
-            self.init(baseEmoji: .mountainBicyclist, skinTones: [.light])
-        } else if rawValue == "🚵🏼" {
-            self.init(baseEmoji: .mountainBicyclist, skinTones: [.mediumLight])
-        } else if rawValue == "🚵🏽" {
-            self.init(baseEmoji: .mountainBicyclist, skinTones: [.medium])
-        } else if rawValue == "🚵🏾" {
-            self.init(baseEmoji: .mountainBicyclist, skinTones: [.mediumDark])
-        } else if rawValue == "🚵🏿" {
-            self.init(baseEmoji: .mountainBicyclist, skinTones: [.dark])
-        } else if rawValue == "🚵‍♂️" {
-            self.init(baseEmoji: .manMountainBiking, skinTones: nil)
-        } else if rawValue == "🚵🏻‍♂️" {
-            self.init(baseEmoji: .manMountainBiking, skinTones: [.light])
-        } else if rawValue == "🚵🏼‍♂️" {
-            self.init(baseEmoji: .manMountainBiking, skinTones: [.mediumLight])
-        } else if rawValue == "🚵🏽‍♂️" {
-            self.init(baseEmoji: .manMountainBiking, skinTones: [.medium])
-        } else if rawValue == "🚵🏾‍♂️" {
-            self.init(baseEmoji: .manMountainBiking, skinTones: [.mediumDark])
-        } else if rawValue == "🚵🏿‍♂️" {
-            self.init(baseEmoji: .manMountainBiking, skinTones: [.dark])
-        } else if rawValue == "🚵‍♀️" {
-            self.init(baseEmoji: .womanMountainBiking, skinTones: nil)
-        } else if rawValue == "🚵🏻‍♀️" {
-            self.init(baseEmoji: .womanMountainBiking, skinTones: [.light])
-        } else if rawValue == "🚵🏼‍♀️" {
-            self.init(baseEmoji: .womanMountainBiking, skinTones: [.mediumLight])
-        } else if rawValue == "🚵🏽‍♀️" {
-            self.init(baseEmoji: .womanMountainBiking, skinTones: [.medium])
-        } else if rawValue == "🚵🏾‍♀️" {
-            self.init(baseEmoji: .womanMountainBiking, skinTones: [.mediumDark])
-        } else if rawValue == "🚵🏿‍♀️" {
-            self.init(baseEmoji: .womanMountainBiking, skinTones: [.dark])
-        } else if rawValue == "🤸" {
-            self.init(baseEmoji: .personDoingCartwheel, skinTones: nil)
-        } else if rawValue == "🤸🏻" {
-            self.init(baseEmoji: .personDoingCartwheel, skinTones: [.light])
-        } else if rawValue == "🤸🏼" {
-            self.init(baseEmoji: .personDoingCartwheel, skinTones: [.mediumLight])
-        } else if rawValue == "🤸🏽" {
-            self.init(baseEmoji: .personDoingCartwheel, skinTones: [.medium])
-        } else if rawValue == "🤸🏾" {
-            self.init(baseEmoji: .personDoingCartwheel, skinTones: [.mediumDark])
-        } else if rawValue == "🤸🏿" {
-            self.init(baseEmoji: .personDoingCartwheel, skinTones: [.dark])
-        } else if rawValue == "🤸‍♂️" {
-            self.init(baseEmoji: .manCartwheeling, skinTones: nil)
-        } else if rawValue == "🤸🏻‍♂️" {
-            self.init(baseEmoji: .manCartwheeling, skinTones: [.light])
-        } else if rawValue == "🤸🏼‍♂️" {
-            self.init(baseEmoji: .manCartwheeling, skinTones: [.mediumLight])
-        } else if rawValue == "🤸🏽‍♂️" {
-            self.init(baseEmoji: .manCartwheeling, skinTones: [.medium])
-        } else if rawValue == "🤸🏾‍♂️" {
-            self.init(baseEmoji: .manCartwheeling, skinTones: [.mediumDark])
-        } else if rawValue == "🤸🏿‍♂️" {
-            self.init(baseEmoji: .manCartwheeling, skinTones: [.dark])
-        } else if rawValue == "🤸‍♀️" {
-            self.init(baseEmoji: .womanCartwheeling, skinTones: nil)
-        } else if rawValue == "🤸🏻‍♀️" {
-            self.init(baseEmoji: .womanCartwheeling, skinTones: [.light])
-        } else if rawValue == "🤸🏼‍♀️" {
-            self.init(baseEmoji: .womanCartwheeling, skinTones: [.mediumLight])
-        } else if rawValue == "🤸🏽‍♀️" {
-            self.init(baseEmoji: .womanCartwheeling, skinTones: [.medium])
-        } else if rawValue == "🤸🏾‍♀️" {
-            self.init(baseEmoji: .womanCartwheeling, skinTones: [.mediumDark])
-        } else if rawValue == "🤸🏿‍♀️" {
-            self.init(baseEmoji: .womanCartwheeling, skinTones: [.dark])
-        } else if rawValue == "🤼" {
-            self.init(baseEmoji: .wrestlers, skinTones: nil)
-        } else if rawValue == "🤼‍♂️" {
-            self.init(baseEmoji: .manWrestling, skinTones: nil)
-        } else if rawValue == "🤼‍♀️" {
-            self.init(baseEmoji: .womanWrestling, skinTones: nil)
-        } else if rawValue == "🤽" {
-            self.init(baseEmoji: .waterPolo, skinTones: nil)
-        } else if rawValue == "🤽🏻" {
-            self.init(baseEmoji: .waterPolo, skinTones: [.light])
-        } else if rawValue == "🤽🏼" {
-            self.init(baseEmoji: .waterPolo, skinTones: [.mediumLight])
-        } else if rawValue == "🤽🏽" {
-            self.init(baseEmoji: .waterPolo, skinTones: [.medium])
-        } else if rawValue == "🤽🏾" {
-            self.init(baseEmoji: .waterPolo, skinTones: [.mediumDark])
-        } else if rawValue == "🤽🏿" {
-            self.init(baseEmoji: .waterPolo, skinTones: [.dark])
-        } else if rawValue == "🤽‍♂️" {
-            self.init(baseEmoji: .manPlayingWaterPolo, skinTones: nil)
-        } else if rawValue == "🤽🏻‍♂️" {
-            self.init(baseEmoji: .manPlayingWaterPolo, skinTones: [.light])
-        } else if rawValue == "🤽🏼‍♂️" {
-            self.init(baseEmoji: .manPlayingWaterPolo, skinTones: [.mediumLight])
-        } else if rawValue == "🤽🏽‍♂️" {
-            self.init(baseEmoji: .manPlayingWaterPolo, skinTones: [.medium])
-        } else if rawValue == "🤽🏾‍♂️" {
-            self.init(baseEmoji: .manPlayingWaterPolo, skinTones: [.mediumDark])
-        } else if rawValue == "🤽🏿‍♂️" {
-            self.init(baseEmoji: .manPlayingWaterPolo, skinTones: [.dark])
-        } else if rawValue == "🤽‍♀️" {
-            self.init(baseEmoji: .womanPlayingWaterPolo, skinTones: nil)
-        } else if rawValue == "🤽🏻‍♀️" {
-            self.init(baseEmoji: .womanPlayingWaterPolo, skinTones: [.light])
-        } else if rawValue == "🤽🏼‍♀️" {
-            self.init(baseEmoji: .womanPlayingWaterPolo, skinTones: [.mediumLight])
-        } else if rawValue == "🤽🏽‍♀️" {
-            self.init(baseEmoji: .womanPlayingWaterPolo, skinTones: [.medium])
-        } else if rawValue == "🤽🏾‍♀️" {
-            self.init(baseEmoji: .womanPlayingWaterPolo, skinTones: [.mediumDark])
-        } else if rawValue == "🤽🏿‍♀️" {
-            self.init(baseEmoji: .womanPlayingWaterPolo, skinTones: [.dark])
-        } else if rawValue == "🤾" {
-            self.init(baseEmoji: .handball, skinTones: nil)
-        } else if rawValue == "🤾🏻" {
-            self.init(baseEmoji: .handball, skinTones: [.light])
-        } else if rawValue == "🤾🏼" {
-            self.init(baseEmoji: .handball, skinTones: [.mediumLight])
-        } else if rawValue == "🤾🏽" {
-            self.init(baseEmoji: .handball, skinTones: [.medium])
-        } else if rawValue == "🤾🏾" {
-            self.init(baseEmoji: .handball, skinTones: [.mediumDark])
-        } else if rawValue == "🤾🏿" {
-            self.init(baseEmoji: .handball, skinTones: [.dark])
-        } else if rawValue == "🤾‍♂️" {
-            self.init(baseEmoji: .manPlayingHandball, skinTones: nil)
-        } else if rawValue == "🤾🏻‍♂️" {
-            self.init(baseEmoji: .manPlayingHandball, skinTones: [.light])
-        } else if rawValue == "🤾🏼‍♂️" {
-            self.init(baseEmoji: .manPlayingHandball, skinTones: [.mediumLight])
-        } else if rawValue == "🤾🏽‍♂️" {
-            self.init(baseEmoji: .manPlayingHandball, skinTones: [.medium])
-        } else if rawValue == "🤾🏾‍♂️" {
-            self.init(baseEmoji: .manPlayingHandball, skinTones: [.mediumDark])
-        } else if rawValue == "🤾🏿‍♂️" {
-            self.init(baseEmoji: .manPlayingHandball, skinTones: [.dark])
-        } else if rawValue == "🤾‍♀️" {
-            self.init(baseEmoji: .womanPlayingHandball, skinTones: nil)
-        } else if rawValue == "🤾🏻‍♀️" {
-            self.init(baseEmoji: .womanPlayingHandball, skinTones: [.light])
-        } else if rawValue == "🤾🏼‍♀️" {
-            self.init(baseEmoji: .womanPlayingHandball, skinTones: [.mediumLight])
-        } else if rawValue == "🤾🏽‍♀️" {
-            self.init(baseEmoji: .womanPlayingHandball, skinTones: [.medium])
-        } else if rawValue == "🤾🏾‍♀️" {
-            self.init(baseEmoji: .womanPlayingHandball, skinTones: [.mediumDark])
-        } else if rawValue == "🤾🏿‍♀️" {
-            self.init(baseEmoji: .womanPlayingHandball, skinTones: [.dark])
-        } else if rawValue == "🤹" {
-            self.init(baseEmoji: .juggling, skinTones: nil)
-        } else if rawValue == "🤹🏻" {
-            self.init(baseEmoji: .juggling, skinTones: [.light])
-        } else if rawValue == "🤹🏼" {
-            self.init(baseEmoji: .juggling, skinTones: [.mediumLight])
-        } else if rawValue == "🤹🏽" {
-            self.init(baseEmoji: .juggling, skinTones: [.medium])
-        } else if rawValue == "🤹🏾" {
-            self.init(baseEmoji: .juggling, skinTones: [.mediumDark])
-        } else if rawValue == "🤹🏿" {
-            self.init(baseEmoji: .juggling, skinTones: [.dark])
-        } else if rawValue == "🤹‍♂️" {
-            self.init(baseEmoji: .manJuggling, skinTones: nil)
-        } else if rawValue == "🤹🏻‍♂️" {
-            self.init(baseEmoji: .manJuggling, skinTones: [.light])
-        } else if rawValue == "🤹🏼‍♂️" {
-            self.init(baseEmoji: .manJuggling, skinTones: [.mediumLight])
-        } else if rawValue == "🤹🏽‍♂️" {
-            self.init(baseEmoji: .manJuggling, skinTones: [.medium])
-        } else if rawValue == "🤹🏾‍♂️" {
-            self.init(baseEmoji: .manJuggling, skinTones: [.mediumDark])
-        } else if rawValue == "🤹🏿‍♂️" {
-            self.init(baseEmoji: .manJuggling, skinTones: [.dark])
-        } else if rawValue == "🤹‍♀️" {
-            self.init(baseEmoji: .womanJuggling, skinTones: nil)
-        } else if rawValue == "🤹🏻‍♀️" {
-            self.init(baseEmoji: .womanJuggling, skinTones: [.light])
-        } else if rawValue == "🤹🏼‍♀️" {
-            self.init(baseEmoji: .womanJuggling, skinTones: [.mediumLight])
-        } else if rawValue == "🤹🏽‍♀️" {
-            self.init(baseEmoji: .womanJuggling, skinTones: [.medium])
-        } else if rawValue == "🤹🏾‍♀️" {
-            self.init(baseEmoji: .womanJuggling, skinTones: [.mediumDark])
-        } else if rawValue == "🤹🏿‍♀️" {
-            self.init(baseEmoji: .womanJuggling, skinTones: [.dark])
-        } else if rawValue == "🧘" {
-            self.init(baseEmoji: .personInLotusPosition, skinTones: nil)
-        } else if rawValue == "🧘🏻" {
-            self.init(baseEmoji: .personInLotusPosition, skinTones: [.light])
-        } else if rawValue == "🧘🏼" {
-            self.init(baseEmoji: .personInLotusPosition, skinTones: [.mediumLight])
-        } else if rawValue == "🧘🏽" {
-            self.init(baseEmoji: .personInLotusPosition, skinTones: [.medium])
-        } else if rawValue == "🧘🏾" {
-            self.init(baseEmoji: .personInLotusPosition, skinTones: [.mediumDark])
-        } else if rawValue == "🧘🏿" {
-            self.init(baseEmoji: .personInLotusPosition, skinTones: [.dark])
-        } else if rawValue == "🧘‍♂️" {
-            self.init(baseEmoji: .manInLotusPosition, skinTones: nil)
-        } else if rawValue == "🧘🏻‍♂️" {
-            self.init(baseEmoji: .manInLotusPosition, skinTones: [.light])
-        } else if rawValue == "🧘🏼‍♂️" {
-            self.init(baseEmoji: .manInLotusPosition, skinTones: [.mediumLight])
-        } else if rawValue == "🧘🏽‍♂️" {
-            self.init(baseEmoji: .manInLotusPosition, skinTones: [.medium])
-        } else if rawValue == "🧘🏾‍♂️" {
-            self.init(baseEmoji: .manInLotusPosition, skinTones: [.mediumDark])
-        } else if rawValue == "🧘🏿‍♂️" {
-            self.init(baseEmoji: .manInLotusPosition, skinTones: [.dark])
-        } else if rawValue == "🧘‍♀️" {
-            self.init(baseEmoji: .womanInLotusPosition, skinTones: nil)
-        } else if rawValue == "🧘🏻‍♀️" {
-            self.init(baseEmoji: .womanInLotusPosition, skinTones: [.light])
-        } else if rawValue == "🧘🏼‍♀️" {
-            self.init(baseEmoji: .womanInLotusPosition, skinTones: [.mediumLight])
-        } else if rawValue == "🧘🏽‍♀️" {
-            self.init(baseEmoji: .womanInLotusPosition, skinTones: [.medium])
-        } else if rawValue == "🧘🏾‍♀️" {
-            self.init(baseEmoji: .womanInLotusPosition, skinTones: [.mediumDark])
-        } else if rawValue == "🧘🏿‍♀️" {
-            self.init(baseEmoji: .womanInLotusPosition, skinTones: [.dark])
-        } else if rawValue == "🛀" {
-            self.init(baseEmoji: .bath, skinTones: nil)
-        } else if rawValue == "🛀🏻" {
-            self.init(baseEmoji: .bath, skinTones: [.light])
-        } else if rawValue == "🛀🏼" {
-            self.init(baseEmoji: .bath, skinTones: [.mediumLight])
-        } else if rawValue == "🛀🏽" {
-            self.init(baseEmoji: .bath, skinTones: [.medium])
-        } else if rawValue == "🛀🏾" {
-            self.init(baseEmoji: .bath, skinTones: [.mediumDark])
-        } else if rawValue == "🛀🏿" {
-            self.init(baseEmoji: .bath, skinTones: [.dark])
-        } else if rawValue == "🛌" {
-            self.init(baseEmoji: .sleepingAccommodation, skinTones: nil)
-        } else if rawValue == "🛌🏻" {
-            self.init(baseEmoji: .sleepingAccommodation, skinTones: [.light])
-        } else if rawValue == "🛌🏼" {
-            self.init(baseEmoji: .sleepingAccommodation, skinTones: [.mediumLight])
-        } else if rawValue == "🛌🏽" {
-            self.init(baseEmoji: .sleepingAccommodation, skinTones: [.medium])
-        } else if rawValue == "🛌🏾" {
-            self.init(baseEmoji: .sleepingAccommodation, skinTones: [.mediumDark])
-        } else if rawValue == "🛌🏿" {
-            self.init(baseEmoji: .sleepingAccommodation, skinTones: [.dark])
-        } else if rawValue == "🧑‍🤝‍🧑" {
-            self.init(baseEmoji: .peopleHoldingHands, skinTones: nil)
-        } else if rawValue == "🧑🏻‍🤝‍🧑🏻" {
-            self.init(baseEmoji: .peopleHoldingHands, skinTones: [.light])
-        } else if rawValue == "🧑🏻‍🤝‍🧑🏼" {
-            self.init(baseEmoji: .peopleHoldingHands, skinTones: [.light, .mediumLight])
-        } else if rawValue == "🧑🏻‍🤝‍🧑🏽" {
-            self.init(baseEmoji: .peopleHoldingHands, skinTones: [.light, .medium])
-        } else if rawValue == "🧑🏻‍🤝‍🧑🏾" {
-            self.init(baseEmoji: .peopleHoldingHands, skinTones: [.light, .mediumDark])
-        } else if rawValue == "🧑🏻‍🤝‍🧑🏿" {
-            self.init(baseEmoji: .peopleHoldingHands, skinTones: [.light, .dark])
-        } else if rawValue == "🧑🏼‍🤝‍🧑🏼" {
-            self.init(baseEmoji: .peopleHoldingHands, skinTones: [.mediumLight])
-        } else if rawValue == "🧑🏼‍🤝‍🧑🏻" {
-            self.init(baseEmoji: .peopleHoldingHands, skinTones: [.mediumLight, .light])
-        } else if rawValue == "🧑🏼‍🤝‍🧑🏽" {
-            self.init(baseEmoji: .peopleHoldingHands, skinTones: [.mediumLight, .medium])
-        } else if rawValue == "🧑🏼‍🤝‍🧑🏾" {
-            self.init(baseEmoji: .peopleHoldingHands, skinTones: [.mediumLight, .mediumDark])
-        } else if rawValue == "🧑🏼‍🤝‍🧑🏿" {
-            self.init(baseEmoji: .peopleHoldingHands, skinTones: [.mediumLight, .dark])
-        } else if rawValue == "🧑🏽‍🤝‍🧑🏽" {
-            self.init(baseEmoji: .peopleHoldingHands, skinTones: [.medium])
-        } else if rawValue == "🧑🏽‍🤝‍🧑🏻" {
-            self.init(baseEmoji: .peopleHoldingHands, skinTones: [.medium, .light])
-        } else if rawValue == "🧑🏽‍🤝‍🧑🏼" {
-            self.init(baseEmoji: .peopleHoldingHands, skinTones: [.medium, .mediumLight])
-        } else if rawValue == "🧑🏽‍🤝‍🧑🏾" {
-            self.init(baseEmoji: .peopleHoldingHands, skinTones: [.medium, .mediumDark])
-        } else if rawValue == "🧑🏽‍🤝‍🧑🏿" {
-            self.init(baseEmoji: .peopleHoldingHands, skinTones: [.medium, .dark])
-        } else if rawValue == "🧑🏾‍🤝‍🧑🏾" {
-            self.init(baseEmoji: .peopleHoldingHands, skinTones: [.mediumDark])
-        } else if rawValue == "🧑🏾‍🤝‍🧑🏻" {
-            self.init(baseEmoji: .peopleHoldingHands, skinTones: [.mediumDark, .light])
-        } else if rawValue == "🧑🏾‍🤝‍🧑🏼" {
-            self.init(baseEmoji: .peopleHoldingHands, skinTones: [.mediumDark, .mediumLight])
-        } else if rawValue == "🧑🏾‍🤝‍🧑🏽" {
-            self.init(baseEmoji: .peopleHoldingHands, skinTones: [.mediumDark, .medium])
-        } else if rawValue == "🧑🏾‍🤝‍🧑🏿" {
-            self.init(baseEmoji: .peopleHoldingHands, skinTones: [.mediumDark, .dark])
-        } else if rawValue == "🧑🏿‍🤝‍🧑🏿" {
-            self.init(baseEmoji: .peopleHoldingHands, skinTones: [.dark])
-        } else if rawValue == "🧑🏿‍🤝‍🧑🏻" {
-            self.init(baseEmoji: .peopleHoldingHands, skinTones: [.dark, .light])
-        } else if rawValue == "🧑🏿‍🤝‍🧑🏼" {
-            self.init(baseEmoji: .peopleHoldingHands, skinTones: [.dark, .mediumLight])
-        } else if rawValue == "🧑🏿‍🤝‍🧑🏽" {
-            self.init(baseEmoji: .peopleHoldingHands, skinTones: [.dark, .medium])
-        } else if rawValue == "🧑🏿‍🤝‍🧑🏾" {
-            self.init(baseEmoji: .peopleHoldingHands, skinTones: [.dark, .mediumDark])
-        } else if rawValue == "👭" {
-            self.init(baseEmoji: .twoWomenHoldingHands, skinTones: nil)
-        } else if rawValue == "👭🏻" {
-            self.init(baseEmoji: .twoWomenHoldingHands, skinTones: [.light])
-        } else if rawValue == "👩🏻‍🤝‍👩🏼" {
-            self.init(baseEmoji: .twoWomenHoldingHands, skinTones: [.light, .mediumLight])
-        } else if rawValue == "👩🏻‍🤝‍👩🏽" {
-            self.init(baseEmoji: .twoWomenHoldingHands, skinTones: [.light, .medium])
-        } else if rawValue == "👩🏻‍🤝‍👩🏾" {
-            self.init(baseEmoji: .twoWomenHoldingHands, skinTones: [.light, .mediumDark])
-        } else if rawValue == "👩🏻‍🤝‍👩🏿" {
-            self.init(baseEmoji: .twoWomenHoldingHands, skinTones: [.light, .dark])
-        } else if rawValue == "👭🏼" {
-            self.init(baseEmoji: .twoWomenHoldingHands, skinTones: [.mediumLight])
-        } else if rawValue == "👩🏼‍🤝‍👩🏻" {
-            self.init(baseEmoji: .twoWomenHoldingHands, skinTones: [.mediumLight, .light])
-        } else if rawValue == "👩🏼‍🤝‍👩🏽" {
-            self.init(baseEmoji: .twoWomenHoldingHands, skinTones: [.mediumLight, .medium])
-        } else if rawValue == "👩🏼‍🤝‍👩🏾" {
-            self.init(baseEmoji: .twoWomenHoldingHands, skinTones: [.mediumLight, .mediumDark])
-        } else if rawValue == "👩🏼‍🤝‍👩🏿" {
-            self.init(baseEmoji: .twoWomenHoldingHands, skinTones: [.mediumLight, .dark])
-        } else if rawValue == "👭🏽" {
-            self.init(baseEmoji: .twoWomenHoldingHands, skinTones: [.medium])
-        } else if rawValue == "👩🏽‍🤝‍👩🏻" {
-            self.init(baseEmoji: .twoWomenHoldingHands, skinTones: [.medium, .light])
-        } else if rawValue == "👩🏽‍🤝‍👩🏼" {
-            self.init(baseEmoji: .twoWomenHoldingHands, skinTones: [.medium, .mediumLight])
-        } else if rawValue == "👩🏽‍🤝‍👩🏾" {
-            self.init(baseEmoji: .twoWomenHoldingHands, skinTones: [.medium, .mediumDark])
-        } else if rawValue == "👩🏽‍🤝‍👩🏿" {
-            self.init(baseEmoji: .twoWomenHoldingHands, skinTones: [.medium, .dark])
-        } else if rawValue == "👭🏾" {
-            self.init(baseEmoji: .twoWomenHoldingHands, skinTones: [.mediumDark])
-        } else if rawValue == "👩🏾‍🤝‍👩🏻" {
-            self.init(baseEmoji: .twoWomenHoldingHands, skinTones: [.mediumDark, .light])
-        } else if rawValue == "👩🏾‍🤝‍👩🏼" {
-            self.init(baseEmoji: .twoWomenHoldingHands, skinTones: [.mediumDark, .mediumLight])
-        } else if rawValue == "👩🏾‍🤝‍👩🏽" {
-            self.init(baseEmoji: .twoWomenHoldingHands, skinTones: [.mediumDark, .medium])
-        } else if rawValue == "👩🏾‍🤝‍👩🏿" {
-            self.init(baseEmoji: .twoWomenHoldingHands, skinTones: [.mediumDark, .dark])
-        } else if rawValue == "👭🏿" {
-            self.init(baseEmoji: .twoWomenHoldingHands, skinTones: [.dark])
-        } else if rawValue == "👩🏿‍🤝‍👩🏻" {
-            self.init(baseEmoji: .twoWomenHoldingHands, skinTones: [.dark, .light])
-        } else if rawValue == "👩🏿‍🤝‍👩🏼" {
-            self.init(baseEmoji: .twoWomenHoldingHands, skinTones: [.dark, .mediumLight])
-        } else if rawValue == "👩🏿‍🤝‍👩🏽" {
-            self.init(baseEmoji: .twoWomenHoldingHands, skinTones: [.dark, .medium])
-        } else if rawValue == "👩🏿‍🤝‍👩🏾" {
-            self.init(baseEmoji: .twoWomenHoldingHands, skinTones: [.dark, .mediumDark])
-        } else if rawValue == "👫" {
-            self.init(baseEmoji: .manAndWomanHoldingHands, skinTones: nil)
-        } else if rawValue == "👫🏻" {
-            self.init(baseEmoji: .manAndWomanHoldingHands, skinTones: [.light])
-        } else if rawValue == "👩🏻‍🤝‍👨🏼" {
-            self.init(baseEmoji: .manAndWomanHoldingHands, skinTones: [.light, .mediumLight])
-        } else if rawValue == "👩🏻‍🤝‍👨🏽" {
-            self.init(baseEmoji: .manAndWomanHoldingHands, skinTones: [.light, .medium])
-        } else if rawValue == "👩🏻‍🤝‍👨🏾" {
-            self.init(baseEmoji: .manAndWomanHoldingHands, skinTones: [.light, .mediumDark])
-        } else if rawValue == "👩🏻‍🤝‍👨🏿" {
-            self.init(baseEmoji: .manAndWomanHoldingHands, skinTones: [.light, .dark])
-        } else if rawValue == "👫🏼" {
-            self.init(baseEmoji: .manAndWomanHoldingHands, skinTones: [.mediumLight])
-        } else if rawValue == "👩🏼‍🤝‍👨🏻" {
-            self.init(baseEmoji: .manAndWomanHoldingHands, skinTones: [.mediumLight, .light])
-        } else if rawValue == "👩🏼‍🤝‍👨🏽" {
-            self.init(baseEmoji: .manAndWomanHoldingHands, skinTones: [.mediumLight, .medium])
-        } else if rawValue == "👩🏼‍🤝‍👨🏾" {
-            self.init(baseEmoji: .manAndWomanHoldingHands, skinTones: [.mediumLight, .mediumDark])
-        } else if rawValue == "👩🏼‍🤝‍👨🏿" {
-            self.init(baseEmoji: .manAndWomanHoldingHands, skinTones: [.mediumLight, .dark])
-        } else if rawValue == "👫🏽" {
-            self.init(baseEmoji: .manAndWomanHoldingHands, skinTones: [.medium])
-        } else if rawValue == "👩🏽‍🤝‍👨🏻" {
-            self.init(baseEmoji: .manAndWomanHoldingHands, skinTones: [.medium, .light])
-        } else if rawValue == "👩🏽‍🤝‍👨🏼" {
-            self.init(baseEmoji: .manAndWomanHoldingHands, skinTones: [.medium, .mediumLight])
-        } else if rawValue == "👩🏽‍🤝‍👨🏾" {
-            self.init(baseEmoji: .manAndWomanHoldingHands, skinTones: [.medium, .mediumDark])
-        } else if rawValue == "👩🏽‍🤝‍👨🏿" {
-            self.init(baseEmoji: .manAndWomanHoldingHands, skinTones: [.medium, .dark])
-        } else if rawValue == "👫🏾" {
-            self.init(baseEmoji: .manAndWomanHoldingHands, skinTones: [.mediumDark])
-        } else if rawValue == "👩🏾‍🤝‍👨🏻" {
-            self.init(baseEmoji: .manAndWomanHoldingHands, skinTones: [.mediumDark, .light])
-        } else if rawValue == "👩🏾‍🤝‍👨🏼" {
-            self.init(baseEmoji: .manAndWomanHoldingHands, skinTones: [.mediumDark, .mediumLight])
-        } else if rawValue == "👩🏾‍🤝‍👨🏽" {
-            self.init(baseEmoji: .manAndWomanHoldingHands, skinTones: [.mediumDark, .medium])
-        } else if rawValue == "👩🏾‍🤝‍👨🏿" {
-            self.init(baseEmoji: .manAndWomanHoldingHands, skinTones: [.mediumDark, .dark])
-        } else if rawValue == "👫🏿" {
-            self.init(baseEmoji: .manAndWomanHoldingHands, skinTones: [.dark])
-        } else if rawValue == "👩🏿‍🤝‍👨🏻" {
-            self.init(baseEmoji: .manAndWomanHoldingHands, skinTones: [.dark, .light])
-        } else if rawValue == "👩🏿‍🤝‍👨🏼" {
-            self.init(baseEmoji: .manAndWomanHoldingHands, skinTones: [.dark, .mediumLight])
-        } else if rawValue == "👩🏿‍🤝‍👨🏽" {
-            self.init(baseEmoji: .manAndWomanHoldingHands, skinTones: [.dark, .medium])
-        } else if rawValue == "👩🏿‍🤝‍👨🏾" {
-            self.init(baseEmoji: .manAndWomanHoldingHands, skinTones: [.dark, .mediumDark])
-        } else if rawValue == "👬" {
-            self.init(baseEmoji: .twoMenHoldingHands, skinTones: nil)
-        } else if rawValue == "👬🏻" {
-            self.init(baseEmoji: .twoMenHoldingHands, skinTones: [.light])
-        } else if rawValue == "👨🏻‍🤝‍👨🏼" {
-            self.init(baseEmoji: .twoMenHoldingHands, skinTones: [.light, .mediumLight])
-        } else if rawValue == "👨🏻‍🤝‍👨🏽" {
-            self.init(baseEmoji: .twoMenHoldingHands, skinTones: [.light, .medium])
-        } else if rawValue == "👨🏻‍🤝‍👨🏾" {
-            self.init(baseEmoji: .twoMenHoldingHands, skinTones: [.light, .mediumDark])
-        } else if rawValue == "👨🏻‍🤝‍👨🏿" {
-            self.init(baseEmoji: .twoMenHoldingHands, skinTones: [.light, .dark])
-        } else if rawValue == "👬🏼" {
-            self.init(baseEmoji: .twoMenHoldingHands, skinTones: [.mediumLight])
-        } else if rawValue == "👨🏼‍🤝‍👨🏻" {
-            self.init(baseEmoji: .twoMenHoldingHands, skinTones: [.mediumLight, .light])
-        } else if rawValue == "👨🏼‍🤝‍👨🏽" {
-            self.init(baseEmoji: .twoMenHoldingHands, skinTones: [.mediumLight, .medium])
-        } else if rawValue == "👨🏼‍🤝‍👨🏾" {
-            self.init(baseEmoji: .twoMenHoldingHands, skinTones: [.mediumLight, .mediumDark])
-        } else if rawValue == "👨🏼‍🤝‍👨🏿" {
-            self.init(baseEmoji: .twoMenHoldingHands, skinTones: [.mediumLight, .dark])
-        } else if rawValue == "👬🏽" {
-            self.init(baseEmoji: .twoMenHoldingHands, skinTones: [.medium])
-        } else if rawValue == "👨🏽‍🤝‍👨🏻" {
-            self.init(baseEmoji: .twoMenHoldingHands, skinTones: [.medium, .light])
-        } else if rawValue == "👨🏽‍🤝‍👨🏼" {
-            self.init(baseEmoji: .twoMenHoldingHands, skinTones: [.medium, .mediumLight])
-        } else if rawValue == "👨🏽‍🤝‍👨🏾" {
-            self.init(baseEmoji: .twoMenHoldingHands, skinTones: [.medium, .mediumDark])
-        } else if rawValue == "👨🏽‍🤝‍👨🏿" {
-            self.init(baseEmoji: .twoMenHoldingHands, skinTones: [.medium, .dark])
-        } else if rawValue == "👬🏾" {
-            self.init(baseEmoji: .twoMenHoldingHands, skinTones: [.mediumDark])
-        } else if rawValue == "👨🏾‍🤝‍👨🏻" {
-            self.init(baseEmoji: .twoMenHoldingHands, skinTones: [.mediumDark, .light])
-        } else if rawValue == "👨🏾‍🤝‍👨🏼" {
-            self.init(baseEmoji: .twoMenHoldingHands, skinTones: [.mediumDark, .mediumLight])
-        } else if rawValue == "👨🏾‍🤝‍👨🏽" {
-            self.init(baseEmoji: .twoMenHoldingHands, skinTones: [.mediumDark, .medium])
-        } else if rawValue == "👨🏾‍🤝‍👨🏿" {
-            self.init(baseEmoji: .twoMenHoldingHands, skinTones: [.mediumDark, .dark])
-        } else if rawValue == "👬🏿" {
-            self.init(baseEmoji: .twoMenHoldingHands, skinTones: [.dark])
-        } else if rawValue == "👨🏿‍🤝‍👨🏻" {
-            self.init(baseEmoji: .twoMenHoldingHands, skinTones: [.dark, .light])
-        } else if rawValue == "👨🏿‍🤝‍👨🏼" {
-            self.init(baseEmoji: .twoMenHoldingHands, skinTones: [.dark, .mediumLight])
-        } else if rawValue == "👨🏿‍🤝‍👨🏽" {
-            self.init(baseEmoji: .twoMenHoldingHands, skinTones: [.dark, .medium])
-        } else if rawValue == "👨🏿‍🤝‍👨🏾" {
-            self.init(baseEmoji: .twoMenHoldingHands, skinTones: [.dark, .mediumDark])
-        } else if rawValue == "💏" {
-            self.init(baseEmoji: .personKissPerson, skinTones: nil)
-        } else if rawValue == "💏🏻" {
-            self.init(baseEmoji: .personKissPerson, skinTones: [.light])
-        } else if rawValue == "🧑🏻‍❤️‍💋‍🧑🏼" {
-            self.init(baseEmoji: .personKissPerson, skinTones: [.light, .mediumLight])
-        } else if rawValue == "🧑🏻‍❤️‍💋‍🧑🏽" {
-            self.init(baseEmoji: .personKissPerson, skinTones: [.light, .medium])
-        } else if rawValue == "🧑🏻‍❤️‍💋‍🧑🏾" {
-            self.init(baseEmoji: .personKissPerson, skinTones: [.light, .mediumDark])
-        } else if rawValue == "🧑🏻‍❤️‍💋‍🧑🏿" {
-            self.init(baseEmoji: .personKissPerson, skinTones: [.light, .dark])
-        } else if rawValue == "💏🏼" {
-            self.init(baseEmoji: .personKissPerson, skinTones: [.mediumLight])
-        } else if rawValue == "🧑🏼‍❤️‍💋‍🧑🏻" {
-            self.init(baseEmoji: .personKissPerson, skinTones: [.mediumLight, .light])
-        } else if rawValue == "🧑🏼‍❤️‍💋‍🧑🏽" {
-            self.init(baseEmoji: .personKissPerson, skinTones: [.mediumLight, .medium])
-        } else if rawValue == "🧑🏼‍❤️‍💋‍🧑🏾" {
-            self.init(baseEmoji: .personKissPerson, skinTones: [.mediumLight, .mediumDark])
-        } else if rawValue == "🧑🏼‍❤️‍💋‍🧑🏿" {
-            self.init(baseEmoji: .personKissPerson, skinTones: [.mediumLight, .dark])
-        } else if rawValue == "💏🏽" {
-            self.init(baseEmoji: .personKissPerson, skinTones: [.medium])
-        } else if rawValue == "🧑🏽‍❤️‍💋‍🧑🏻" {
-            self.init(baseEmoji: .personKissPerson, skinTones: [.medium, .light])
-        } else if rawValue == "🧑🏽‍❤️‍💋‍🧑🏼" {
-            self.init(baseEmoji: .personKissPerson, skinTones: [.medium, .mediumLight])
-        } else if rawValue == "🧑🏽‍❤️‍💋‍🧑🏾" {
-            self.init(baseEmoji: .personKissPerson, skinTones: [.medium, .mediumDark])
-        } else if rawValue == "🧑🏽‍❤️‍💋‍🧑🏿" {
-            self.init(baseEmoji: .personKissPerson, skinTones: [.medium, .dark])
-        } else if rawValue == "💏🏾" {
-            self.init(baseEmoji: .personKissPerson, skinTones: [.mediumDark])
-        } else if rawValue == "🧑🏾‍❤️‍💋‍🧑🏻" {
-            self.init(baseEmoji: .personKissPerson, skinTones: [.mediumDark, .light])
-        } else if rawValue == "🧑🏾‍❤️‍💋‍🧑🏼" {
-            self.init(baseEmoji: .personKissPerson, skinTones: [.mediumDark, .mediumLight])
-        } else if rawValue == "🧑🏾‍❤️‍💋‍🧑🏽" {
-            self.init(baseEmoji: .personKissPerson, skinTones: [.mediumDark, .medium])
-        } else if rawValue == "🧑🏾‍❤️‍💋‍🧑🏿" {
-            self.init(baseEmoji: .personKissPerson, skinTones: [.mediumDark, .dark])
-        } else if rawValue == "💏🏿" {
-            self.init(baseEmoji: .personKissPerson, skinTones: [.dark])
-        } else if rawValue == "🧑🏿‍❤️‍💋‍🧑🏻" {
-            self.init(baseEmoji: .personKissPerson, skinTones: [.dark, .light])
-        } else if rawValue == "🧑🏿‍❤️‍💋‍🧑🏼" {
-            self.init(baseEmoji: .personKissPerson, skinTones: [.dark, .mediumLight])
-        } else if rawValue == "🧑🏿‍❤️‍💋‍🧑🏽" {
-            self.init(baseEmoji: .personKissPerson, skinTones: [.dark, .medium])
-        } else if rawValue == "🧑🏿‍❤️‍💋‍🧑🏾" {
-            self.init(baseEmoji: .personKissPerson, skinTones: [.dark, .mediumDark])
-        } else if rawValue == "👩‍❤️‍💋‍👨" {
-            self.init(baseEmoji: .womanKissMan, skinTones: nil)
-        } else if rawValue == "👩🏻‍❤️‍💋‍👨🏻" {
-            self.init(baseEmoji: .womanKissMan, skinTones: [.light])
-        } else if rawValue == "👩🏻‍❤️‍💋‍👨🏼" {
-            self.init(baseEmoji: .womanKissMan, skinTones: [.light, .mediumLight])
-        } else if rawValue == "👩🏻‍❤️‍💋‍👨🏽" {
-            self.init(baseEmoji: .womanKissMan, skinTones: [.light, .medium])
-        } else if rawValue == "👩🏻‍❤️‍💋‍👨🏾" {
-            self.init(baseEmoji: .womanKissMan, skinTones: [.light, .mediumDark])
-        } else if rawValue == "👩🏻‍❤️‍💋‍👨🏿" {
-            self.init(baseEmoji: .womanKissMan, skinTones: [.light, .dark])
-        } else if rawValue == "👩🏼‍❤️‍💋‍👨🏼" {
-            self.init(baseEmoji: .womanKissMan, skinTones: [.mediumLight])
-        } else if rawValue == "👩🏼‍❤️‍💋‍👨🏻" {
-            self.init(baseEmoji: .womanKissMan, skinTones: [.mediumLight, .light])
-        } else if rawValue == "👩🏼‍❤️‍💋‍👨🏽" {
-            self.init(baseEmoji: .womanKissMan, skinTones: [.mediumLight, .medium])
-        } else if rawValue == "👩🏼‍❤️‍💋‍👨🏾" {
-            self.init(baseEmoji: .womanKissMan, skinTones: [.mediumLight, .mediumDark])
-        } else if rawValue == "👩🏼‍❤️‍💋‍👨🏿" {
-            self.init(baseEmoji: .womanKissMan, skinTones: [.mediumLight, .dark])
-        } else if rawValue == "👩🏽‍❤️‍💋‍👨🏽" {
-            self.init(baseEmoji: .womanKissMan, skinTones: [.medium])
-        } else if rawValue == "👩🏽‍❤️‍💋‍👨🏻" {
-            self.init(baseEmoji: .womanKissMan, skinTones: [.medium, .light])
-        } else if rawValue == "👩🏽‍❤️‍💋‍👨🏼" {
-            self.init(baseEmoji: .womanKissMan, skinTones: [.medium, .mediumLight])
-        } else if rawValue == "👩🏽‍❤️‍💋‍👨🏾" {
-            self.init(baseEmoji: .womanKissMan, skinTones: [.medium, .mediumDark])
-        } else if rawValue == "👩🏽‍❤️‍💋‍👨🏿" {
-            self.init(baseEmoji: .womanKissMan, skinTones: [.medium, .dark])
-        } else if rawValue == "👩🏾‍❤️‍💋‍👨🏾" {
-            self.init(baseEmoji: .womanKissMan, skinTones: [.mediumDark])
-        } else if rawValue == "👩🏾‍❤️‍💋‍👨🏻" {
-            self.init(baseEmoji: .womanKissMan, skinTones: [.mediumDark, .light])
-        } else if rawValue == "👩🏾‍❤️‍💋‍👨🏼" {
-            self.init(baseEmoji: .womanKissMan, skinTones: [.mediumDark, .mediumLight])
-        } else if rawValue == "👩🏾‍❤️‍💋‍👨🏽" {
-            self.init(baseEmoji: .womanKissMan, skinTones: [.mediumDark, .medium])
-        } else if rawValue == "👩🏾‍❤️‍💋‍👨🏿" {
-            self.init(baseEmoji: .womanKissMan, skinTones: [.mediumDark, .dark])
-        } else if rawValue == "👩🏿‍❤️‍💋‍👨🏿" {
-            self.init(baseEmoji: .womanKissMan, skinTones: [.dark])
-        } else if rawValue == "👩🏿‍❤️‍💋‍👨🏻" {
-            self.init(baseEmoji: .womanKissMan, skinTones: [.dark, .light])
-        } else if rawValue == "👩🏿‍❤️‍💋‍👨🏼" {
-            self.init(baseEmoji: .womanKissMan, skinTones: [.dark, .mediumLight])
-        } else if rawValue == "👩🏿‍❤️‍💋‍👨🏽" {
-            self.init(baseEmoji: .womanKissMan, skinTones: [.dark, .medium])
-        } else if rawValue == "👩🏿‍❤️‍💋‍👨🏾" {
-            self.init(baseEmoji: .womanKissMan, skinTones: [.dark, .mediumDark])
-        } else if rawValue == "👨‍❤️‍💋‍👨" {
-            self.init(baseEmoji: .manKissMan, skinTones: nil)
-        } else if rawValue == "👨🏻‍❤️‍💋‍👨🏻" {
-            self.init(baseEmoji: .manKissMan, skinTones: [.light])
-        } else if rawValue == "👨🏻‍❤️‍💋‍👨🏼" {
-            self.init(baseEmoji: .manKissMan, skinTones: [.light, .mediumLight])
-        } else if rawValue == "👨🏻‍❤️‍💋‍👨🏽" {
-            self.init(baseEmoji: .manKissMan, skinTones: [.light, .medium])
-        } else if rawValue == "👨🏻‍❤️‍💋‍👨🏾" {
-            self.init(baseEmoji: .manKissMan, skinTones: [.light, .mediumDark])
-        } else if rawValue == "👨🏻‍❤️‍💋‍👨🏿" {
-            self.init(baseEmoji: .manKissMan, skinTones: [.light, .dark])
-        } else if rawValue == "👨🏼‍❤️‍💋‍👨🏼" {
-            self.init(baseEmoji: .manKissMan, skinTones: [.mediumLight])
-        } else if rawValue == "👨🏼‍❤️‍💋‍👨🏻" {
-            self.init(baseEmoji: .manKissMan, skinTones: [.mediumLight, .light])
-        } else if rawValue == "👨🏼‍❤️‍💋‍👨🏽" {
-            self.init(baseEmoji: .manKissMan, skinTones: [.mediumLight, .medium])
-        } else if rawValue == "👨🏼‍❤️‍💋‍👨🏾" {
-            self.init(baseEmoji: .manKissMan, skinTones: [.mediumLight, .mediumDark])
-        } else if rawValue == "👨🏼‍❤️‍💋‍👨🏿" {
-            self.init(baseEmoji: .manKissMan, skinTones: [.mediumLight, .dark])
-        } else if rawValue == "👨🏽‍❤️‍💋‍👨🏽" {
-            self.init(baseEmoji: .manKissMan, skinTones: [.medium])
-        } else if rawValue == "👨🏽‍❤️‍💋‍👨🏻" {
-            self.init(baseEmoji: .manKissMan, skinTones: [.medium, .light])
-        } else if rawValue == "👨🏽‍❤️‍💋‍👨🏼" {
-            self.init(baseEmoji: .manKissMan, skinTones: [.medium, .mediumLight])
-        } else if rawValue == "👨🏽‍❤️‍💋‍👨🏾" {
-            self.init(baseEmoji: .manKissMan, skinTones: [.medium, .mediumDark])
-        } else if rawValue == "👨🏽‍❤️‍💋‍👨🏿" {
-            self.init(baseEmoji: .manKissMan, skinTones: [.medium, .dark])
-        } else if rawValue == "👨🏾‍❤️‍💋‍👨🏾" {
-            self.init(baseEmoji: .manKissMan, skinTones: [.mediumDark])
-        } else if rawValue == "👨🏾‍❤️‍💋‍👨🏻" {
-            self.init(baseEmoji: .manKissMan, skinTones: [.mediumDark, .light])
-        } else if rawValue == "👨🏾‍❤️‍💋‍👨🏼" {
-            self.init(baseEmoji: .manKissMan, skinTones: [.mediumDark, .mediumLight])
-        } else if rawValue == "👨🏾‍❤️‍💋‍👨🏽" {
-            self.init(baseEmoji: .manKissMan, skinTones: [.mediumDark, .medium])
-        } else if rawValue == "👨🏾‍❤️‍💋‍👨🏿" {
-            self.init(baseEmoji: .manKissMan, skinTones: [.mediumDark, .dark])
-        } else if rawValue == "👨🏿‍❤️‍💋‍👨🏿" {
-            self.init(baseEmoji: .manKissMan, skinTones: [.dark])
-        } else if rawValue == "👨🏿‍❤️‍💋‍👨🏻" {
-            self.init(baseEmoji: .manKissMan, skinTones: [.dark, .light])
-        } else if rawValue == "👨🏿‍❤️‍💋‍👨🏼" {
-            self.init(baseEmoji: .manKissMan, skinTones: [.dark, .mediumLight])
-        } else if rawValue == "👨🏿‍❤️‍💋‍👨🏽" {
-            self.init(baseEmoji: .manKissMan, skinTones: [.dark, .medium])
-        } else if rawValue == "👨🏿‍❤️‍💋‍👨🏾" {
-            self.init(baseEmoji: .manKissMan, skinTones: [.dark, .mediumDark])
-        } else if rawValue == "👩‍❤️‍💋‍👩" {
-            self.init(baseEmoji: .womanKissWoman, skinTones: nil)
-        } else if rawValue == "👩🏻‍❤️‍💋‍👩🏻" {
-            self.init(baseEmoji: .womanKissWoman, skinTones: [.light])
-        } else if rawValue == "👩🏻‍❤️‍💋‍👩🏼" {
-            self.init(baseEmoji: .womanKissWoman, skinTones: [.light, .mediumLight])
-        } else if rawValue == "👩🏻‍❤️‍💋‍👩🏽" {
-            self.init(baseEmoji: .womanKissWoman, skinTones: [.light, .medium])
-        } else if rawValue == "👩🏻‍❤️‍💋‍👩🏾" {
-            self.init(baseEmoji: .womanKissWoman, skinTones: [.light, .mediumDark])
-        } else if rawValue == "👩🏻‍❤️‍💋‍👩🏿" {
-            self.init(baseEmoji: .womanKissWoman, skinTones: [.light, .dark])
-        } else if rawValue == "👩🏼‍❤️‍💋‍👩🏼" {
-            self.init(baseEmoji: .womanKissWoman, skinTones: [.mediumLight])
-        } else if rawValue == "👩🏼‍❤️‍💋‍👩🏻" {
-            self.init(baseEmoji: .womanKissWoman, skinTones: [.mediumLight, .light])
-        } else if rawValue == "👩🏼‍❤️‍💋‍👩🏽" {
-            self.init(baseEmoji: .womanKissWoman, skinTones: [.mediumLight, .medium])
-        } else if rawValue == "👩🏼‍❤️‍💋‍👩🏾" {
-            self.init(baseEmoji: .womanKissWoman, skinTones: [.mediumLight, .mediumDark])
-        } else if rawValue == "👩🏼‍❤️‍💋‍👩🏿" {
-            self.init(baseEmoji: .womanKissWoman, skinTones: [.mediumLight, .dark])
-        } else if rawValue == "👩🏽‍❤️‍💋‍👩🏽" {
-            self.init(baseEmoji: .womanKissWoman, skinTones: [.medium])
-        } else if rawValue == "👩🏽‍❤️‍💋‍👩🏻" {
-            self.init(baseEmoji: .womanKissWoman, skinTones: [.medium, .light])
-        } else if rawValue == "👩🏽‍❤️‍💋‍👩🏼" {
-            self.init(baseEmoji: .womanKissWoman, skinTones: [.medium, .mediumLight])
-        } else if rawValue == "👩🏽‍❤️‍💋‍👩🏾" {
-            self.init(baseEmoji: .womanKissWoman, skinTones: [.medium, .mediumDark])
-        } else if rawValue == "👩🏽‍❤️‍💋‍👩🏿" {
-            self.init(baseEmoji: .womanKissWoman, skinTones: [.medium, .dark])
-        } else if rawValue == "👩🏾‍❤️‍💋‍👩🏾" {
-            self.init(baseEmoji: .womanKissWoman, skinTones: [.mediumDark])
-        } else if rawValue == "👩🏾‍❤️‍💋‍👩🏻" {
-            self.init(baseEmoji: .womanKissWoman, skinTones: [.mediumDark, .light])
-        } else if rawValue == "👩🏾‍❤️‍💋‍👩🏼" {
-            self.init(baseEmoji: .womanKissWoman, skinTones: [.mediumDark, .mediumLight])
-        } else if rawValue == "👩🏾‍❤️‍💋‍👩🏽" {
-            self.init(baseEmoji: .womanKissWoman, skinTones: [.mediumDark, .medium])
-        } else if rawValue == "👩🏾‍❤️‍💋‍👩🏿" {
-            self.init(baseEmoji: .womanKissWoman, skinTones: [.mediumDark, .dark])
-        } else if rawValue == "👩🏿‍❤️‍💋‍👩🏿" {
-            self.init(baseEmoji: .womanKissWoman, skinTones: [.dark])
-        } else if rawValue == "👩🏿‍❤️‍💋‍👩🏻" {
-            self.init(baseEmoji: .womanKissWoman, skinTones: [.dark, .light])
-        } else if rawValue == "👩🏿‍❤️‍💋‍👩🏼" {
-            self.init(baseEmoji: .womanKissWoman, skinTones: [.dark, .mediumLight])
-        } else if rawValue == "👩🏿‍❤️‍💋‍👩🏽" {
-            self.init(baseEmoji: .womanKissWoman, skinTones: [.dark, .medium])
-        } else if rawValue == "👩🏿‍❤️‍💋‍👩🏾" {
-            self.init(baseEmoji: .womanKissWoman, skinTones: [.dark, .mediumDark])
-        } else if rawValue == "💑" {
-            self.init(baseEmoji: .personHeartPerson, skinTones: nil)
-        } else if rawValue == "💑🏻" {
-            self.init(baseEmoji: .personHeartPerson, skinTones: [.light])
-        } else if rawValue == "🧑🏻‍❤️‍🧑🏼" {
-            self.init(baseEmoji: .personHeartPerson, skinTones: [.light, .mediumLight])
-        } else if rawValue == "🧑🏻‍❤️‍🧑🏽" {
-            self.init(baseEmoji: .personHeartPerson, skinTones: [.light, .medium])
-        } else if rawValue == "🧑🏻‍❤️‍🧑🏾" {
-            self.init(baseEmoji: .personHeartPerson, skinTones: [.light, .mediumDark])
-        } else if rawValue == "🧑🏻‍❤️‍🧑🏿" {
-            self.init(baseEmoji: .personHeartPerson, skinTones: [.light, .dark])
-        } else if rawValue == "💑🏼" {
-            self.init(baseEmoji: .personHeartPerson, skinTones: [.mediumLight])
-        } else if rawValue == "🧑🏼‍❤️‍🧑🏻" {
-            self.init(baseEmoji: .personHeartPerson, skinTones: [.mediumLight, .light])
-        } else if rawValue == "🧑🏼‍❤️‍🧑🏽" {
-            self.init(baseEmoji: .personHeartPerson, skinTones: [.mediumLight, .medium])
-        } else if rawValue == "🧑🏼‍❤️‍🧑🏾" {
-            self.init(baseEmoji: .personHeartPerson, skinTones: [.mediumLight, .mediumDark])
-        } else if rawValue == "🧑🏼‍❤️‍🧑🏿" {
-            self.init(baseEmoji: .personHeartPerson, skinTones: [.mediumLight, .dark])
-        } else if rawValue == "💑🏽" {
-            self.init(baseEmoji: .personHeartPerson, skinTones: [.medium])
-        } else if rawValue == "🧑🏽‍❤️‍🧑🏻" {
-            self.init(baseEmoji: .personHeartPerson, skinTones: [.medium, .light])
-        } else if rawValue == "🧑🏽‍❤️‍🧑🏼" {
-            self.init(baseEmoji: .personHeartPerson, skinTones: [.medium, .mediumLight])
-        } else if rawValue == "🧑🏽‍❤️‍🧑🏾" {
-            self.init(baseEmoji: .personHeartPerson, skinTones: [.medium, .mediumDark])
-        } else if rawValue == "🧑🏽‍❤️‍🧑🏿" {
-            self.init(baseEmoji: .personHeartPerson, skinTones: [.medium, .dark])
-        } else if rawValue == "💑🏾" {
-            self.init(baseEmoji: .personHeartPerson, skinTones: [.mediumDark])
-        } else if rawValue == "🧑🏾‍❤️‍🧑🏻" {
-            self.init(baseEmoji: .personHeartPerson, skinTones: [.mediumDark, .light])
-        } else if rawValue == "🧑🏾‍❤️‍🧑🏼" {
-            self.init(baseEmoji: .personHeartPerson, skinTones: [.mediumDark, .mediumLight])
-        } else if rawValue == "🧑🏾‍❤️‍🧑🏽" {
-            self.init(baseEmoji: .personHeartPerson, skinTones: [.mediumDark, .medium])
-        } else if rawValue == "🧑🏾‍❤️‍🧑🏿" {
-            self.init(baseEmoji: .personHeartPerson, skinTones: [.mediumDark, .dark])
-        } else if rawValue == "💑🏿" {
-            self.init(baseEmoji: .personHeartPerson, skinTones: [.dark])
-        } else if rawValue == "🧑🏿‍❤️‍🧑🏻" {
-            self.init(baseEmoji: .personHeartPerson, skinTones: [.dark, .light])
-        } else if rawValue == "🧑🏿‍❤️‍🧑🏼" {
-            self.init(baseEmoji: .personHeartPerson, skinTones: [.dark, .mediumLight])
-        } else if rawValue == "🧑🏿‍❤️‍🧑🏽" {
-            self.init(baseEmoji: .personHeartPerson, skinTones: [.dark, .medium])
-        } else if rawValue == "🧑🏿‍❤️‍🧑🏾" {
-            self.init(baseEmoji: .personHeartPerson, skinTones: [.dark, .mediumDark])
-        } else if rawValue == "👩‍❤️‍👨" {
-            self.init(baseEmoji: .womanHeartMan, skinTones: nil)
-        } else if rawValue == "👩🏻‍❤️‍👨🏻" {
-            self.init(baseEmoji: .womanHeartMan, skinTones: [.light])
-        } else if rawValue == "👩🏻‍❤️‍👨🏼" {
-            self.init(baseEmoji: .womanHeartMan, skinTones: [.light, .mediumLight])
-        } else if rawValue == "👩🏻‍❤️‍👨🏽" {
-            self.init(baseEmoji: .womanHeartMan, skinTones: [.light, .medium])
-        } else if rawValue == "👩🏻‍❤️‍👨🏾" {
-            self.init(baseEmoji: .womanHeartMan, skinTones: [.light, .mediumDark])
-        } else if rawValue == "👩🏻‍❤️‍👨🏿" {
-            self.init(baseEmoji: .womanHeartMan, skinTones: [.light, .dark])
-        } else if rawValue == "👩🏼‍❤️‍👨🏼" {
-            self.init(baseEmoji: .womanHeartMan, skinTones: [.mediumLight])
-        } else if rawValue == "👩🏼‍❤️‍👨🏻" {
-            self.init(baseEmoji: .womanHeartMan, skinTones: [.mediumLight, .light])
-        } else if rawValue == "👩🏼‍❤️‍👨🏽" {
-            self.init(baseEmoji: .womanHeartMan, skinTones: [.mediumLight, .medium])
-        } else if rawValue == "👩🏼‍❤️‍👨🏾" {
-            self.init(baseEmoji: .womanHeartMan, skinTones: [.mediumLight, .mediumDark])
-        } else if rawValue == "👩🏼‍❤️‍👨🏿" {
-            self.init(baseEmoji: .womanHeartMan, skinTones: [.mediumLight, .dark])
-        } else if rawValue == "👩🏽‍❤️‍👨🏽" {
-            self.init(baseEmoji: .womanHeartMan, skinTones: [.medium])
-        } else if rawValue == "👩🏽‍❤️‍👨🏻" {
-            self.init(baseEmoji: .womanHeartMan, skinTones: [.medium, .light])
-        } else if rawValue == "👩🏽‍❤️‍👨🏼" {
-            self.init(baseEmoji: .womanHeartMan, skinTones: [.medium, .mediumLight])
-        } else if rawValue == "👩🏽‍❤️‍👨🏾" {
-            self.init(baseEmoji: .womanHeartMan, skinTones: [.medium, .mediumDark])
-        } else if rawValue == "👩🏽‍❤️‍👨🏿" {
-            self.init(baseEmoji: .womanHeartMan, skinTones: [.medium, .dark])
-        } else if rawValue == "👩🏾‍❤️‍👨🏾" {
-            self.init(baseEmoji: .womanHeartMan, skinTones: [.mediumDark])
-        } else if rawValue == "👩🏾‍❤️‍👨🏻" {
-            self.init(baseEmoji: .womanHeartMan, skinTones: [.mediumDark, .light])
-        } else if rawValue == "👩🏾‍❤️‍👨🏼" {
-            self.init(baseEmoji: .womanHeartMan, skinTones: [.mediumDark, .mediumLight])
-        } else if rawValue == "👩🏾‍❤️‍👨🏽" {
-            self.init(baseEmoji: .womanHeartMan, skinTones: [.mediumDark, .medium])
-        } else if rawValue == "👩🏾‍❤️‍👨🏿" {
-            self.init(baseEmoji: .womanHeartMan, skinTones: [.mediumDark, .dark])
-        } else if rawValue == "👩🏿‍❤️‍👨🏿" {
-            self.init(baseEmoji: .womanHeartMan, skinTones: [.dark])
-        } else if rawValue == "👩🏿‍❤️‍👨🏻" {
-            self.init(baseEmoji: .womanHeartMan, skinTones: [.dark, .light])
-        } else if rawValue == "👩🏿‍❤️‍👨🏼" {
-            self.init(baseEmoji: .womanHeartMan, skinTones: [.dark, .mediumLight])
-        } else if rawValue == "👩🏿‍❤️‍👨🏽" {
-            self.init(baseEmoji: .womanHeartMan, skinTones: [.dark, .medium])
-        } else if rawValue == "👩🏿‍❤️‍👨🏾" {
-            self.init(baseEmoji: .womanHeartMan, skinTones: [.dark, .mediumDark])
-        } else if rawValue == "👨‍❤️‍👨" {
-            self.init(baseEmoji: .manHeartMan, skinTones: nil)
-        } else if rawValue == "👨🏻‍❤️‍👨🏻" {
-            self.init(baseEmoji: .manHeartMan, skinTones: [.light])
-        } else if rawValue == "👨🏻‍❤️‍👨🏼" {
-            self.init(baseEmoji: .manHeartMan, skinTones: [.light, .mediumLight])
-        } else if rawValue == "👨🏻‍❤️‍👨🏽" {
-            self.init(baseEmoji: .manHeartMan, skinTones: [.light, .medium])
-        } else if rawValue == "👨🏻‍❤️‍👨🏾" {
-            self.init(baseEmoji: .manHeartMan, skinTones: [.light, .mediumDark])
-        } else if rawValue == "👨🏻‍❤️‍👨🏿" {
-            self.init(baseEmoji: .manHeartMan, skinTones: [.light, .dark])
-        } else if rawValue == "👨🏼‍❤️‍👨🏼" {
-            self.init(baseEmoji: .manHeartMan, skinTones: [.mediumLight])
-        } else if rawValue == "👨🏼‍❤️‍👨🏻" {
-            self.init(baseEmoji: .manHeartMan, skinTones: [.mediumLight, .light])
-        } else if rawValue == "👨🏼‍❤️‍👨🏽" {
-            self.init(baseEmoji: .manHeartMan, skinTones: [.mediumLight, .medium])
-        } else if rawValue == "👨🏼‍❤️‍👨🏾" {
-            self.init(baseEmoji: .manHeartMan, skinTones: [.mediumLight, .mediumDark])
-        } else if rawValue == "👨🏼‍❤️‍👨🏿" {
-            self.init(baseEmoji: .manHeartMan, skinTones: [.mediumLight, .dark])
-        } else if rawValue == "👨🏽‍❤️‍👨🏽" {
-            self.init(baseEmoji: .manHeartMan, skinTones: [.medium])
-        } else if rawValue == "👨🏽‍❤️‍👨🏻" {
-            self.init(baseEmoji: .manHeartMan, skinTones: [.medium, .light])
-        } else if rawValue == "👨🏽‍❤️‍👨🏼" {
-            self.init(baseEmoji: .manHeartMan, skinTones: [.medium, .mediumLight])
-        } else if rawValue == "👨🏽‍❤️‍👨🏾" {
-            self.init(baseEmoji: .manHeartMan, skinTones: [.medium, .mediumDark])
-        } else if rawValue == "👨🏽‍❤️‍👨🏿" {
-            self.init(baseEmoji: .manHeartMan, skinTones: [.medium, .dark])
-        } else if rawValue == "👨🏾‍❤️‍👨🏾" {
-            self.init(baseEmoji: .manHeartMan, skinTones: [.mediumDark])
-        } else if rawValue == "👨🏾‍❤️‍👨🏻" {
-            self.init(baseEmoji: .manHeartMan, skinTones: [.mediumDark, .light])
-        } else if rawValue == "👨🏾‍❤️‍👨🏼" {
-            self.init(baseEmoji: .manHeartMan, skinTones: [.mediumDark, .mediumLight])
-        } else if rawValue == "👨🏾‍❤️‍👨🏽" {
-            self.init(baseEmoji: .manHeartMan, skinTones: [.mediumDark, .medium])
-        } else if rawValue == "👨🏾‍❤️‍👨🏿" {
-            self.init(baseEmoji: .manHeartMan, skinTones: [.mediumDark, .dark])
-        } else if rawValue == "👨🏿‍❤️‍👨🏿" {
-            self.init(baseEmoji: .manHeartMan, skinTones: [.dark])
-        } else if rawValue == "👨🏿‍❤️‍👨🏻" {
-            self.init(baseEmoji: .manHeartMan, skinTones: [.dark, .light])
-        } else if rawValue == "👨🏿‍❤️‍👨🏼" {
-            self.init(baseEmoji: .manHeartMan, skinTones: [.dark, .mediumLight])
-        } else if rawValue == "👨🏿‍❤️‍👨🏽" {
-            self.init(baseEmoji: .manHeartMan, skinTones: [.dark, .medium])
-        } else if rawValue == "👨🏿‍❤️‍👨🏾" {
-            self.init(baseEmoji: .manHeartMan, skinTones: [.dark, .mediumDark])
-        } else if rawValue == "👩‍❤️‍👩" {
-            self.init(baseEmoji: .womanHeartWoman, skinTones: nil)
-        } else if rawValue == "👩🏻‍❤️‍👩🏻" {
-            self.init(baseEmoji: .womanHeartWoman, skinTones: [.light])
-        } else if rawValue == "👩🏻‍❤️‍👩🏼" {
-            self.init(baseEmoji: .womanHeartWoman, skinTones: [.light, .mediumLight])
-        } else if rawValue == "👩🏻‍❤️‍👩🏽" {
-            self.init(baseEmoji: .womanHeartWoman, skinTones: [.light, .medium])
-        } else if rawValue == "👩🏻‍❤️‍👩🏾" {
-            self.init(baseEmoji: .womanHeartWoman, skinTones: [.light, .mediumDark])
-        } else if rawValue == "👩🏻‍❤️‍👩🏿" {
-            self.init(baseEmoji: .womanHeartWoman, skinTones: [.light, .dark])
-        } else if rawValue == "👩🏼‍❤️‍👩🏼" {
-            self.init(baseEmoji: .womanHeartWoman, skinTones: [.mediumLight])
-        } else if rawValue == "👩🏼‍❤️‍👩🏻" {
-            self.init(baseEmoji: .womanHeartWoman, skinTones: [.mediumLight, .light])
-        } else if rawValue == "👩🏼‍❤️‍👩🏽" {
-            self.init(baseEmoji: .womanHeartWoman, skinTones: [.mediumLight, .medium])
-        } else if rawValue == "👩🏼‍❤️‍👩🏾" {
-            self.init(baseEmoji: .womanHeartWoman, skinTones: [.mediumLight, .mediumDark])
-        } else if rawValue == "👩🏼‍❤️‍👩🏿" {
-            self.init(baseEmoji: .womanHeartWoman, skinTones: [.mediumLight, .dark])
-        } else if rawValue == "👩🏽‍❤️‍👩🏽" {
-            self.init(baseEmoji: .womanHeartWoman, skinTones: [.medium])
-        } else if rawValue == "👩🏽‍❤️‍👩🏻" {
-            self.init(baseEmoji: .womanHeartWoman, skinTones: [.medium, .light])
-        } else if rawValue == "👩🏽‍❤️‍👩🏼" {
-            self.init(baseEmoji: .womanHeartWoman, skinTones: [.medium, .mediumLight])
-        } else if rawValue == "👩🏽‍❤️‍👩🏾" {
-            self.init(baseEmoji: .womanHeartWoman, skinTones: [.medium, .mediumDark])
-        } else if rawValue == "👩🏽‍❤️‍👩🏿" {
-            self.init(baseEmoji: .womanHeartWoman, skinTones: [.medium, .dark])
-        } else if rawValue == "👩🏾‍❤️‍👩🏾" {
-            self.init(baseEmoji: .womanHeartWoman, skinTones: [.mediumDark])
-        } else if rawValue == "👩🏾‍❤️‍👩🏻" {
-            self.init(baseEmoji: .womanHeartWoman, skinTones: [.mediumDark, .light])
-        } else if rawValue == "👩🏾‍❤️‍👩🏼" {
-            self.init(baseEmoji: .womanHeartWoman, skinTones: [.mediumDark, .mediumLight])
-        } else if rawValue == "👩🏾‍❤️‍👩🏽" {
-            self.init(baseEmoji: .womanHeartWoman, skinTones: [.mediumDark, .medium])
-        } else if rawValue == "👩🏾‍❤️‍👩🏿" {
-            self.init(baseEmoji: .womanHeartWoman, skinTones: [.mediumDark, .dark])
-        } else if rawValue == "👩🏿‍❤️‍👩🏿" {
-            self.init(baseEmoji: .womanHeartWoman, skinTones: [.dark])
-        } else if rawValue == "👩🏿‍❤️‍👩🏻" {
-            self.init(baseEmoji: .womanHeartWoman, skinTones: [.dark, .light])
-        } else if rawValue == "👩🏿‍❤️‍👩🏼" {
-            self.init(baseEmoji: .womanHeartWoman, skinTones: [.dark, .mediumLight])
-        } else if rawValue == "👩🏿‍❤️‍👩🏽" {
-            self.init(baseEmoji: .womanHeartWoman, skinTones: [.dark, .medium])
-        } else if rawValue == "👩🏿‍❤️‍👩🏾" {
-            self.init(baseEmoji: .womanHeartWoman, skinTones: [.dark, .mediumDark])
-        } else if rawValue == "👪" {
-            self.init(baseEmoji: .family, skinTones: nil)
-        } else if rawValue == "👨‍👩‍👦" {
-            self.init(baseEmoji: .manWomanBoy, skinTones: nil)
-        } else if rawValue == "👨‍👩‍👧" {
-            self.init(baseEmoji: .manWomanGirl, skinTones: nil)
-        } else if rawValue == "👨‍👩‍👧‍👦" {
-            self.init(baseEmoji: .manWomanGirlBoy, skinTones: nil)
-        } else if rawValue == "👨‍👩‍👦‍👦" {
-            self.init(baseEmoji: .manWomanBoyBoy, skinTones: nil)
-        } else if rawValue == "👨‍👩‍👧‍👧" {
-            self.init(baseEmoji: .manWomanGirlGirl, skinTones: nil)
-        } else if rawValue == "👨‍👨‍👦" {
-            self.init(baseEmoji: .manManBoy, skinTones: nil)
-        } else if rawValue == "👨‍👨‍👧" {
-            self.init(baseEmoji: .manManGirl, skinTones: nil)
-        } else if rawValue == "👨‍👨‍👧‍👦" {
-            self.init(baseEmoji: .manManGirlBoy, skinTones: nil)
-        } else if rawValue == "👨‍👨‍👦‍👦" {
-            self.init(baseEmoji: .manManBoyBoy, skinTones: nil)
-        } else if rawValue == "👨‍👨‍👧‍👧" {
-            self.init(baseEmoji: .manManGirlGirl, skinTones: nil)
-        } else if rawValue == "👩‍👩‍👦" {
-            self.init(baseEmoji: .womanWomanBoy, skinTones: nil)
-        } else if rawValue == "👩‍👩‍👧" {
-            self.init(baseEmoji: .womanWomanGirl, skinTones: nil)
-        } else if rawValue == "👩‍👩‍👧‍👦" {
-            self.init(baseEmoji: .womanWomanGirlBoy, skinTones: nil)
-        } else if rawValue == "👩‍👩‍👦‍👦" {
-            self.init(baseEmoji: .womanWomanBoyBoy, skinTones: nil)
-        } else if rawValue == "👩‍👩‍👧‍👧" {
-            self.init(baseEmoji: .womanWomanGirlGirl, skinTones: nil)
-        } else if rawValue == "👨‍👦" {
-            self.init(baseEmoji: .manBoy, skinTones: nil)
-        } else if rawValue == "👨‍👦‍👦" {
-            self.init(baseEmoji: .manBoyBoy, skinTones: nil)
-        } else if rawValue == "👨‍👧" {
-            self.init(baseEmoji: .manGirl, skinTones: nil)
-        } else if rawValue == "👨‍👧‍👦" {
-            self.init(baseEmoji: .manGirlBoy, skinTones: nil)
-        } else if rawValue == "👨‍👧‍👧" {
-            self.init(baseEmoji: .manGirlGirl, skinTones: nil)
-        } else if rawValue == "👩‍👦" {
-            self.init(baseEmoji: .womanBoy, skinTones: nil)
-        } else if rawValue == "👩‍👦‍👦" {
-            self.init(baseEmoji: .womanBoyBoy, skinTones: nil)
-        } else if rawValue == "👩‍👧" {
-            self.init(baseEmoji: .womanGirl, skinTones: nil)
-        } else if rawValue == "👩‍👧‍👦" {
-            self.init(baseEmoji: .womanGirlBoy, skinTones: nil)
-        } else if rawValue == "👩‍👧‍👧" {
-            self.init(baseEmoji: .womanGirlGirl, skinTones: nil)
-        } else if rawValue == "🗣️" {
-            self.init(baseEmoji: .speakingHeadInSilhouette, skinTones: nil)
-        } else if rawValue == "👤" {
-            self.init(baseEmoji: .bustInSilhouette, skinTones: nil)
-        } else if rawValue == "👥" {
-            self.init(baseEmoji: .bustsInSilhouette, skinTones: nil)
-        } else if rawValue == "🫂" {
-            self.init(baseEmoji: .peopleHugging, skinTones: nil)
-        } else if rawValue == "👣" {
-            self.init(baseEmoji: .footprints, skinTones: nil)
-        } else if rawValue == "🏻" {
-            self.init(baseEmoji: .skinTone2, skinTones: nil)
-        } else if rawValue == "🏼" {
-            self.init(baseEmoji: .skinTone3, skinTones: nil)
-        } else if rawValue == "🏽" {
-            self.init(baseEmoji: .skinTone4, skinTones: nil)
-        } else if rawValue == "🏾" {
-            self.init(baseEmoji: .skinTone5, skinTones: nil)
-        } else if rawValue == "🏿" {
-            self.init(baseEmoji: .skinTone6, skinTones: nil)
-        } else if rawValue == "🐵" {
-            self.init(baseEmoji: .monkeyFace, skinTones: nil)
-        } else if rawValue == "🐒" {
-            self.init(baseEmoji: .monkey, skinTones: nil)
-        } else if rawValue == "🦍" {
-            self.init(baseEmoji: .gorilla, skinTones: nil)
-        } else if rawValue == "🦧" {
-            self.init(baseEmoji: .orangutan, skinTones: nil)
-        } else if rawValue == "🐶" {
-            self.init(baseEmoji: .dog, skinTones: nil)
-        } else if rawValue == "🐕" {
-            self.init(baseEmoji: .dog2, skinTones: nil)
-        } else if rawValue == "🦮" {
-            self.init(baseEmoji: .guideDog, skinTones: nil)
-        } else if rawValue == "🐕‍🦺" {
-            self.init(baseEmoji: .serviceDog, skinTones: nil)
-        } else if rawValue == "🐩" {
-            self.init(baseEmoji: .poodle, skinTones: nil)
-        } else if rawValue == "🐺" {
-            self.init(baseEmoji: .wolf, skinTones: nil)
-        } else if rawValue == "🦊" {
-            self.init(baseEmoji: .foxFace, skinTones: nil)
-        } else if rawValue == "🦝" {
-            self.init(baseEmoji: .raccoon, skinTones: nil)
-        } else if rawValue == "🐱" {
-            self.init(baseEmoji: .cat, skinTones: nil)
-        } else if rawValue == "🐈" {
-            self.init(baseEmoji: .cat2, skinTones: nil)
-        } else if rawValue == "🐈‍⬛" {
-            self.init(baseEmoji: .blackCat, skinTones: nil)
-        } else if rawValue == "🦁" {
-            self.init(baseEmoji: .lionFace, skinTones: nil)
-        } else if rawValue == "🐯" {
-            self.init(baseEmoji: .tiger, skinTones: nil)
-        } else if rawValue == "🐅" {
-            self.init(baseEmoji: .tiger2, skinTones: nil)
-        } else if rawValue == "🐆" {
-            self.init(baseEmoji: .leopard, skinTones: nil)
-        } else if rawValue == "🐴" {
-            self.init(baseEmoji: .horse, skinTones: nil)
-        } else if rawValue == "🐎" {
-            self.init(baseEmoji: .racehorse, skinTones: nil)
-        } else if rawValue == "🦄" {
-            self.init(baseEmoji: .unicornFace, skinTones: nil)
-        } else if rawValue == "🦓" {
-            self.init(baseEmoji: .zebraFace, skinTones: nil)
-        } else if rawValue == "🦌" {
-            self.init(baseEmoji: .deer, skinTones: nil)
-        } else if rawValue == "🦬" {
-            self.init(baseEmoji: .bison, skinTones: nil)
-        } else if rawValue == "🐮" {
-            self.init(baseEmoji: .cow, skinTones: nil)
-        } else if rawValue == "🐂" {
-            self.init(baseEmoji: .ox, skinTones: nil)
-        } else if rawValue == "🐃" {
-            self.init(baseEmoji: .waterBuffalo, skinTones: nil)
-        } else if rawValue == "🐄" {
-            self.init(baseEmoji: .cow2, skinTones: nil)
-        } else if rawValue == "🐷" {
-            self.init(baseEmoji: .pig, skinTones: nil)
-        } else if rawValue == "🐖" {
-            self.init(baseEmoji: .pig2, skinTones: nil)
-        } else if rawValue == "🐗" {
-            self.init(baseEmoji: .boar, skinTones: nil)
-        } else if rawValue == "🐽" {
-            self.init(baseEmoji: .pigNose, skinTones: nil)
-        } else if rawValue == "🐏" {
-            self.init(baseEmoji: .ram, skinTones: nil)
-        } else if rawValue == "🐑" {
-            self.init(baseEmoji: .sheep, skinTones: nil)
-        } else if rawValue == "🐐" {
-            self.init(baseEmoji: .goat, skinTones: nil)
-        } else if rawValue == "🐪" {
-            self.init(baseEmoji: .dromedaryCamel, skinTones: nil)
-        } else if rawValue == "🐫" {
-            self.init(baseEmoji: .camel, skinTones: nil)
-        } else if rawValue == "🦙" {
-            self.init(baseEmoji: .llama, skinTones: nil)
-        } else if rawValue == "🦒" {
-            self.init(baseEmoji: .giraffeFace, skinTones: nil)
-        } else if rawValue == "🐘" {
-            self.init(baseEmoji: .elephant, skinTones: nil)
-        } else if rawValue == "🦣" {
-            self.init(baseEmoji: .mammoth, skinTones: nil)
-        } else if rawValue == "🦏" {
-            self.init(baseEmoji: .rhinoceros, skinTones: nil)
-        } else if rawValue == "🦛" {
-            self.init(baseEmoji: .hippopotamus, skinTones: nil)
-        } else if rawValue == "🐭" {
-            self.init(baseEmoji: .mouse, skinTones: nil)
-        } else if rawValue == "🐁" {
-            self.init(baseEmoji: .mouse2, skinTones: nil)
-        } else if rawValue == "🐀" {
-            self.init(baseEmoji: .rat, skinTones: nil)
-        } else if rawValue == "🐹" {
-            self.init(baseEmoji: .hamster, skinTones: nil)
-        } else if rawValue == "🐰" {
-            self.init(baseEmoji: .rabbit, skinTones: nil)
-        } else if rawValue == "🐇" {
-            self.init(baseEmoji: .rabbit2, skinTones: nil)
-        } else if rawValue == "🐿️" {
-            self.init(baseEmoji: .chipmunk, skinTones: nil)
-        } else if rawValue == "🦫" {
-            self.init(baseEmoji: .beaver, skinTones: nil)
-        } else if rawValue == "🦔" {
-            self.init(baseEmoji: .hedgehog, skinTones: nil)
-        } else if rawValue == "🦇" {
-            self.init(baseEmoji: .bat, skinTones: nil)
-        } else if rawValue == "🐻" {
-            self.init(baseEmoji: .bear, skinTones: nil)
-        } else if rawValue == "🐻‍❄️" {
-            self.init(baseEmoji: .polarBear, skinTones: nil)
-        } else if rawValue == "🐨" {
-            self.init(baseEmoji: .koala, skinTones: nil)
-        } else if rawValue == "🐼" {
-            self.init(baseEmoji: .pandaFace, skinTones: nil)
-        } else if rawValue == "🦥" {
-            self.init(baseEmoji: .sloth, skinTones: nil)
-        } else if rawValue == "🦦" {
-            self.init(baseEmoji: .otter, skinTones: nil)
-        } else if rawValue == "🦨" {
-            self.init(baseEmoji: .skunk, skinTones: nil)
-        } else if rawValue == "🦘" {
-            self.init(baseEmoji: .kangaroo, skinTones: nil)
-        } else if rawValue == "🦡" {
-            self.init(baseEmoji: .badger, skinTones: nil)
-        } else if rawValue == "🐾" {
-            self.init(baseEmoji: .feet, skinTones: nil)
-        } else if rawValue == "🦃" {
-            self.init(baseEmoji: .turkey, skinTones: nil)
-        } else if rawValue == "🐔" {
-            self.init(baseEmoji: .chicken, skinTones: nil)
-        } else if rawValue == "🐓" {
-            self.init(baseEmoji: .rooster, skinTones: nil)
-        } else if rawValue == "🐣" {
-            self.init(baseEmoji: .hatchingChick, skinTones: nil)
-        } else if rawValue == "🐤" {
-            self.init(baseEmoji: .babyChick, skinTones: nil)
-        } else if rawValue == "🐥" {
-            self.init(baseEmoji: .hatchedChick, skinTones: nil)
-        } else if rawValue == "🐦" {
-            self.init(baseEmoji: .bird, skinTones: nil)
-        } else if rawValue == "🐧" {
-            self.init(baseEmoji: .penguin, skinTones: nil)
-        } else if rawValue == "🕊️" {
-            self.init(baseEmoji: .doveOfPeace, skinTones: nil)
-        } else if rawValue == "🦅" {
-            self.init(baseEmoji: .eagle, skinTones: nil)
-        } else if rawValue == "🦆" {
-            self.init(baseEmoji: .duck, skinTones: nil)
-        } else if rawValue == "🦢" {
-            self.init(baseEmoji: .swan, skinTones: nil)
-        } else if rawValue == "🦉" {
-            self.init(baseEmoji: .owl, skinTones: nil)
-        } else if rawValue == "🦤" {
-            self.init(baseEmoji: .dodo, skinTones: nil)
-        } else if rawValue == "🪶" {
-            self.init(baseEmoji: .feather, skinTones: nil)
-        } else if rawValue == "🦩" {
-            self.init(baseEmoji: .flamingo, skinTones: nil)
-        } else if rawValue == "🦚" {
-            self.init(baseEmoji: .peacock, skinTones: nil)
-        } else if rawValue == "🦜" {
-            self.init(baseEmoji: .parrot, skinTones: nil)
-        } else if rawValue == "🐸" {
-            self.init(baseEmoji: .frog, skinTones: nil)
-        } else if rawValue == "🐊" {
-            self.init(baseEmoji: .crocodile, skinTones: nil)
-        } else if rawValue == "🐢" {
-            self.init(baseEmoji: .turtle, skinTones: nil)
-        } else if rawValue == "🦎" {
-            self.init(baseEmoji: .lizard, skinTones: nil)
-        } else if rawValue == "🐍" {
-            self.init(baseEmoji: .snake, skinTones: nil)
-        } else if rawValue == "🐲" {
-            self.init(baseEmoji: .dragonFace, skinTones: nil)
-        } else if rawValue == "🐉" {
-            self.init(baseEmoji: .dragon, skinTones: nil)
-        } else if rawValue == "🦕" {
-            self.init(baseEmoji: .sauropod, skinTones: nil)
-        } else if rawValue == "🦖" {
-            self.init(baseEmoji: .tRex, skinTones: nil)
-        } else if rawValue == "🐳" {
-            self.init(baseEmoji: .whale, skinTones: nil)
-        } else if rawValue == "🐋" {
-            self.init(baseEmoji: .whale2, skinTones: nil)
-        } else if rawValue == "🐬" {
-            self.init(baseEmoji: .dolphin, skinTones: nil)
-        } else if rawValue == "🦭" {
-            self.init(baseEmoji: .seal, skinTones: nil)
-        } else if rawValue == "🐟" {
-            self.init(baseEmoji: .fish, skinTones: nil)
-        } else if rawValue == "🐠" {
-            self.init(baseEmoji: .tropicalFish, skinTones: nil)
-        } else if rawValue == "🐡" {
-            self.init(baseEmoji: .blowfish, skinTones: nil)
-        } else if rawValue == "🦈" {
-            self.init(baseEmoji: .shark, skinTones: nil)
-        } else if rawValue == "🐙" {
-            self.init(baseEmoji: .octopus, skinTones: nil)
-        } else if rawValue == "🐚" {
-            self.init(baseEmoji: .shell, skinTones: nil)
-        } else if rawValue == "🪸" {
-            self.init(baseEmoji: .coral, skinTones: nil)
-        } else if rawValue == "🐌" {
-            self.init(baseEmoji: .snail, skinTones: nil)
-        } else if rawValue == "🦋" {
-            self.init(baseEmoji: .butterfly, skinTones: nil)
-        } else if rawValue == "🐛" {
-            self.init(baseEmoji: .bug, skinTones: nil)
-        } else if rawValue == "🐜" {
-            self.init(baseEmoji: .ant, skinTones: nil)
-        } else if rawValue == "🐝" {
-            self.init(baseEmoji: .bee, skinTones: nil)
-        } else if rawValue == "🪲" {
-            self.init(baseEmoji: .beetle, skinTones: nil)
-        } else if rawValue == "🐞" {
-            self.init(baseEmoji: .ladybug, skinTones: nil)
-        } else if rawValue == "🦗" {
-            self.init(baseEmoji: .cricket, skinTones: nil)
-        } else if rawValue == "🪳" {
-            self.init(baseEmoji: .cockroach, skinTones: nil)
-        } else if rawValue == "🕷️" {
-            self.init(baseEmoji: .spider, skinTones: nil)
-        } else if rawValue == "🕸️" {
-            self.init(baseEmoji: .spiderWeb, skinTones: nil)
-        } else if rawValue == "🦂" {
-            self.init(baseEmoji: .scorpion, skinTones: nil)
-        } else if rawValue == "🦟" {
-            self.init(baseEmoji: .mosquito, skinTones: nil)
-        } else if rawValue == "🪰" {
-            self.init(baseEmoji: .fly, skinTones: nil)
-        } else if rawValue == "🪱" {
-            self.init(baseEmoji: .worm, skinTones: nil)
-        } else if rawValue == "🦠" {
-            self.init(baseEmoji: .microbe, skinTones: nil)
-        } else if rawValue == "💐" {
-            self.init(baseEmoji: .bouquet, skinTones: nil)
-        } else if rawValue == "🌸" {
-            self.init(baseEmoji: .cherryBlossom, skinTones: nil)
-        } else if rawValue == "💮" {
-            self.init(baseEmoji: .whiteFlower, skinTones: nil)
-        } else if rawValue == "🪷" {
-            self.init(baseEmoji: .lotus, skinTones: nil)
-        } else if rawValue == "🏵️" {
-            self.init(baseEmoji: .rosette, skinTones: nil)
-        } else if rawValue == "🌹" {
-            self.init(baseEmoji: .rose, skinTones: nil)
-        } else if rawValue == "🥀" {
-            self.init(baseEmoji: .wiltedFlower, skinTones: nil)
-        } else if rawValue == "🌺" {
-            self.init(baseEmoji: .hibiscus, skinTones: nil)
-        } else if rawValue == "🌻" {
-            self.init(baseEmoji: .sunflower, skinTones: nil)
-        } else if rawValue == "🌼" {
-            self.init(baseEmoji: .blossom, skinTones: nil)
-        } else if rawValue == "🌷" {
-            self.init(baseEmoji: .tulip, skinTones: nil)
-        } else if rawValue == "🌱" {
-            self.init(baseEmoji: .seedling, skinTones: nil)
-        } else if rawValue == "🪴" {
-            self.init(baseEmoji: .pottedPlant, skinTones: nil)
-        } else if rawValue == "🌲" {
-            self.init(baseEmoji: .evergreenTree, skinTones: nil)
-        } else if rawValue == "🌳" {
-            self.init(baseEmoji: .deciduousTree, skinTones: nil)
-        } else if rawValue == "🌴" {
-            self.init(baseEmoji: .palmTree, skinTones: nil)
-        } else if rawValue == "🌵" {
-            self.init(baseEmoji: .cactus, skinTones: nil)
-        } else if rawValue == "🌾" {
-            self.init(baseEmoji: .earOfRice, skinTones: nil)
-        } else if rawValue == "🌿" {
-            self.init(baseEmoji: .herb, skinTones: nil)
-        } else if rawValue == "☘️" {
-            self.init(baseEmoji: .shamrock, skinTones: nil)
-        } else if rawValue == "🍀" {
-            self.init(baseEmoji: .fourLeafClover, skinTones: nil)
-        } else if rawValue == "🍁" {
-            self.init(baseEmoji: .mapleLeaf, skinTones: nil)
-        } else if rawValue == "🍂" {
-            self.init(baseEmoji: .fallenLeaf, skinTones: nil)
-        } else if rawValue == "🍃" {
-            self.init(baseEmoji: .leaves, skinTones: nil)
-        } else if rawValue == "🪹" {
-            self.init(baseEmoji: .emptyNest, skinTones: nil)
-        } else if rawValue == "🪺" {
-            self.init(baseEmoji: .nestWithEggs, skinTones: nil)
-        } else if rawValue == "🍇" {
-            self.init(baseEmoji: .grapes, skinTones: nil)
-        } else if rawValue == "🍈" {
-            self.init(baseEmoji: .melon, skinTones: nil)
-        } else if rawValue == "🍉" {
-            self.init(baseEmoji: .watermelon, skinTones: nil)
-        } else if rawValue == "🍊" {
-            self.init(baseEmoji: .tangerine, skinTones: nil)
-        } else if rawValue == "🍋" {
-            self.init(baseEmoji: .lemon, skinTones: nil)
-        } else if rawValue == "🍌" {
-            self.init(baseEmoji: .banana, skinTones: nil)
-        } else if rawValue == "🍍" {
-            self.init(baseEmoji: .pineapple, skinTones: nil)
-        } else if rawValue == "🥭" {
-            self.init(baseEmoji: .mango, skinTones: nil)
-        } else if rawValue == "🍎" {
-            self.init(baseEmoji: .apple, skinTones: nil)
-        } else if rawValue == "🍏" {
-            self.init(baseEmoji: .greenApple, skinTones: nil)
-        } else if rawValue == "🍐" {
-            self.init(baseEmoji: .pear, skinTones: nil)
-        } else if rawValue == "🍑" {
-            self.init(baseEmoji: .peach, skinTones: nil)
-        } else if rawValue == "🍒" {
-            self.init(baseEmoji: .cherries, skinTones: nil)
-        } else if rawValue == "🍓" {
-            self.init(baseEmoji: .strawberry, skinTones: nil)
-        } else if rawValue == "🫐" {
-            self.init(baseEmoji: .blueberries, skinTones: nil)
-        } else if rawValue == "🥝" {
-            self.init(baseEmoji: .kiwifruit, skinTones: nil)
-        } else if rawValue == "🍅" {
-            self.init(baseEmoji: .tomato, skinTones: nil)
-        } else if rawValue == "🫒" {
-            self.init(baseEmoji: .olive, skinTones: nil)
-        } else if rawValue == "🥥" {
-            self.init(baseEmoji: .coconut, skinTones: nil)
-        } else if rawValue == "🥑" {
-            self.init(baseEmoji: .avocado, skinTones: nil)
-        } else if rawValue == "🍆" {
-            self.init(baseEmoji: .eggplant, skinTones: nil)
-        } else if rawValue == "🥔" {
-            self.init(baseEmoji: .potato, skinTones: nil)
-        } else if rawValue == "🥕" {
-            self.init(baseEmoji: .carrot, skinTones: nil)
-        } else if rawValue == "🌽" {
-            self.init(baseEmoji: .corn, skinTones: nil)
-        } else if rawValue == "🌶️" {
-            self.init(baseEmoji: .hotPepper, skinTones: nil)
-        } else if rawValue == "🫑" {
-            self.init(baseEmoji: .bellPepper, skinTones: nil)
-        } else if rawValue == "🥒" {
-            self.init(baseEmoji: .cucumber, skinTones: nil)
-        } else if rawValue == "🥬" {
-            self.init(baseEmoji: .leafyGreen, skinTones: nil)
-        } else if rawValue == "🥦" {
-            self.init(baseEmoji: .broccoli, skinTones: nil)
-        } else if rawValue == "🧄" {
-            self.init(baseEmoji: .garlic, skinTones: nil)
-        } else if rawValue == "🧅" {
-            self.init(baseEmoji: .onion, skinTones: nil)
-        } else if rawValue == "🍄" {
-            self.init(baseEmoji: .mushroom, skinTones: nil)
-        } else if rawValue == "🥜" {
-            self.init(baseEmoji: .peanuts, skinTones: nil)
-        } else if rawValue == "🫘" {
-            self.init(baseEmoji: .beans, skinTones: nil)
-        } else if rawValue == "🌰" {
-            self.init(baseEmoji: .chestnut, skinTones: nil)
-        } else if rawValue == "🍞" {
-            self.init(baseEmoji: .bread, skinTones: nil)
-        } else if rawValue == "🥐" {
-            self.init(baseEmoji: .croissant, skinTones: nil)
-        } else if rawValue == "🥖" {
-            self.init(baseEmoji: .baguetteBread, skinTones: nil)
-        } else if rawValue == "🫓" {
-            self.init(baseEmoji: .flatbread, skinTones: nil)
-        } else if rawValue == "🥨" {
-            self.init(baseEmoji: .pretzel, skinTones: nil)
-        } else if rawValue == "🥯" {
-            self.init(baseEmoji: .bagel, skinTones: nil)
-        } else if rawValue == "🥞" {
-            self.init(baseEmoji: .pancakes, skinTones: nil)
-        } else if rawValue == "🧇" {
-            self.init(baseEmoji: .waffle, skinTones: nil)
-        } else if rawValue == "🧀" {
-            self.init(baseEmoji: .cheeseWedge, skinTones: nil)
-        } else if rawValue == "🍖" {
-            self.init(baseEmoji: .meatOnBone, skinTones: nil)
-        } else if rawValue == "🍗" {
-            self.init(baseEmoji: .poultryLeg, skinTones: nil)
-        } else if rawValue == "🥩" {
-            self.init(baseEmoji: .cutOfMeat, skinTones: nil)
-        } else if rawValue == "🥓" {
-            self.init(baseEmoji: .bacon, skinTones: nil)
-        } else if rawValue == "🍔" {
-            self.init(baseEmoji: .hamburger, skinTones: nil)
-        } else if rawValue == "🍟" {
-            self.init(baseEmoji: .fries, skinTones: nil)
-        } else if rawValue == "🍕" {
-            self.init(baseEmoji: .pizza, skinTones: nil)
-        } else if rawValue == "🌭" {
-            self.init(baseEmoji: .hotdog, skinTones: nil)
-        } else if rawValue == "🥪" {
-            self.init(baseEmoji: .sandwich, skinTones: nil)
-        } else if rawValue == "🌮" {
-            self.init(baseEmoji: .taco, skinTones: nil)
-        } else if rawValue == "🌯" {
-            self.init(baseEmoji: .burrito, skinTones: nil)
-        } else if rawValue == "🫔" {
-            self.init(baseEmoji: .tamale, skinTones: nil)
-        } else if rawValue == "🥙" {
-            self.init(baseEmoji: .stuffedFlatbread, skinTones: nil)
-        } else if rawValue == "🧆" {
-            self.init(baseEmoji: .falafel, skinTones: nil)
-        } else if rawValue == "🥚" {
-            self.init(baseEmoji: .egg, skinTones: nil)
-        } else if rawValue == "🍳" {
-            self.init(baseEmoji: .friedEgg, skinTones: nil)
-        } else if rawValue == "🥘" {
-            self.init(baseEmoji: .shallowPanOfFood, skinTones: nil)
-        } else if rawValue == "🍲" {
-            self.init(baseEmoji: .stew, skinTones: nil)
-        } else if rawValue == "🫕" {
-            self.init(baseEmoji: .fondue, skinTones: nil)
-        } else if rawValue == "🥣" {
-            self.init(baseEmoji: .bowlWithSpoon, skinTones: nil)
-        } else if rawValue == "🥗" {
-            self.init(baseEmoji: .greenSalad, skinTones: nil)
-        } else if rawValue == "🍿" {
-            self.init(baseEmoji: .popcorn, skinTones: nil)
-        } else if rawValue == "🧈" {
-            self.init(baseEmoji: .butter, skinTones: nil)
-        } else if rawValue == "🧂" {
-            self.init(baseEmoji: .salt, skinTones: nil)
-        } else if rawValue == "🥫" {
-            self.init(baseEmoji: .cannedFood, skinTones: nil)
-        } else if rawValue == "🍱" {
-            self.init(baseEmoji: .bento, skinTones: nil)
-        } else if rawValue == "🍘" {
-            self.init(baseEmoji: .riceCracker, skinTones: nil)
-        } else if rawValue == "🍙" {
-            self.init(baseEmoji: .riceBall, skinTones: nil)
-        } else if rawValue == "🍚" {
-            self.init(baseEmoji: .rice, skinTones: nil)
-        } else if rawValue == "🍛" {
-            self.init(baseEmoji: .curry, skinTones: nil)
-        } else if rawValue == "🍜" {
-            self.init(baseEmoji: .ramen, skinTones: nil)
-        } else if rawValue == "🍝" {
-            self.init(baseEmoji: .spaghetti, skinTones: nil)
-        } else if rawValue == "🍠" {
-            self.init(baseEmoji: .sweetPotato, skinTones: nil)
-        } else if rawValue == "🍢" {
-            self.init(baseEmoji: .oden, skinTones: nil)
-        } else if rawValue == "🍣" {
-            self.init(baseEmoji: .sushi, skinTones: nil)
-        } else if rawValue == "🍤" {
-            self.init(baseEmoji: .friedShrimp, skinTones: nil)
-        } else if rawValue == "🍥" {
-            self.init(baseEmoji: .fishCake, skinTones: nil)
-        } else if rawValue == "🥮" {
-            self.init(baseEmoji: .moonCake, skinTones: nil)
-        } else if rawValue == "🍡" {
-            self.init(baseEmoji: .dango, skinTones: nil)
-        } else if rawValue == "🥟" {
-            self.init(baseEmoji: .dumpling, skinTones: nil)
-        } else if rawValue == "🥠" {
-            self.init(baseEmoji: .fortuneCookie, skinTones: nil)
-        } else if rawValue == "🥡" {
-            self.init(baseEmoji: .takeoutBox, skinTones: nil)
-        } else if rawValue == "🦀" {
-            self.init(baseEmoji: .crab, skinTones: nil)
-        } else if rawValue == "🦞" {
-            self.init(baseEmoji: .lobster, skinTones: nil)
-        } else if rawValue == "🦐" {
-            self.init(baseEmoji: .shrimp, skinTones: nil)
-        } else if rawValue == "🦑" {
-            self.init(baseEmoji: .squid, skinTones: nil)
-        } else if rawValue == "🦪" {
-            self.init(baseEmoji: .oyster, skinTones: nil)
-        } else if rawValue == "🍦" {
-            self.init(baseEmoji: .icecream, skinTones: nil)
-        } else if rawValue == "🍧" {
-            self.init(baseEmoji: .shavedIce, skinTones: nil)
-        } else if rawValue == "🍨" {
-            self.init(baseEmoji: .iceCream, skinTones: nil)
-        } else if rawValue == "🍩" {
-            self.init(baseEmoji: .doughnut, skinTones: nil)
-        } else if rawValue == "🍪" {
-            self.init(baseEmoji: .cookie, skinTones: nil)
-        } else if rawValue == "🎂" {
-            self.init(baseEmoji: .birthday, skinTones: nil)
-        } else if rawValue == "🍰" {
-            self.init(baseEmoji: .cake, skinTones: nil)
-        } else if rawValue == "🧁" {
-            self.init(baseEmoji: .cupcake, skinTones: nil)
-        } else if rawValue == "🥧" {
-            self.init(baseEmoji: .pie, skinTones: nil)
-        } else if rawValue == "🍫" {
-            self.init(baseEmoji: .chocolateBar, skinTones: nil)
-        } else if rawValue == "🍬" {
-            self.init(baseEmoji: .candy, skinTones: nil)
-        } else if rawValue == "🍭" {
-            self.init(baseEmoji: .lollipop, skinTones: nil)
-        } else if rawValue == "🍮" {
-            self.init(baseEmoji: .custard, skinTones: nil)
-        } else if rawValue == "🍯" {
-            self.init(baseEmoji: .honeyPot, skinTones: nil)
-        } else if rawValue == "🍼" {
-            self.init(baseEmoji: .babyBottle, skinTones: nil)
-        } else if rawValue == "🥛" {
-            self.init(baseEmoji: .glassOfMilk, skinTones: nil)
-        } else if rawValue == "☕" {
-            self.init(baseEmoji: .coffee, skinTones: nil)
-        } else if rawValue == "🫖" {
-            self.init(baseEmoji: .teapot, skinTones: nil)
-        } else if rawValue == "🍵" {
-            self.init(baseEmoji: .tea, skinTones: nil)
-        } else if rawValue == "🍶" {
-            self.init(baseEmoji: .sake, skinTones: nil)
-        } else if rawValue == "🍾" {
-            self.init(baseEmoji: .champagne, skinTones: nil)
-        } else if rawValue == "🍷" {
-            self.init(baseEmoji: .wineGlass, skinTones: nil)
-        } else if rawValue == "🍸" {
-            self.init(baseEmoji: .cocktail, skinTones: nil)
-        } else if rawValue == "🍹" {
-            self.init(baseEmoji: .tropicalDrink, skinTones: nil)
-        } else if rawValue == "🍺" {
-            self.init(baseEmoji: .beer, skinTones: nil)
-        } else if rawValue == "🍻" {
-            self.init(baseEmoji: .beers, skinTones: nil)
-        } else if rawValue == "🥂" {
-            self.init(baseEmoji: .clinkingGlasses, skinTones: nil)
-        } else if rawValue == "🥃" {
-            self.init(baseEmoji: .tumblerGlass, skinTones: nil)
-        } else if rawValue == "🫗" {
-            self.init(baseEmoji: .pouringLiquid, skinTones: nil)
-        } else if rawValue == "🥤" {
-            self.init(baseEmoji: .cupWithStraw, skinTones: nil)
-        } else if rawValue == "🧋" {
-            self.init(baseEmoji: .bubbleTea, skinTones: nil)
-        } else if rawValue == "🧃" {
-            self.init(baseEmoji: .beverageBox, skinTones: nil)
-        } else if rawValue == "🧉" {
-            self.init(baseEmoji: .mateDrink, skinTones: nil)
-        } else if rawValue == "🧊" {
-            self.init(baseEmoji: .iceCube, skinTones: nil)
-        } else if rawValue == "🥢" {
-            self.init(baseEmoji: .chopsticks, skinTones: nil)
-        } else if rawValue == "🍽️" {
-            self.init(baseEmoji: .knifeForkPlate, skinTones: nil)
-        } else if rawValue == "🍴" {
-            self.init(baseEmoji: .forkAndKnife, skinTones: nil)
-        } else if rawValue == "🥄" {
-            self.init(baseEmoji: .spoon, skinTones: nil)
-        } else if rawValue == "🔪" {
-            self.init(baseEmoji: .hocho, skinTones: nil)
-        } else if rawValue == "🫙" {
-            self.init(baseEmoji: .jar, skinTones: nil)
-        } else if rawValue == "🏺" {
-            self.init(baseEmoji: .amphora, skinTones: nil)
-        } else if rawValue == "🌍" {
-            self.init(baseEmoji: .earthAfrica, skinTones: nil)
-        } else if rawValue == "🌎" {
-            self.init(baseEmoji: .earthAmericas, skinTones: nil)
-        } else if rawValue == "🌏" {
-            self.init(baseEmoji: .earthAsia, skinTones: nil)
-        } else if rawValue == "🌐" {
-            self.init(baseEmoji: .globeWithMeridians, skinTones: nil)
-        } else if rawValue == "🗺️" {
-            self.init(baseEmoji: .worldMap, skinTones: nil)
-        } else if rawValue == "🗾" {
-            self.init(baseEmoji: .japan, skinTones: nil)
-        } else if rawValue == "🧭" {
-            self.init(baseEmoji: .compass, skinTones: nil)
-        } else if rawValue == "🏔️" {
-            self.init(baseEmoji: .snowCappedMountain, skinTones: nil)
-        } else if rawValue == "⛰️" {
-            self.init(baseEmoji: .mountain, skinTones: nil)
-        } else if rawValue == "🌋" {
-            self.init(baseEmoji: .volcano, skinTones: nil)
-        } else if rawValue == "🗻" {
-            self.init(baseEmoji: .mountFuji, skinTones: nil)
-        } else if rawValue == "🏕️" {
-            self.init(baseEmoji: .camping, skinTones: nil)
-        } else if rawValue == "🏖️" {
-            self.init(baseEmoji: .beachWithUmbrella, skinTones: nil)
-        } else if rawValue == "🏜️" {
-            self.init(baseEmoji: .desert, skinTones: nil)
-        } else if rawValue == "🏝️" {
-            self.init(baseEmoji: .desertIsland, skinTones: nil)
-        } else if rawValue == "🏞️" {
-            self.init(baseEmoji: .nationalPark, skinTones: nil)
-        } else if rawValue == "🏟️" {
-            self.init(baseEmoji: .stadium, skinTones: nil)
-        } else if rawValue == "🏛️" {
-            self.init(baseEmoji: .classicalBuilding, skinTones: nil)
-        } else if rawValue == "🏗️" {
-            self.init(baseEmoji: .buildingConstruction, skinTones: nil)
-        } else if rawValue == "🧱" {
-            self.init(baseEmoji: .bricks, skinTones: nil)
-        } else if rawValue == "🪨" {
-            self.init(baseEmoji: .rock, skinTones: nil)
-        } else if rawValue == "🪵" {
-            self.init(baseEmoji: .wood, skinTones: nil)
-        } else if rawValue == "🛖" {
-            self.init(baseEmoji: .hut, skinTones: nil)
-        } else if rawValue == "🏘️" {
-            self.init(baseEmoji: .houseBuildings, skinTones: nil)
-        } else if rawValue == "🏚️" {
-            self.init(baseEmoji: .derelictHouseBuilding, skinTones: nil)
-        } else if rawValue == "🏠" {
-            self.init(baseEmoji: .house, skinTones: nil)
-        } else if rawValue == "🏡" {
-            self.init(baseEmoji: .houseWithGarden, skinTones: nil)
-        } else if rawValue == "🏢" {
-            self.init(baseEmoji: .office, skinTones: nil)
-        } else if rawValue == "🏣" {
-            self.init(baseEmoji: .postOffice, skinTones: nil)
-        } else if rawValue == "🏤" {
-            self.init(baseEmoji: .europeanPostOffice, skinTones: nil)
-        } else if rawValue == "🏥" {
-            self.init(baseEmoji: .hospital, skinTones: nil)
-        } else if rawValue == "🏦" {
-            self.init(baseEmoji: .bank, skinTones: nil)
-        } else if rawValue == "🏨" {
-            self.init(baseEmoji: .hotel, skinTones: nil)
-        } else if rawValue == "🏩" {
-            self.init(baseEmoji: .loveHotel, skinTones: nil)
-        } else if rawValue == "🏪" {
-            self.init(baseEmoji: .convenienceStore, skinTones: nil)
-        } else if rawValue == "🏫" {
-            self.init(baseEmoji: .school, skinTones: nil)
-        } else if rawValue == "🏬" {
-            self.init(baseEmoji: .departmentStore, skinTones: nil)
-        } else if rawValue == "🏭" {
-            self.init(baseEmoji: .factory, skinTones: nil)
-        } else if rawValue == "🏯" {
-            self.init(baseEmoji: .japaneseCastle, skinTones: nil)
-        } else if rawValue == "🏰" {
-            self.init(baseEmoji: .europeanCastle, skinTones: nil)
-        } else if rawValue == "💒" {
-            self.init(baseEmoji: .wedding, skinTones: nil)
-        } else if rawValue == "🗼" {
-            self.init(baseEmoji: .tokyoTower, skinTones: nil)
-        } else if rawValue == "🗽" {
-            self.init(baseEmoji: .statueOfLiberty, skinTones: nil)
-        } else if rawValue == "⛪" {
-            self.init(baseEmoji: .church, skinTones: nil)
-        } else if rawValue == "🕌" {
-            self.init(baseEmoji: .mosque, skinTones: nil)
-        } else if rawValue == "🛕" {
-            self.init(baseEmoji: .hinduTemple, skinTones: nil)
-        } else if rawValue == "🕍" {
-            self.init(baseEmoji: .synagogue, skinTones: nil)
-        } else if rawValue == "⛩️" {
-            self.init(baseEmoji: .shintoShrine, skinTones: nil)
-        } else if rawValue == "🕋" {
-            self.init(baseEmoji: .kaaba, skinTones: nil)
-        } else if rawValue == "⛲" {
-            self.init(baseEmoji: .fountain, skinTones: nil)
-        } else if rawValue == "⛺" {
-            self.init(baseEmoji: .tent, skinTones: nil)
-        } else if rawValue == "🌁" {
-            self.init(baseEmoji: .foggy, skinTones: nil)
-        } else if rawValue == "🌃" {
-            self.init(baseEmoji: .nightWithStars, skinTones: nil)
-        } else if rawValue == "🏙️" {
-            self.init(baseEmoji: .cityscape, skinTones: nil)
-        } else if rawValue == "🌄" {
-            self.init(baseEmoji: .sunriseOverMountains, skinTones: nil)
-        } else if rawValue == "🌅" {
-            self.init(baseEmoji: .sunrise, skinTones: nil)
-        } else if rawValue == "🌆" {
-            self.init(baseEmoji: .citySunset, skinTones: nil)
-        } else if rawValue == "🌇" {
-            self.init(baseEmoji: .citySunrise, skinTones: nil)
-        } else if rawValue == "🌉" {
-            self.init(baseEmoji: .bridgeAtNight, skinTones: nil)
-        } else if rawValue == "♨️" {
-            self.init(baseEmoji: .hotsprings, skinTones: nil)
-        } else if rawValue == "🎠" {
-            self.init(baseEmoji: .carouselHorse, skinTones: nil)
-        } else if rawValue == "🛝" {
-            self.init(baseEmoji: .playgroundSlide, skinTones: nil)
-        } else if rawValue == "🎡" {
-            self.init(baseEmoji: .ferrisWheel, skinTones: nil)
-        } else if rawValue == "🎢" {
-            self.init(baseEmoji: .rollerCoaster, skinTones: nil)
-        } else if rawValue == "💈" {
-            self.init(baseEmoji: .barber, skinTones: nil)
-        } else if rawValue == "🎪" {
-            self.init(baseEmoji: .circusTent, skinTones: nil)
-        } else if rawValue == "🚂" {
-            self.init(baseEmoji: .steamLocomotive, skinTones: nil)
-        } else if rawValue == "🚃" {
-            self.init(baseEmoji: .railwayCar, skinTones: nil)
-        } else if rawValue == "🚄" {
-            self.init(baseEmoji: .bullettrainSide, skinTones: nil)
-        } else if rawValue == "🚅" {
-            self.init(baseEmoji: .bullettrainFront, skinTones: nil)
-        } else if rawValue == "🚆" {
-            self.init(baseEmoji: .train2, skinTones: nil)
-        } else if rawValue == "🚇" {
-            self.init(baseEmoji: .metro, skinTones: nil)
-        } else if rawValue == "🚈" {
-            self.init(baseEmoji: .lightRail, skinTones: nil)
-        } else if rawValue == "🚉" {
-            self.init(baseEmoji: .station, skinTones: nil)
-        } else if rawValue == "🚊" {
-            self.init(baseEmoji: .tram, skinTones: nil)
-        } else if rawValue == "🚝" {
-            self.init(baseEmoji: .monorail, skinTones: nil)
-        } else if rawValue == "🚞" {
-            self.init(baseEmoji: .mountainRailway, skinTones: nil)
-        } else if rawValue == "🚋" {
-            self.init(baseEmoji: .train, skinTones: nil)
-        } else if rawValue == "🚌" {
-            self.init(baseEmoji: .bus, skinTones: nil)
-        } else if rawValue == "🚍" {
-            self.init(baseEmoji: .oncomingBus, skinTones: nil)
-        } else if rawValue == "🚎" {
-            self.init(baseEmoji: .trolleybus, skinTones: nil)
-        } else if rawValue == "🚐" {
-            self.init(baseEmoji: .minibus, skinTones: nil)
-        } else if rawValue == "🚑" {
-            self.init(baseEmoji: .ambulance, skinTones: nil)
-        } else if rawValue == "🚒" {
-            self.init(baseEmoji: .fireEngine, skinTones: nil)
-        } else if rawValue == "🚓" {
-            self.init(baseEmoji: .policeCar, skinTones: nil)
-        } else if rawValue == "🚔" {
-            self.init(baseEmoji: .oncomingPoliceCar, skinTones: nil)
-        } else if rawValue == "🚕" {
-            self.init(baseEmoji: .taxi, skinTones: nil)
-        } else if rawValue == "🚖" {
-            self.init(baseEmoji: .oncomingTaxi, skinTones: nil)
-        } else if rawValue == "🚗" {
-            self.init(baseEmoji: .car, skinTones: nil)
-        } else if rawValue == "🚘" {
-            self.init(baseEmoji: .oncomingAutomobile, skinTones: nil)
-        } else if rawValue == "🚙" {
-            self.init(baseEmoji: .blueCar, skinTones: nil)
-        } else if rawValue == "🛻" {
-            self.init(baseEmoji: .pickupTruck, skinTones: nil)
-        } else if rawValue == "🚚" {
-            self.init(baseEmoji: .truck, skinTones: nil)
-        } else if rawValue == "🚛" {
-            self.init(baseEmoji: .articulatedLorry, skinTones: nil)
-        } else if rawValue == "🚜" {
-            self.init(baseEmoji: .tractor, skinTones: nil)
-        } else if rawValue == "🏎️" {
-            self.init(baseEmoji: .racingCar, skinTones: nil)
-        } else if rawValue == "🏍️" {
-            self.init(baseEmoji: .racingMotorcycle, skinTones: nil)
-        } else if rawValue == "🛵" {
-            self.init(baseEmoji: .motorScooter, skinTones: nil)
-        } else if rawValue == "🦽" {
-            self.init(baseEmoji: .manualWheelchair, skinTones: nil)
-        } else if rawValue == "🦼" {
-            self.init(baseEmoji: .motorizedWheelchair, skinTones: nil)
-        } else if rawValue == "🛺" {
-            self.init(baseEmoji: .autoRickshaw, skinTones: nil)
-        } else if rawValue == "🚲" {
-            self.init(baseEmoji: .bike, skinTones: nil)
-        } else if rawValue == "🛴" {
-            self.init(baseEmoji: .scooter, skinTones: nil)
-        } else if rawValue == "🛹" {
-            self.init(baseEmoji: .skateboard, skinTones: nil)
-        } else if rawValue == "🛼" {
-            self.init(baseEmoji: .rollerSkate, skinTones: nil)
-        } else if rawValue == "🚏" {
-            self.init(baseEmoji: .busstop, skinTones: nil)
-        } else if rawValue == "🛣️" {
-            self.init(baseEmoji: .motorway, skinTones: nil)
-        } else if rawValue == "🛤️" {
-            self.init(baseEmoji: .railwayTrack, skinTones: nil)
-        } else if rawValue == "🛢️" {
-            self.init(baseEmoji: .oilDrum, skinTones: nil)
-        } else if rawValue == "⛽" {
-            self.init(baseEmoji: .fuelpump, skinTones: nil)
-        } else if rawValue == "🛞" {
-            self.init(baseEmoji: .wheel, skinTones: nil)
-        } else if rawValue == "🚨" {
-            self.init(baseEmoji: .rotatingLight, skinTones: nil)
-        } else if rawValue == "🚥" {
-            self.init(baseEmoji: .trafficLight, skinTones: nil)
-        } else if rawValue == "🚦" {
-            self.init(baseEmoji: .verticalTrafficLight, skinTones: nil)
-        } else if rawValue == "🛑" {
-            self.init(baseEmoji: .octagonalSign, skinTones: nil)
-        } else if rawValue == "🚧" {
-            self.init(baseEmoji: .construction, skinTones: nil)
-        } else if rawValue == "⚓" {
-            self.init(baseEmoji: .anchor, skinTones: nil)
-        } else if rawValue == "🛟" {
-            self.init(baseEmoji: .ringBuoy, skinTones: nil)
-        } else if rawValue == "⛵" {
-            self.init(baseEmoji: .boat, skinTones: nil)
-        } else if rawValue == "🛶" {
-            self.init(baseEmoji: .canoe, skinTones: nil)
-        } else if rawValue == "🚤" {
-            self.init(baseEmoji: .speedboat, skinTones: nil)
-        } else if rawValue == "🛳️" {
-            self.init(baseEmoji: .passengerShip, skinTones: nil)
-        } else if rawValue == "⛴️" {
-            self.init(baseEmoji: .ferry, skinTones: nil)
-        } else if rawValue == "🛥️" {
-            self.init(baseEmoji: .motorBoat, skinTones: nil)
-        } else if rawValue == "🚢" {
-            self.init(baseEmoji: .ship, skinTones: nil)
-        } else if rawValue == "✈️" {
-            self.init(baseEmoji: .airplane, skinTones: nil)
-        } else if rawValue == "🛩️" {
-            self.init(baseEmoji: .smallAirplane, skinTones: nil)
-        } else if rawValue == "🛫" {
-            self.init(baseEmoji: .airplaneDeparture, skinTones: nil)
-        } else if rawValue == "🛬" {
-            self.init(baseEmoji: .airplaneArriving, skinTones: nil)
-        } else if rawValue == "🪂" {
-            self.init(baseEmoji: .parachute, skinTones: nil)
-        } else if rawValue == "💺" {
-            self.init(baseEmoji: .seat, skinTones: nil)
-        } else if rawValue == "🚁" {
-            self.init(baseEmoji: .helicopter, skinTones: nil)
-        } else if rawValue == "🚟" {
-            self.init(baseEmoji: .suspensionRailway, skinTones: nil)
-        } else if rawValue == "🚠" {
-            self.init(baseEmoji: .mountainCableway, skinTones: nil)
-        } else if rawValue == "🚡" {
-            self.init(baseEmoji: .aerialTramway, skinTones: nil)
-        } else if rawValue == "🛰️" {
-            self.init(baseEmoji: .satellite, skinTones: nil)
-        } else if rawValue == "🚀" {
-            self.init(baseEmoji: .rocket, skinTones: nil)
-        } else if rawValue == "🛸" {
-            self.init(baseEmoji: .flyingSaucer, skinTones: nil)
-        } else if rawValue == "🛎️" {
-            self.init(baseEmoji: .bellhopBell, skinTones: nil)
-        } else if rawValue == "🧳" {
-            self.init(baseEmoji: .luggage, skinTones: nil)
-        } else if rawValue == "⌛" {
-            self.init(baseEmoji: .hourglass, skinTones: nil)
-        } else if rawValue == "⏳" {
-            self.init(baseEmoji: .hourglassFlowingSand, skinTones: nil)
-        } else if rawValue == "⌚" {
-            self.init(baseEmoji: .watch, skinTones: nil)
-        } else if rawValue == "⏰" {
-            self.init(baseEmoji: .alarmClock, skinTones: nil)
-        } else if rawValue == "⏱️" {
-            self.init(baseEmoji: .stopwatch, skinTones: nil)
-        } else if rawValue == "⏲️" {
-            self.init(baseEmoji: .timerClock, skinTones: nil)
-        } else if rawValue == "🕰️" {
-            self.init(baseEmoji: .mantelpieceClock, skinTones: nil)
-        } else if rawValue == "🕛" {
-            self.init(baseEmoji: .clock12, skinTones: nil)
-        } else if rawValue == "🕧" {
-            self.init(baseEmoji: .clock1230, skinTones: nil)
-        } else if rawValue == "🕐" {
-            self.init(baseEmoji: .clock1, skinTones: nil)
-        } else if rawValue == "🕜" {
-            self.init(baseEmoji: .clock130, skinTones: nil)
-        } else if rawValue == "🕑" {
-            self.init(baseEmoji: .clock2, skinTones: nil)
-        } else if rawValue == "🕝" {
-            self.init(baseEmoji: .clock230, skinTones: nil)
-        } else if rawValue == "🕒" {
-            self.init(baseEmoji: .clock3, skinTones: nil)
-        } else if rawValue == "🕞" {
-            self.init(baseEmoji: .clock330, skinTones: nil)
-        } else if rawValue == "🕓" {
-            self.init(baseEmoji: .clock4, skinTones: nil)
-        } else if rawValue == "🕟" {
-            self.init(baseEmoji: .clock430, skinTones: nil)
-        } else if rawValue == "🕔" {
-            self.init(baseEmoji: .clock5, skinTones: nil)
-        } else if rawValue == "🕠" {
-            self.init(baseEmoji: .clock530, skinTones: nil)
-        } else if rawValue == "🕕" {
-            self.init(baseEmoji: .clock6, skinTones: nil)
-        } else if rawValue == "🕡" {
-            self.init(baseEmoji: .clock630, skinTones: nil)
-        } else if rawValue == "🕖" {
-            self.init(baseEmoji: .clock7, skinTones: nil)
-        } else if rawValue == "🕢" {
-            self.init(baseEmoji: .clock730, skinTones: nil)
-        } else if rawValue == "🕗" {
-            self.init(baseEmoji: .clock8, skinTones: nil)
-        } else if rawValue == "🕣" {
-            self.init(baseEmoji: .clock830, skinTones: nil)
-        } else if rawValue == "🕘" {
-            self.init(baseEmoji: .clock9, skinTones: nil)
-        } else if rawValue == "🕤" {
-            self.init(baseEmoji: .clock930, skinTones: nil)
-        } else if rawValue == "🕙" {
-            self.init(baseEmoji: .clock10, skinTones: nil)
-        } else if rawValue == "🕥" {
-            self.init(baseEmoji: .clock1030, skinTones: nil)
-        } else if rawValue == "🕚" {
-            self.init(baseEmoji: .clock11, skinTones: nil)
-        } else if rawValue == "🕦" {
-            self.init(baseEmoji: .clock1130, skinTones: nil)
-        } else if rawValue == "🌑" {
-            self.init(baseEmoji: .newMoon, skinTones: nil)
-        } else if rawValue == "🌒" {
-            self.init(baseEmoji: .waxingCrescentMoon, skinTones: nil)
-        } else if rawValue == "🌓" {
-            self.init(baseEmoji: .firstQuarterMoon, skinTones: nil)
-        } else if rawValue == "🌔" {
-            self.init(baseEmoji: .moon, skinTones: nil)
-        } else if rawValue == "🌕" {
-            self.init(baseEmoji: .fullMoon, skinTones: nil)
-        } else if rawValue == "🌖" {
-            self.init(baseEmoji: .waningGibbousMoon, skinTones: nil)
-        } else if rawValue == "🌗" {
-            self.init(baseEmoji: .lastQuarterMoon, skinTones: nil)
-        } else if rawValue == "🌘" {
-            self.init(baseEmoji: .waningCrescentMoon, skinTones: nil)
-        } else if rawValue == "🌙" {
-            self.init(baseEmoji: .crescentMoon, skinTones: nil)
-        } else if rawValue == "🌚" {
-            self.init(baseEmoji: .newMoonWithFace, skinTones: nil)
-        } else if rawValue == "🌛" {
-            self.init(baseEmoji: .firstQuarterMoonWithFace, skinTones: nil)
-        } else if rawValue == "🌜" {
-            self.init(baseEmoji: .lastQuarterMoonWithFace, skinTones: nil)
-        } else if rawValue == "🌡️" {
-            self.init(baseEmoji: .thermometer, skinTones: nil)
-        } else if rawValue == "☀️" {
-            self.init(baseEmoji: .sunny, skinTones: nil)
-        } else if rawValue == "🌝" {
-            self.init(baseEmoji: .fullMoonWithFace, skinTones: nil)
-        } else if rawValue == "🌞" {
-            self.init(baseEmoji: .sunWithFace, skinTones: nil)
-        } else if rawValue == "🪐" {
-            self.init(baseEmoji: .ringedPlanet, skinTones: nil)
-        } else if rawValue == "⭐" {
-            self.init(baseEmoji: .star, skinTones: nil)
-        } else if rawValue == "🌟" {
-            self.init(baseEmoji: .star2, skinTones: nil)
-        } else if rawValue == "🌠" {
-            self.init(baseEmoji: .stars, skinTones: nil)
-        } else if rawValue == "🌌" {
-            self.init(baseEmoji: .milkyWay, skinTones: nil)
-        } else if rawValue == "☁️" {
-            self.init(baseEmoji: .cloud, skinTones: nil)
-        } else if rawValue == "⛅" {
-            self.init(baseEmoji: .partlySunny, skinTones: nil)
-        } else if rawValue == "⛈️" {
-            self.init(baseEmoji: .thunderCloudAndRain, skinTones: nil)
-        } else if rawValue == "🌤️" {
-            self.init(baseEmoji: .mostlySunny, skinTones: nil)
-        } else if rawValue == "🌥️" {
-            self.init(baseEmoji: .barelySunny, skinTones: nil)
-        } else if rawValue == "🌦️" {
-            self.init(baseEmoji: .partlySunnyRain, skinTones: nil)
-        } else if rawValue == "🌧️" {
-            self.init(baseEmoji: .rainCloud, skinTones: nil)
-        } else if rawValue == "🌨️" {
-            self.init(baseEmoji: .snowCloud, skinTones: nil)
-        } else if rawValue == "🌩️" {
-            self.init(baseEmoji: .lightning, skinTones: nil)
-        } else if rawValue == "🌪️" {
-            self.init(baseEmoji: .tornado, skinTones: nil)
-        } else if rawValue == "🌫️" {
-            self.init(baseEmoji: .fog, skinTones: nil)
-        } else if rawValue == "🌬️" {
-            self.init(baseEmoji: .windBlowingFace, skinTones: nil)
-        } else if rawValue == "🌀" {
-            self.init(baseEmoji: .cyclone, skinTones: nil)
-        } else if rawValue == "🌈" {
-            self.init(baseEmoji: .rainbow, skinTones: nil)
-        } else if rawValue == "🌂" {
-            self.init(baseEmoji: .closedUmbrella, skinTones: nil)
-        } else if rawValue == "☂️" {
-            self.init(baseEmoji: .umbrella, skinTones: nil)
-        } else if rawValue == "☔" {
-            self.init(baseEmoji: .umbrellaWithRainDrops, skinTones: nil)
-        } else if rawValue == "⛱️" {
-            self.init(baseEmoji: .umbrellaOnGround, skinTones: nil)
-        } else if rawValue == "⚡" {
-            self.init(baseEmoji: .zap, skinTones: nil)
-        } else if rawValue == "❄️" {
-            self.init(baseEmoji: .snowflake, skinTones: nil)
-        } else if rawValue == "☃️" {
-            self.init(baseEmoji: .snowman, skinTones: nil)
-        } else if rawValue == "⛄" {
-            self.init(baseEmoji: .snowmanWithoutSnow, skinTones: nil)
-        } else if rawValue == "☄️" {
-            self.init(baseEmoji: .comet, skinTones: nil)
-        } else if rawValue == "🔥" {
-            self.init(baseEmoji: .fire, skinTones: nil)
-        } else if rawValue == "💧" {
-            self.init(baseEmoji: .droplet, skinTones: nil)
-        } else if rawValue == "🌊" {
-            self.init(baseEmoji: .ocean, skinTones: nil)
-        } else if rawValue == "🎃" {
-            self.init(baseEmoji: .jackOLantern, skinTones: nil)
-        } else if rawValue == "🎄" {
-            self.init(baseEmoji: .christmasTree, skinTones: nil)
-        } else if rawValue == "🎆" {
-            self.init(baseEmoji: .fireworks, skinTones: nil)
-        } else if rawValue == "🎇" {
-            self.init(baseEmoji: .sparkler, skinTones: nil)
-        } else if rawValue == "🧨" {
-            self.init(baseEmoji: .firecracker, skinTones: nil)
-        } else if rawValue == "✨" {
-            self.init(baseEmoji: .sparkles, skinTones: nil)
-        } else if rawValue == "🎈" {
-            self.init(baseEmoji: .balloon, skinTones: nil)
-        } else if rawValue == "🎉" {
-            self.init(baseEmoji: .tada, skinTones: nil)
-        } else if rawValue == "🎊" {
-            self.init(baseEmoji: .confettiBall, skinTones: nil)
-        } else if rawValue == "🎋" {
-            self.init(baseEmoji: .tanabataTree, skinTones: nil)
-        } else if rawValue == "🎍" {
-            self.init(baseEmoji: .bamboo, skinTones: nil)
-        } else if rawValue == "🎎" {
-            self.init(baseEmoji: .dolls, skinTones: nil)
-        } else if rawValue == "🎏" {
-            self.init(baseEmoji: .flags, skinTones: nil)
-        } else if rawValue == "🎐" {
-            self.init(baseEmoji: .windChime, skinTones: nil)
-        } else if rawValue == "🎑" {
-            self.init(baseEmoji: .riceScene, skinTones: nil)
-        } else if rawValue == "🧧" {
-            self.init(baseEmoji: .redEnvelope, skinTones: nil)
-        } else if rawValue == "🎀" {
-            self.init(baseEmoji: .ribbon, skinTones: nil)
-        } else if rawValue == "🎁" {
-            self.init(baseEmoji: .gift, skinTones: nil)
-        } else if rawValue == "🎗️" {
-            self.init(baseEmoji: .reminderRibbon, skinTones: nil)
-        } else if rawValue == "🎟️" {
-            self.init(baseEmoji: .admissionTickets, skinTones: nil)
-        } else if rawValue == "🎫" {
-            self.init(baseEmoji: .ticket, skinTones: nil)
-        } else if rawValue == "🎖️" {
-            self.init(baseEmoji: .medal, skinTones: nil)
-        } else if rawValue == "🏆" {
-            self.init(baseEmoji: .trophy, skinTones: nil)
-        } else if rawValue == "🏅" {
-            self.init(baseEmoji: .sportsMedal, skinTones: nil)
-        } else if rawValue == "🥇" {
-            self.init(baseEmoji: .firstPlaceMedal, skinTones: nil)
-        } else if rawValue == "🥈" {
-            self.init(baseEmoji: .secondPlaceMedal, skinTones: nil)
-        } else if rawValue == "🥉" {
-            self.init(baseEmoji: .thirdPlaceMedal, skinTones: nil)
-        } else if rawValue == "⚽" {
-            self.init(baseEmoji: .soccer, skinTones: nil)
-        } else if rawValue == "⚾" {
-            self.init(baseEmoji: .baseball, skinTones: nil)
-        } else if rawValue == "🥎" {
-            self.init(baseEmoji: .softball, skinTones: nil)
-        } else if rawValue == "🏀" {
-            self.init(baseEmoji: .basketball, skinTones: nil)
-        } else if rawValue == "🏐" {
-            self.init(baseEmoji: .volleyball, skinTones: nil)
-        } else if rawValue == "🏈" {
-            self.init(baseEmoji: .football, skinTones: nil)
-        } else if rawValue == "🏉" {
-            self.init(baseEmoji: .rugbyFootball, skinTones: nil)
-        } else if rawValue == "🎾" {
-            self.init(baseEmoji: .tennis, skinTones: nil)
-        } else if rawValue == "🥏" {
-            self.init(baseEmoji: .flyingDisc, skinTones: nil)
-        } else if rawValue == "🎳" {
-            self.init(baseEmoji: .bowling, skinTones: nil)
-        } else if rawValue == "🏏" {
-            self.init(baseEmoji: .cricketBatAndBall, skinTones: nil)
-        } else if rawValue == "🏑" {
-            self.init(baseEmoji: .fieldHockeyStickAndBall, skinTones: nil)
-        } else if rawValue == "🏒" {
-            self.init(baseEmoji: .iceHockeyStickAndPuck, skinTones: nil)
-        } else if rawValue == "🥍" {
-            self.init(baseEmoji: .lacrosse, skinTones: nil)
-        } else if rawValue == "🏓" {
-            self.init(baseEmoji: .tableTennisPaddleAndBall, skinTones: nil)
-        } else if rawValue == "🏸" {
-            self.init(baseEmoji: .badmintonRacquetAndShuttlecock, skinTones: nil)
-        } else if rawValue == "🥊" {
-            self.init(baseEmoji: .boxingGlove, skinTones: nil)
-        } else if rawValue == "🥋" {
-            self.init(baseEmoji: .martialArtsUniform, skinTones: nil)
-        } else if rawValue == "🥅" {
-            self.init(baseEmoji: .goalNet, skinTones: nil)
-        } else if rawValue == "⛳" {
-            self.init(baseEmoji: .golf, skinTones: nil)
-        } else if rawValue == "⛸️" {
-            self.init(baseEmoji: .iceSkate, skinTones: nil)
-        } else if rawValue == "🎣" {
-            self.init(baseEmoji: .fishingPoleAndFish, skinTones: nil)
-        } else if rawValue == "🤿" {
-            self.init(baseEmoji: .divingMask, skinTones: nil)
-        } else if rawValue == "🎽" {
-            self.init(baseEmoji: .runningShirtWithSash, skinTones: nil)
-        } else if rawValue == "🎿" {
-            self.init(baseEmoji: .ski, skinTones: nil)
-        } else if rawValue == "🛷" {
-            self.init(baseEmoji: .sled, skinTones: nil)
-        } else if rawValue == "🥌" {
-            self.init(baseEmoji: .curlingStone, skinTones: nil)
-        } else if rawValue == "🎯" {
-            self.init(baseEmoji: .dart, skinTones: nil)
-        } else if rawValue == "🪀" {
-            self.init(baseEmoji: .yoYo, skinTones: nil)
-        } else if rawValue == "🪁" {
-            self.init(baseEmoji: .kite, skinTones: nil)
-        } else if rawValue == "🎱" {
-            self.init(baseEmoji: .eightBall, skinTones: nil)
-        } else if rawValue == "🔮" {
-            self.init(baseEmoji: .crystalBall, skinTones: nil)
-        } else if rawValue == "🪄" {
-            self.init(baseEmoji: .magicWand, skinTones: nil)
-        } else if rawValue == "🧿" {
-            self.init(baseEmoji: .nazarAmulet, skinTones: nil)
-        } else if rawValue == "🪬" {
-            self.init(baseEmoji: .hamsa, skinTones: nil)
-        } else if rawValue == "🎮" {
-            self.init(baseEmoji: .videoGame, skinTones: nil)
-        } else if rawValue == "🕹️" {
-            self.init(baseEmoji: .joystick, skinTones: nil)
-        } else if rawValue == "🎰" {
-            self.init(baseEmoji: .slotMachine, skinTones: nil)
-        } else if rawValue == "🎲" {
-            self.init(baseEmoji: .gameDie, skinTones: nil)
-        } else if rawValue == "🧩" {
-            self.init(baseEmoji: .jigsaw, skinTones: nil)
-        } else if rawValue == "🧸" {
-            self.init(baseEmoji: .teddyBear, skinTones: nil)
-        } else if rawValue == "🪅" {
-            self.init(baseEmoji: .pinata, skinTones: nil)
-        } else if rawValue == "🪩" {
-            self.init(baseEmoji: .mirrorBall, skinTones: nil)
-        } else if rawValue == "🪆" {
-            self.init(baseEmoji: .nestingDolls, skinTones: nil)
-        } else if rawValue == "♠️" {
-            self.init(baseEmoji: .spades, skinTones: nil)
-        } else if rawValue == "♥️" {
-            self.init(baseEmoji: .hearts, skinTones: nil)
-        } else if rawValue == "♦️" {
-            self.init(baseEmoji: .diamonds, skinTones: nil)
-        } else if rawValue == "♣️" {
-            self.init(baseEmoji: .clubs, skinTones: nil)
-        } else if rawValue == "♟️" {
-            self.init(baseEmoji: .chessPawn, skinTones: nil)
-        } else if rawValue == "🃏" {
-            self.init(baseEmoji: .blackJoker, skinTones: nil)
-        } else if rawValue == "🀄" {
-            self.init(baseEmoji: .mahjong, skinTones: nil)
-        } else if rawValue == "🎴" {
-            self.init(baseEmoji: .flowerPlayingCards, skinTones: nil)
-        } else if rawValue == "🎭" {
-            self.init(baseEmoji: .performingArts, skinTones: nil)
-        } else if rawValue == "🖼️" {
-            self.init(baseEmoji: .frameWithPicture, skinTones: nil)
-        } else if rawValue == "🎨" {
-            self.init(baseEmoji: .art, skinTones: nil)
-        } else if rawValue == "🧵" {
-            self.init(baseEmoji: .thread, skinTones: nil)
-        } else if rawValue == "🪡" {
-            self.init(baseEmoji: .sewingNeedle, skinTones: nil)
-        } else if rawValue == "🧶" {
-            self.init(baseEmoji: .yarn, skinTones: nil)
-        } else if rawValue == "🪢" {
-            self.init(baseEmoji: .knot, skinTones: nil)
-        } else if rawValue == "👓" {
-            self.init(baseEmoji: .eyeglasses, skinTones: nil)
-        } else if rawValue == "🕶️" {
-            self.init(baseEmoji: .darkSunglasses, skinTones: nil)
-        } else if rawValue == "🥽" {
-            self.init(baseEmoji: .goggles, skinTones: nil)
-        } else if rawValue == "🥼" {
-            self.init(baseEmoji: .labCoat, skinTones: nil)
-        } else if rawValue == "🦺" {
-            self.init(baseEmoji: .safetyVest, skinTones: nil)
-        } else if rawValue == "👔" {
-            self.init(baseEmoji: .necktie, skinTones: nil)
-        } else if rawValue == "👕" {
-            self.init(baseEmoji: .shirt, skinTones: nil)
-        } else if rawValue == "👖" {
-            self.init(baseEmoji: .jeans, skinTones: nil)
-        } else if rawValue == "🧣" {
-            self.init(baseEmoji: .scarf, skinTones: nil)
-        } else if rawValue == "🧤" {
-            self.init(baseEmoji: .gloves, skinTones: nil)
-        } else if rawValue == "🧥" {
-            self.init(baseEmoji: .coat, skinTones: nil)
-        } else if rawValue == "🧦" {
-            self.init(baseEmoji: .socks, skinTones: nil)
-        } else if rawValue == "👗" {
-            self.init(baseEmoji: .dress, skinTones: nil)
-        } else if rawValue == "👘" {
-            self.init(baseEmoji: .kimono, skinTones: nil)
-        } else if rawValue == "🥻" {
-            self.init(baseEmoji: .sari, skinTones: nil)
-        } else if rawValue == "🩱" {
-            self.init(baseEmoji: .onePieceSwimsuit, skinTones: nil)
-        } else if rawValue == "🩲" {
-            self.init(baseEmoji: .briefs, skinTones: nil)
-        } else if rawValue == "🩳" {
-            self.init(baseEmoji: .shorts, skinTones: nil)
-        } else if rawValue == "👙" {
-            self.init(baseEmoji: .bikini, skinTones: nil)
-        } else if rawValue == "👚" {
-            self.init(baseEmoji: .womansClothes, skinTones: nil)
-        } else if rawValue == "👛" {
-            self.init(baseEmoji: .purse, skinTones: nil)
-        } else if rawValue == "👜" {
-            self.init(baseEmoji: .handbag, skinTones: nil)
-        } else if rawValue == "👝" {
-            self.init(baseEmoji: .pouch, skinTones: nil)
-        } else if rawValue == "🛍️" {
-            self.init(baseEmoji: .shoppingBags, skinTones: nil)
-        } else if rawValue == "🎒" {
-            self.init(baseEmoji: .schoolSatchel, skinTones: nil)
-        } else if rawValue == "🩴" {
-            self.init(baseEmoji: .thongSandal, skinTones: nil)
-        } else if rawValue == "👞" {
-            self.init(baseEmoji: .mansShoe, skinTones: nil)
-        } else if rawValue == "👟" {
-            self.init(baseEmoji: .athleticShoe, skinTones: nil)
-        } else if rawValue == "🥾" {
-            self.init(baseEmoji: .hikingBoot, skinTones: nil)
-        } else if rawValue == "🥿" {
-            self.init(baseEmoji: .womansFlatShoe, skinTones: nil)
-        } else if rawValue == "👠" {
-            self.init(baseEmoji: .highHeel, skinTones: nil)
-        } else if rawValue == "👡" {
-            self.init(baseEmoji: .sandal, skinTones: nil)
-        } else if rawValue == "🩰" {
-            self.init(baseEmoji: .balletShoes, skinTones: nil)
-        } else if rawValue == "👢" {
-            self.init(baseEmoji: .boot, skinTones: nil)
-        } else if rawValue == "👑" {
-            self.init(baseEmoji: .crown, skinTones: nil)
-        } else if rawValue == "👒" {
-            self.init(baseEmoji: .womansHat, skinTones: nil)
-        } else if rawValue == "🎩" {
-            self.init(baseEmoji: .tophat, skinTones: nil)
-        } else if rawValue == "🎓" {
-            self.init(baseEmoji: .mortarBoard, skinTones: nil)
-        } else if rawValue == "🧢" {
-            self.init(baseEmoji: .billedCap, skinTones: nil)
-        } else if rawValue == "🪖" {
-            self.init(baseEmoji: .militaryHelmet, skinTones: nil)
-        } else if rawValue == "⛑️" {
-            self.init(baseEmoji: .helmetWithWhiteCross, skinTones: nil)
-        } else if rawValue == "📿" {
-            self.init(baseEmoji: .prayerBeads, skinTones: nil)
-        } else if rawValue == "💄" {
-            self.init(baseEmoji: .lipstick, skinTones: nil)
-        } else if rawValue == "💍" {
-            self.init(baseEmoji: .ring, skinTones: nil)
-        } else if rawValue == "💎" {
-            self.init(baseEmoji: .gem, skinTones: nil)
-        } else if rawValue == "🔇" {
-            self.init(baseEmoji: .mute, skinTones: nil)
-        } else if rawValue == "🔈" {
-            self.init(baseEmoji: .speaker, skinTones: nil)
-        } else if rawValue == "🔉" {
-            self.init(baseEmoji: .sound, skinTones: nil)
-        } else if rawValue == "🔊" {
-            self.init(baseEmoji: .loudSound, skinTones: nil)
-        } else if rawValue == "📢" {
-            self.init(baseEmoji: .loudspeaker, skinTones: nil)
-        } else if rawValue == "📣" {
-            self.init(baseEmoji: .mega, skinTones: nil)
-        } else if rawValue == "📯" {
-            self.init(baseEmoji: .postalHorn, skinTones: nil)
-        } else if rawValue == "🔔" {
-            self.init(baseEmoji: .bell, skinTones: nil)
-        } else if rawValue == "🔕" {
-            self.init(baseEmoji: .noBell, skinTones: nil)
-        } else if rawValue == "🎼" {
-            self.init(baseEmoji: .musicalScore, skinTones: nil)
-        } else if rawValue == "🎵" {
-            self.init(baseEmoji: .musicalNote, skinTones: nil)
-        } else if rawValue == "🎶" {
-            self.init(baseEmoji: .notes, skinTones: nil)
-        } else if rawValue == "🎙️" {
-            self.init(baseEmoji: .studioMicrophone, skinTones: nil)
-        } else if rawValue == "🎚️" {
-            self.init(baseEmoji: .levelSlider, skinTones: nil)
-        } else if rawValue == "🎛️" {
-            self.init(baseEmoji: .controlKnobs, skinTones: nil)
-        } else if rawValue == "🎤" {
-            self.init(baseEmoji: .microphone, skinTones: nil)
-        } else if rawValue == "🎧" {
-            self.init(baseEmoji: .headphones, skinTones: nil)
-        } else if rawValue == "📻" {
-            self.init(baseEmoji: .radio, skinTones: nil)
-        } else if rawValue == "🎷" {
-            self.init(baseEmoji: .saxophone, skinTones: nil)
-        } else if rawValue == "🪗" {
-            self.init(baseEmoji: .accordion, skinTones: nil)
-        } else if rawValue == "🎸" {
-            self.init(baseEmoji: .guitar, skinTones: nil)
-        } else if rawValue == "🎹" {
-            self.init(baseEmoji: .musicalKeyboard, skinTones: nil)
-        } else if rawValue == "🎺" {
-            self.init(baseEmoji: .trumpet, skinTones: nil)
-        } else if rawValue == "🎻" {
-            self.init(baseEmoji: .violin, skinTones: nil)
-        } else if rawValue == "🪕" {
-            self.init(baseEmoji: .banjo, skinTones: nil)
-        } else if rawValue == "🥁" {
-            self.init(baseEmoji: .drumWithDrumsticks, skinTones: nil)
-        } else if rawValue == "🪘" {
-            self.init(baseEmoji: .longDrum, skinTones: nil)
-        } else if rawValue == "📱" {
-            self.init(baseEmoji: .iphone, skinTones: nil)
-        } else if rawValue == "📲" {
-            self.init(baseEmoji: .calling, skinTones: nil)
-        } else if rawValue == "☎️" {
-            self.init(baseEmoji: .phone, skinTones: nil)
-        } else if rawValue == "📞" {
-            self.init(baseEmoji: .telephoneReceiver, skinTones: nil)
-        } else if rawValue == "📟" {
-            self.init(baseEmoji: .pager, skinTones: nil)
-        } else if rawValue == "📠" {
-            self.init(baseEmoji: .fax, skinTones: nil)
-        } else if rawValue == "🔋" {
-            self.init(baseEmoji: .battery, skinTones: nil)
-        } else if rawValue == "🪫" {
-            self.init(baseEmoji: .lowBattery, skinTones: nil)
-        } else if rawValue == "🔌" {
-            self.init(baseEmoji: .electricPlug, skinTones: nil)
-        } else if rawValue == "💻" {
-            self.init(baseEmoji: .computer, skinTones: nil)
-        } else if rawValue == "🖥️" {
-            self.init(baseEmoji: .desktopComputer, skinTones: nil)
-        } else if rawValue == "🖨️" {
-            self.init(baseEmoji: .printer, skinTones: nil)
-        } else if rawValue == "⌨️" {
-            self.init(baseEmoji: .keyboard, skinTones: nil)
-        } else if rawValue == "🖱️" {
-            self.init(baseEmoji: .threeButtonMouse, skinTones: nil)
-        } else if rawValue == "🖲️" {
-            self.init(baseEmoji: .trackball, skinTones: nil)
-        } else if rawValue == "💽" {
-            self.init(baseEmoji: .minidisc, skinTones: nil)
-        } else if rawValue == "💾" {
-            self.init(baseEmoji: .floppyDisk, skinTones: nil)
-        } else if rawValue == "💿" {
-            self.init(baseEmoji: .cd, skinTones: nil)
-        } else if rawValue == "📀" {
-            self.init(baseEmoji: .dvd, skinTones: nil)
-        } else if rawValue == "🧮" {
-            self.init(baseEmoji: .abacus, skinTones: nil)
-        } else if rawValue == "🎥" {
-            self.init(baseEmoji: .movieCamera, skinTones: nil)
-        } else if rawValue == "🎞️" {
-            self.init(baseEmoji: .filmFrames, skinTones: nil)
-        } else if rawValue == "📽️" {
-            self.init(baseEmoji: .filmProjector, skinTones: nil)
-        } else if rawValue == "🎬" {
-            self.init(baseEmoji: .clapper, skinTones: nil)
-        } else if rawValue == "📺" {
-            self.init(baseEmoji: .tv, skinTones: nil)
-        } else if rawValue == "📷" {
-            self.init(baseEmoji: .camera, skinTones: nil)
-        } else if rawValue == "📸" {
-            self.init(baseEmoji: .cameraWithFlash, skinTones: nil)
-        } else if rawValue == "📹" {
-            self.init(baseEmoji: .videoCamera, skinTones: nil)
-        } else if rawValue == "📼" {
-            self.init(baseEmoji: .vhs, skinTones: nil)
-        } else if rawValue == "🔍" {
-            self.init(baseEmoji: .mag, skinTones: nil)
-        } else if rawValue == "🔎" {
-            self.init(baseEmoji: .magRight, skinTones: nil)
-        } else if rawValue == "🕯️" {
-            self.init(baseEmoji: .candle, skinTones: nil)
-        } else if rawValue == "💡" {
-            self.init(baseEmoji: .bulb, skinTones: nil)
-        } else if rawValue == "🔦" {
-            self.init(baseEmoji: .flashlight, skinTones: nil)
-        } else if rawValue == "🏮" {
-            self.init(baseEmoji: .izakayaLantern, skinTones: nil)
-        } else if rawValue == "🪔" {
-            self.init(baseEmoji: .diyaLamp, skinTones: nil)
-        } else if rawValue == "📔" {
-            self.init(baseEmoji: .notebookWithDecorativeCover, skinTones: nil)
-        } else if rawValue == "📕" {
-            self.init(baseEmoji: .closedBook, skinTones: nil)
-        } else if rawValue == "📖" {
-            self.init(baseEmoji: .book, skinTones: nil)
-        } else if rawValue == "📗" {
-            self.init(baseEmoji: .greenBook, skinTones: nil)
-        } else if rawValue == "📘" {
-            self.init(baseEmoji: .blueBook, skinTones: nil)
-        } else if rawValue == "📙" {
-            self.init(baseEmoji: .orangeBook, skinTones: nil)
-        } else if rawValue == "📚" {
-            self.init(baseEmoji: .books, skinTones: nil)
-        } else if rawValue == "📓" {
-            self.init(baseEmoji: .notebook, skinTones: nil)
-        } else if rawValue == "📒" {
-            self.init(baseEmoji: .ledger, skinTones: nil)
-        } else if rawValue == "📃" {
-            self.init(baseEmoji: .pageWithCurl, skinTones: nil)
-        } else if rawValue == "📜" {
-            self.init(baseEmoji: .scroll, skinTones: nil)
-        } else if rawValue == "📄" {
-            self.init(baseEmoji: .pageFacingUp, skinTones: nil)
-        } else if rawValue == "📰" {
-            self.init(baseEmoji: .newspaper, skinTones: nil)
-        } else if rawValue == "🗞️" {
-            self.init(baseEmoji: .rolledUpNewspaper, skinTones: nil)
-        } else if rawValue == "📑" {
-            self.init(baseEmoji: .bookmarkTabs, skinTones: nil)
-        } else if rawValue == "🔖" {
-            self.init(baseEmoji: .bookmark, skinTones: nil)
-        } else if rawValue == "🏷️" {
-            self.init(baseEmoji: .label, skinTones: nil)
-        } else if rawValue == "💰" {
-            self.init(baseEmoji: .moneybag, skinTones: nil)
-        } else if rawValue == "🪙" {
-            self.init(baseEmoji: .coin, skinTones: nil)
-        } else if rawValue == "💴" {
-            self.init(baseEmoji: .yen, skinTones: nil)
-        } else if rawValue == "💵" {
-            self.init(baseEmoji: .dollar, skinTones: nil)
-        } else if rawValue == "💶" {
-            self.init(baseEmoji: .euro, skinTones: nil)
-        } else if rawValue == "💷" {
-            self.init(baseEmoji: .pound, skinTones: nil)
-        } else if rawValue == "💸" {
-            self.init(baseEmoji: .moneyWithWings, skinTones: nil)
-        } else if rawValue == "💳" {
-            self.init(baseEmoji: .creditCard, skinTones: nil)
-        } else if rawValue == "🧾" {
-            self.init(baseEmoji: .receipt, skinTones: nil)
-        } else if rawValue == "💹" {
-            self.init(baseEmoji: .chart, skinTones: nil)
-        } else if rawValue == "✉️" {
-            self.init(baseEmoji: .email, skinTones: nil)
-        } else if rawValue == "📧" {
-            self.init(baseEmoji: .eMail, skinTones: nil)
-        } else if rawValue == "📨" {
-            self.init(baseEmoji: .incomingEnvelope, skinTones: nil)
-        } else if rawValue == "📩" {
-            self.init(baseEmoji: .envelopeWithArrow, skinTones: nil)
-        } else if rawValue == "📤" {
-            self.init(baseEmoji: .outboxTray, skinTones: nil)
-        } else if rawValue == "📥" {
-            self.init(baseEmoji: .inboxTray, skinTones: nil)
-        } else if rawValue == "📦" {
-            self.init(baseEmoji: .package, skinTones: nil)
-        } else if rawValue == "📫" {
-            self.init(baseEmoji: .mailbox, skinTones: nil)
-        } else if rawValue == "📪" {
-            self.init(baseEmoji: .mailboxClosed, skinTones: nil)
-        } else if rawValue == "📬" {
-            self.init(baseEmoji: .mailboxWithMail, skinTones: nil)
-        } else if rawValue == "📭" {
-            self.init(baseEmoji: .mailboxWithNoMail, skinTones: nil)
-        } else if rawValue == "📮" {
-            self.init(baseEmoji: .postbox, skinTones: nil)
-        } else if rawValue == "🗳️" {
-            self.init(baseEmoji: .ballotBoxWithBallot, skinTones: nil)
-        } else if rawValue == "✏️" {
-            self.init(baseEmoji: .pencil2, skinTones: nil)
-        } else if rawValue == "✒️" {
-            self.init(baseEmoji: .blackNib, skinTones: nil)
-        } else if rawValue == "🖋️" {
-            self.init(baseEmoji: .lowerLeftFountainPen, skinTones: nil)
-        } else if rawValue == "🖊️" {
-            self.init(baseEmoji: .lowerLeftBallpointPen, skinTones: nil)
-        } else if rawValue == "🖌️" {
-            self.init(baseEmoji: .lowerLeftPaintbrush, skinTones: nil)
-        } else if rawValue == "🖍️" {
-            self.init(baseEmoji: .lowerLeftCrayon, skinTones: nil)
-        } else if rawValue == "📝" {
-            self.init(baseEmoji: .memo, skinTones: nil)
-        } else if rawValue == "💼" {
-            self.init(baseEmoji: .briefcase, skinTones: nil)
-        } else if rawValue == "📁" {
-            self.init(baseEmoji: .fileFolder, skinTones: nil)
-        } else if rawValue == "📂" {
-            self.init(baseEmoji: .openFileFolder, skinTones: nil)
-        } else if rawValue == "🗂️" {
-            self.init(baseEmoji: .cardIndexDividers, skinTones: nil)
-        } else if rawValue == "📅" {
-            self.init(baseEmoji: .date, skinTones: nil)
-        } else if rawValue == "📆" {
-            self.init(baseEmoji: .calendar, skinTones: nil)
-        } else if rawValue == "🗒️" {
-            self.init(baseEmoji: .spiralNotePad, skinTones: nil)
-        } else if rawValue == "🗓️" {
-            self.init(baseEmoji: .spiralCalendarPad, skinTones: nil)
-        } else if rawValue == "📇" {
-            self.init(baseEmoji: .cardIndex, skinTones: nil)
-        } else if rawValue == "📈" {
-            self.init(baseEmoji: .chartWithUpwardsTrend, skinTones: nil)
-        } else if rawValue == "📉" {
-            self.init(baseEmoji: .chartWithDownwardsTrend, skinTones: nil)
-        } else if rawValue == "📊" {
-            self.init(baseEmoji: .barChart, skinTones: nil)
-        } else if rawValue == "📋" {
-            self.init(baseEmoji: .clipboard, skinTones: nil)
-        } else if rawValue == "📌" {
-            self.init(baseEmoji: .pushpin, skinTones: nil)
-        } else if rawValue == "📍" {
-            self.init(baseEmoji: .roundPushpin, skinTones: nil)
-        } else if rawValue == "📎" {
-            self.init(baseEmoji: .paperclip, skinTones: nil)
-        } else if rawValue == "🖇️" {
-            self.init(baseEmoji: .linkedPaperclips, skinTones: nil)
-        } else if rawValue == "📏" {
-            self.init(baseEmoji: .straightRuler, skinTones: nil)
-        } else if rawValue == "📐" {
-            self.init(baseEmoji: .triangularRuler, skinTones: nil)
-        } else if rawValue == "✂️" {
-            self.init(baseEmoji: .scissors, skinTones: nil)
-        } else if rawValue == "🗃️" {
-            self.init(baseEmoji: .cardFileBox, skinTones: nil)
-        } else if rawValue == "🗄️" {
-            self.init(baseEmoji: .fileCabinet, skinTones: nil)
-        } else if rawValue == "🗑️" {
-            self.init(baseEmoji: .wastebasket, skinTones: nil)
-        } else if rawValue == "🔒" {
-            self.init(baseEmoji: .lock, skinTones: nil)
-        } else if rawValue == "🔓" {
-            self.init(baseEmoji: .unlock, skinTones: nil)
-        } else if rawValue == "🔏" {
-            self.init(baseEmoji: .lockWithInkPen, skinTones: nil)
-        } else if rawValue == "🔐" {
-            self.init(baseEmoji: .closedLockWithKey, skinTones: nil)
-        } else if rawValue == "🔑" {
-            self.init(baseEmoji: .key, skinTones: nil)
-        } else if rawValue == "🗝️" {
-            self.init(baseEmoji: .oldKey, skinTones: nil)
-        } else if rawValue == "🔨" {
-            self.init(baseEmoji: .hammer, skinTones: nil)
-        } else if rawValue == "🪓" {
-            self.init(baseEmoji: .axe, skinTones: nil)
-        } else if rawValue == "⛏️" {
-            self.init(baseEmoji: .pick, skinTones: nil)
-        } else if rawValue == "⚒️" {
-            self.init(baseEmoji: .hammerAndPick, skinTones: nil)
-        } else if rawValue == "🛠️" {
-            self.init(baseEmoji: .hammerAndWrench, skinTones: nil)
-        } else if rawValue == "🗡️" {
-            self.init(baseEmoji: .daggerKnife, skinTones: nil)
-        } else if rawValue == "⚔️" {
-            self.init(baseEmoji: .crossedSwords, skinTones: nil)
-        } else if rawValue == "🔫" {
-            self.init(baseEmoji: .gun, skinTones: nil)
-        } else if rawValue == "🪃" {
-            self.init(baseEmoji: .boomerang, skinTones: nil)
-        } else if rawValue == "🏹" {
-            self.init(baseEmoji: .bowAndArrow, skinTones: nil)
-        } else if rawValue == "🛡️" {
-            self.init(baseEmoji: .shield, skinTones: nil)
-        } else if rawValue == "🪚" {
-            self.init(baseEmoji: .carpentrySaw, skinTones: nil)
-        } else if rawValue == "🔧" {
-            self.init(baseEmoji: .wrench, skinTones: nil)
-        } else if rawValue == "🪛" {
-            self.init(baseEmoji: .screwdriver, skinTones: nil)
-        } else if rawValue == "🔩" {
-            self.init(baseEmoji: .nutAndBolt, skinTones: nil)
-        } else if rawValue == "⚙️" {
-            self.init(baseEmoji: .gear, skinTones: nil)
-        } else if rawValue == "🗜️" {
-            self.init(baseEmoji: .compression, skinTones: nil)
-        } else if rawValue == "⚖️" {
-            self.init(baseEmoji: .scales, skinTones: nil)
-        } else if rawValue == "🦯" {
-            self.init(baseEmoji: .probingCane, skinTones: nil)
-        } else if rawValue == "🔗" {
-            self.init(baseEmoji: .link, skinTones: nil)
-        } else if rawValue == "⛓️" {
-            self.init(baseEmoji: .chains, skinTones: nil)
-        } else if rawValue == "🪝" {
-            self.init(baseEmoji: .hook, skinTones: nil)
-        } else if rawValue == "🧰" {
-            self.init(baseEmoji: .toolbox, skinTones: nil)
-        } else if rawValue == "🧲" {
-            self.init(baseEmoji: .magnet, skinTones: nil)
-        } else if rawValue == "🪜" {
-            self.init(baseEmoji: .ladder, skinTones: nil)
-        } else if rawValue == "⚗️" {
-            self.init(baseEmoji: .alembic, skinTones: nil)
-        } else if rawValue == "🧪" {
-            self.init(baseEmoji: .testTube, skinTones: nil)
-        } else if rawValue == "🧫" {
-            self.init(baseEmoji: .petriDish, skinTones: nil)
-        } else if rawValue == "🧬" {
-            self.init(baseEmoji: .dna, skinTones: nil)
-        } else if rawValue == "🔬" {
-            self.init(baseEmoji: .microscope, skinTones: nil)
-        } else if rawValue == "🔭" {
-            self.init(baseEmoji: .telescope, skinTones: nil)
-        } else if rawValue == "📡" {
-            self.init(baseEmoji: .satelliteAntenna, skinTones: nil)
-        } else if rawValue == "💉" {
-            self.init(baseEmoji: .syringe, skinTones: nil)
-        } else if rawValue == "🩸" {
-            self.init(baseEmoji: .dropOfBlood, skinTones: nil)
-        } else if rawValue == "💊" {
-            self.init(baseEmoji: .pill, skinTones: nil)
-        } else if rawValue == "🩹" {
-            self.init(baseEmoji: .adhesiveBandage, skinTones: nil)
-        } else if rawValue == "🩼" {
-            self.init(baseEmoji: .crutch, skinTones: nil)
-        } else if rawValue == "🩺" {
-            self.init(baseEmoji: .stethoscope, skinTones: nil)
-        } else if rawValue == "🩻" {
-            self.init(baseEmoji: .xRay, skinTones: nil)
-        } else if rawValue == "🚪" {
-            self.init(baseEmoji: .door, skinTones: nil)
-        } else if rawValue == "🛗" {
-            self.init(baseEmoji: .elevator, skinTones: nil)
-        } else if rawValue == "🪞" {
-            self.init(baseEmoji: .mirror, skinTones: nil)
-        } else if rawValue == "🪟" {
-            self.init(baseEmoji: .window, skinTones: nil)
-        } else if rawValue == "🛏️" {
-            self.init(baseEmoji: .bed, skinTones: nil)
-        } else if rawValue == "🛋️" {
-            self.init(baseEmoji: .couchAndLamp, skinTones: nil)
-        } else if rawValue == "🪑" {
-            self.init(baseEmoji: .chair, skinTones: nil)
-        } else if rawValue == "🚽" {
-            self.init(baseEmoji: .toilet, skinTones: nil)
-        } else if rawValue == "🪠" {
-            self.init(baseEmoji: .plunger, skinTones: nil)
-        } else if rawValue == "🚿" {
-            self.init(baseEmoji: .shower, skinTones: nil)
-        } else if rawValue == "🛁" {
-            self.init(baseEmoji: .bathtub, skinTones: nil)
-        } else if rawValue == "🪤" {
-            self.init(baseEmoji: .mouseTrap, skinTones: nil)
-        } else if rawValue == "🪒" {
-            self.init(baseEmoji: .razor, skinTones: nil)
-        } else if rawValue == "🧴" {
-            self.init(baseEmoji: .lotionBottle, skinTones: nil)
-        } else if rawValue == "🧷" {
-            self.init(baseEmoji: .safetyPin, skinTones: nil)
-        } else if rawValue == "🧹" {
-            self.init(baseEmoji: .broom, skinTones: nil)
-        } else if rawValue == "🧺" {
-            self.init(baseEmoji: .basket, skinTones: nil)
-        } else if rawValue == "🧻" {
-            self.init(baseEmoji: .rollOfPaper, skinTones: nil)
-        } else if rawValue == "🪣" {
-            self.init(baseEmoji: .bucket, skinTones: nil)
-        } else if rawValue == "🧼" {
-            self.init(baseEmoji: .soap, skinTones: nil)
-        } else if rawValue == "🫧" {
-            self.init(baseEmoji: .bubbles, skinTones: nil)
-        } else if rawValue == "🪥" {
-            self.init(baseEmoji: .toothbrush, skinTones: nil)
-        } else if rawValue == "🧽" {
-            self.init(baseEmoji: .sponge, skinTones: nil)
-        } else if rawValue == "🧯" {
-            self.init(baseEmoji: .fireExtinguisher, skinTones: nil)
-        } else if rawValue == "🛒" {
-            self.init(baseEmoji: .shoppingTrolley, skinTones: nil)
-        } else if rawValue == "🚬" {
-            self.init(baseEmoji: .smoking, skinTones: nil)
-        } else if rawValue == "⚰️" {
-            self.init(baseEmoji: .coffin, skinTones: nil)
-        } else if rawValue == "🪦" {
-            self.init(baseEmoji: .headstone, skinTones: nil)
-        } else if rawValue == "⚱️" {
-            self.init(baseEmoji: .funeralUrn, skinTones: nil)
-        } else if rawValue == "🗿" {
-            self.init(baseEmoji: .moyai, skinTones: nil)
-        } else if rawValue == "🪧" {
-            self.init(baseEmoji: .placard, skinTones: nil)
-        } else if rawValue == "🪪" {
-            self.init(baseEmoji: .identificationCard, skinTones: nil)
-        } else if rawValue == "🏧" {
-            self.init(baseEmoji: .atm, skinTones: nil)
-        } else if rawValue == "🚮" {
-            self.init(baseEmoji: .putLitterInItsPlace, skinTones: nil)
-        } else if rawValue == "🚰" {
-            self.init(baseEmoji: .potableWater, skinTones: nil)
-        } else if rawValue == "♿" {
-            self.init(baseEmoji: .wheelchair, skinTones: nil)
-        } else if rawValue == "🚹" {
-            self.init(baseEmoji: .mens, skinTones: nil)
-        } else if rawValue == "🚺" {
-            self.init(baseEmoji: .womens, skinTones: nil)
-        } else if rawValue == "🚻" {
-            self.init(baseEmoji: .restroom, skinTones: nil)
-        } else if rawValue == "🚼" {
-            self.init(baseEmoji: .babySymbol, skinTones: nil)
-        } else if rawValue == "🚾" {
-            self.init(baseEmoji: .wc, skinTones: nil)
-        } else if rawValue == "🛂" {
-            self.init(baseEmoji: .passportControl, skinTones: nil)
-        } else if rawValue == "🛃" {
-            self.init(baseEmoji: .customs, skinTones: nil)
-        } else if rawValue == "🛄" {
-            self.init(baseEmoji: .baggageClaim, skinTones: nil)
-        } else if rawValue == "🛅" {
-            self.init(baseEmoji: .leftLuggage, skinTones: nil)
-        } else if rawValue == "⚠️" {
-            self.init(baseEmoji: .warning, skinTones: nil)
-        } else if rawValue == "🚸" {
-            self.init(baseEmoji: .childrenCrossing, skinTones: nil)
-        } else if rawValue == "⛔" {
-            self.init(baseEmoji: .noEntry, skinTones: nil)
-        } else if rawValue == "🚫" {
-            self.init(baseEmoji: .noEntrySign, skinTones: nil)
-        } else if rawValue == "🚳" {
-            self.init(baseEmoji: .noBicycles, skinTones: nil)
-        } else if rawValue == "🚭" {
-            self.init(baseEmoji: .noSmoking, skinTones: nil)
-        } else if rawValue == "🚯" {
-            self.init(baseEmoji: .doNotLitter, skinTones: nil)
-        } else if rawValue == "🚱" {
-            self.init(baseEmoji: .nonPotableWater, skinTones: nil)
-        } else if rawValue == "🚷" {
-            self.init(baseEmoji: .noPedestrians, skinTones: nil)
-        } else if rawValue == "📵" {
-            self.init(baseEmoji: .noMobilePhones, skinTones: nil)
-        } else if rawValue == "🔞" {
-            self.init(baseEmoji: .underage, skinTones: nil)
-        } else if rawValue == "☢️" {
-            self.init(baseEmoji: .radioactiveSign, skinTones: nil)
-        } else if rawValue == "☣️" {
-            self.init(baseEmoji: .biohazardSign, skinTones: nil)
-        } else if rawValue == "⬆️" {
-            self.init(baseEmoji: .arrowUp, skinTones: nil)
-        } else if rawValue == "↗️" {
-            self.init(baseEmoji: .arrowUpperRight, skinTones: nil)
-        } else if rawValue == "➡️" {
-            self.init(baseEmoji: .arrowRight, skinTones: nil)
-        } else if rawValue == "↘️" {
-            self.init(baseEmoji: .arrowLowerRight, skinTones: nil)
-        } else if rawValue == "⬇️" {
-            self.init(baseEmoji: .arrowDown, skinTones: nil)
-        } else if rawValue == "↙️" {
-            self.init(baseEmoji: .arrowLowerLeft, skinTones: nil)
-        } else if rawValue == "⬅️" {
-            self.init(baseEmoji: .arrowLeft, skinTones: nil)
-        } else if rawValue == "↖️" {
-            self.init(baseEmoji: .arrowUpperLeft, skinTones: nil)
-        } else if rawValue == "↕️" {
-            self.init(baseEmoji: .arrowUpDown, skinTones: nil)
-        } else if rawValue == "↔️" {
-            self.init(baseEmoji: .leftRightArrow, skinTones: nil)
-        } else if rawValue == "↩️" {
-            self.init(baseEmoji: .leftwardsArrowWithHook, skinTones: nil)
-        } else if rawValue == "↪️" {
-            self.init(baseEmoji: .arrowRightHook, skinTones: nil)
-        } else if rawValue == "⤴️" {
-            self.init(baseEmoji: .arrowHeadingUp, skinTones: nil)
-        } else if rawValue == "⤵️" {
-            self.init(baseEmoji: .arrowHeadingDown, skinTones: nil)
-        } else if rawValue == "🔃" {
-            self.init(baseEmoji: .arrowsClockwise, skinTones: nil)
-        } else if rawValue == "🔄" {
-            self.init(baseEmoji: .arrowsCounterclockwise, skinTones: nil)
-        } else if rawValue == "🔙" {
-            self.init(baseEmoji: .back, skinTones: nil)
-        } else if rawValue == "🔚" {
-            self.init(baseEmoji: .end, skinTones: nil)
-        } else if rawValue == "🔛" {
-            self.init(baseEmoji: .on, skinTones: nil)
-        } else if rawValue == "🔜" {
-            self.init(baseEmoji: .soon, skinTones: nil)
-        } else if rawValue == "🔝" {
-            self.init(baseEmoji: .top, skinTones: nil)
-        } else if rawValue == "🛐" {
-            self.init(baseEmoji: .placeOfWorship, skinTones: nil)
-        } else if rawValue == "⚛️" {
-            self.init(baseEmoji: .atomSymbol, skinTones: nil)
-        } else if rawValue == "🕉️" {
-            self.init(baseEmoji: .omSymbol, skinTones: nil)
-        } else if rawValue == "✡️" {
-            self.init(baseEmoji: .starOfDavid, skinTones: nil)
-        } else if rawValue == "☸️" {
-            self.init(baseEmoji: .wheelOfDharma, skinTones: nil)
-        } else if rawValue == "☯️" {
-            self.init(baseEmoji: .yinYang, skinTones: nil)
-        } else if rawValue == "✝️" {
-            self.init(baseEmoji: .latinCross, skinTones: nil)
-        } else if rawValue == "☦️" {
-            self.init(baseEmoji: .orthodoxCross, skinTones: nil)
-        } else if rawValue == "☪️" {
-            self.init(baseEmoji: .starAndCrescent, skinTones: nil)
-        } else if rawValue == "☮️" {
-            self.init(baseEmoji: .peaceSymbol, skinTones: nil)
-        } else if rawValue == "🕎" {
-            self.init(baseEmoji: .menorahWithNineBranches, skinTones: nil)
-        } else if rawValue == "🔯" {
-            self.init(baseEmoji: .sixPointedStar, skinTones: nil)
-        } else if rawValue == "♈" {
-            self.init(baseEmoji: .aries, skinTones: nil)
-        } else if rawValue == "♉" {
-            self.init(baseEmoji: .taurus, skinTones: nil)
-        } else if rawValue == "♊" {
-            self.init(baseEmoji: .gemini, skinTones: nil)
-        } else if rawValue == "♋" {
-            self.init(baseEmoji: .cancer, skinTones: nil)
-        } else if rawValue == "♌" {
-            self.init(baseEmoji: .leo, skinTones: nil)
-        } else if rawValue == "♍" {
-            self.init(baseEmoji: .virgo, skinTones: nil)
-        } else if rawValue == "♎" {
-            self.init(baseEmoji: .libra, skinTones: nil)
-        } else if rawValue == "♏" {
-            self.init(baseEmoji: .scorpius, skinTones: nil)
-        } else if rawValue == "♐" {
-            self.init(baseEmoji: .sagittarius, skinTones: nil)
-        } else if rawValue == "♑" {
-            self.init(baseEmoji: .capricorn, skinTones: nil)
-        } else if rawValue == "♒" {
-            self.init(baseEmoji: .aquarius, skinTones: nil)
-        } else if rawValue == "♓" {
-            self.init(baseEmoji: .pisces, skinTones: nil)
-        } else if rawValue == "⛎" {
-            self.init(baseEmoji: .ophiuchus, skinTones: nil)
-        } else if rawValue == "🔀" {
-            self.init(baseEmoji: .twistedRightwardsArrows, skinTones: nil)
-        } else if rawValue == "🔁" {
-            self.init(baseEmoji: .`repeat`, skinTones: nil)
-        } else if rawValue == "🔂" {
-            self.init(baseEmoji: .repeatOne, skinTones: nil)
-        } else if rawValue == "▶️" {
-            self.init(baseEmoji: .arrowForward, skinTones: nil)
-        } else if rawValue == "⏩" {
-            self.init(baseEmoji: .fastForward, skinTones: nil)
-        } else if rawValue == "⏭️" {
-            self.init(baseEmoji: .blackRightPointingDoubleTriangleWithVerticalBar, skinTones: nil)
-        } else if rawValue == "⏯️" {
-            self.init(baseEmoji: .blackRightPointingTriangleWithDoubleVerticalBar, skinTones: nil)
-        } else if rawValue == "◀️" {
-            self.init(baseEmoji: .arrowBackward, skinTones: nil)
-        } else if rawValue == "⏪" {
-            self.init(baseEmoji: .rewind, skinTones: nil)
-        } else if rawValue == "⏮️" {
-            self.init(baseEmoji: .blackLeftPointingDoubleTriangleWithVerticalBar, skinTones: nil)
-        } else if rawValue == "🔼" {
-            self.init(baseEmoji: .arrowUpSmall, skinTones: nil)
-        } else if rawValue == "⏫" {
-            self.init(baseEmoji: .arrowDoubleUp, skinTones: nil)
-        } else if rawValue == "🔽" {
-            self.init(baseEmoji: .arrowDownSmall, skinTones: nil)
-        } else if rawValue == "⏬" {
-            self.init(baseEmoji: .arrowDoubleDown, skinTones: nil)
-        } else if rawValue == "⏸️" {
-            self.init(baseEmoji: .doubleVerticalBar, skinTones: nil)
-        } else if rawValue == "⏹️" {
-            self.init(baseEmoji: .blackSquareForStop, skinTones: nil)
-        } else if rawValue == "⏺️" {
-            self.init(baseEmoji: .blackCircleForRecord, skinTones: nil)
-        } else if rawValue == "⏏️" {
-            self.init(baseEmoji: .eject, skinTones: nil)
-        } else if rawValue == "🎦" {
-            self.init(baseEmoji: .cinema, skinTones: nil)
-        } else if rawValue == "🔅" {
-            self.init(baseEmoji: .lowBrightness, skinTones: nil)
-        } else if rawValue == "🔆" {
-            self.init(baseEmoji: .highBrightness, skinTones: nil)
-        } else if rawValue == "📶" {
-            self.init(baseEmoji: .signalStrength, skinTones: nil)
-        } else if rawValue == "📳" {
-            self.init(baseEmoji: .vibrationMode, skinTones: nil)
-        } else if rawValue == "📴" {
-            self.init(baseEmoji: .mobilePhoneOff, skinTones: nil)
-        } else if rawValue == "♀️" {
-            self.init(baseEmoji: .femaleSign, skinTones: nil)
-        } else if rawValue == "♂️" {
-            self.init(baseEmoji: .maleSign, skinTones: nil)
-        } else if rawValue == "⚧️" {
-            self.init(baseEmoji: .transgenderSymbol, skinTones: nil)
-        } else if rawValue == "✖️" {
-            self.init(baseEmoji: .heavyMultiplicationX, skinTones: nil)
-        } else if rawValue == "➕" {
-            self.init(baseEmoji: .heavyPlusSign, skinTones: nil)
-        } else if rawValue == "➖" {
-            self.init(baseEmoji: .heavyMinusSign, skinTones: nil)
-        } else if rawValue == "➗" {
-            self.init(baseEmoji: .heavyDivisionSign, skinTones: nil)
-        } else if rawValue == "🟰" {
-            self.init(baseEmoji: .heavyEqualsSign, skinTones: nil)
-        } else if rawValue == "♾️" {
-            self.init(baseEmoji: .infinity, skinTones: nil)
-        } else if rawValue == "‼️" {
-            self.init(baseEmoji: .bangbang, skinTones: nil)
-        } else if rawValue == "⁉️" {
-            self.init(baseEmoji: .interrobang, skinTones: nil)
-        } else if rawValue == "❓" {
-            self.init(baseEmoji: .question, skinTones: nil)
-        } else if rawValue == "❔" {
-            self.init(baseEmoji: .greyQuestion, skinTones: nil)
-        } else if rawValue == "❕" {
-            self.init(baseEmoji: .greyExclamation, skinTones: nil)
-        } else if rawValue == "❗" {
-            self.init(baseEmoji: .exclamation, skinTones: nil)
-        } else if rawValue == "〰️" {
-            self.init(baseEmoji: .wavyDash, skinTones: nil)
-        } else if rawValue == "💱" {
-            self.init(baseEmoji: .currencyExchange, skinTones: nil)
-        } else if rawValue == "💲" {
-            self.init(baseEmoji: .heavyDollarSign, skinTones: nil)
-        } else if rawValue == "⚕️" {
-            self.init(baseEmoji: .medicalSymbol, skinTones: nil)
-        } else if rawValue == "♻️" {
-            self.init(baseEmoji: .recycle, skinTones: nil)
-        } else if rawValue == "⚜️" {
-            self.init(baseEmoji: .fleurDeLis, skinTones: nil)
-        } else if rawValue == "🔱" {
-            self.init(baseEmoji: .trident, skinTones: nil)
-        } else if rawValue == "📛" {
-            self.init(baseEmoji: .nameBadge, skinTones: nil)
-        } else if rawValue == "🔰" {
-            self.init(baseEmoji: .beginner, skinTones: nil)
-        } else if rawValue == "⭕" {
-            self.init(baseEmoji: .o, skinTones: nil)
-        } else if rawValue == "✅" {
-            self.init(baseEmoji: .whiteCheckMark, skinTones: nil)
-        } else if rawValue == "☑️" {
-            self.init(baseEmoji: .ballotBoxWithCheck, skinTones: nil)
-        } else if rawValue == "✔️" {
-            self.init(baseEmoji: .heavyCheckMark, skinTones: nil)
-        } else if rawValue == "❌" {
-            self.init(baseEmoji: .x, skinTones: nil)
-        } else if rawValue == "❎" {
-            self.init(baseEmoji: .negativeSquaredCrossMark, skinTones: nil)
-        } else if rawValue == "➰" {
-            self.init(baseEmoji: .curlyLoop, skinTones: nil)
-        } else if rawValue == "➿" {
-            self.init(baseEmoji: .loop, skinTones: nil)
-        } else if rawValue == "〽️" {
-            self.init(baseEmoji: .partAlternationMark, skinTones: nil)
-        } else if rawValue == "✳️" {
-            self.init(baseEmoji: .eightSpokedAsterisk, skinTones: nil)
-        } else if rawValue == "✴️" {
-            self.init(baseEmoji: .eightPointedBlackStar, skinTones: nil)
-        } else if rawValue == "❇️" {
-            self.init(baseEmoji: .sparkle, skinTones: nil)
-        } else if rawValue == "©️" {
-            self.init(baseEmoji: .copyright, skinTones: nil)
-        } else if rawValue == "®️" {
-            self.init(baseEmoji: .registered, skinTones: nil)
-        } else if rawValue == "™️" {
-            self.init(baseEmoji: .tm, skinTones: nil)
-        } else if rawValue == "#️⃣" {
-            self.init(baseEmoji: .hash, skinTones: nil)
-        } else if rawValue == "*️⃣" {
-            self.init(baseEmoji: .keycapStar, skinTones: nil)
-        } else if rawValue == "0️⃣" {
-            self.init(baseEmoji: .zero, skinTones: nil)
-        } else if rawValue == "1️⃣" {
-            self.init(baseEmoji: .one, skinTones: nil)
-        } else if rawValue == "2️⃣" {
-            self.init(baseEmoji: .two, skinTones: nil)
-        } else if rawValue == "3️⃣" {
-            self.init(baseEmoji: .three, skinTones: nil)
-        } else if rawValue == "4️⃣" {
-            self.init(baseEmoji: .four, skinTones: nil)
-        } else if rawValue == "5️⃣" {
-            self.init(baseEmoji: .five, skinTones: nil)
-        } else if rawValue == "6️⃣" {
-            self.init(baseEmoji: .six, skinTones: nil)
-        } else if rawValue == "7️⃣" {
-            self.init(baseEmoji: .seven, skinTones: nil)
-        } else if rawValue == "8️⃣" {
-            self.init(baseEmoji: .eight, skinTones: nil)
-        } else if rawValue == "9️⃣" {
-            self.init(baseEmoji: .nine, skinTones: nil)
-        } else if rawValue == "🔟" {
-            self.init(baseEmoji: .keycapTen, skinTones: nil)
-        } else if rawValue == "🔠" {
-            self.init(baseEmoji: .capitalAbcd, skinTones: nil)
-        } else if rawValue == "🔡" {
-            self.init(baseEmoji: .abcd, skinTones: nil)
-        } else if rawValue == "🔢" {
-            self.init(baseEmoji: .oneTwoThreeFour, skinTones: nil)
-        } else if rawValue == "🔣" {
-            self.init(baseEmoji: .symbols, skinTones: nil)
-        } else if rawValue == "🔤" {
-            self.init(baseEmoji: .abc, skinTones: nil)
-        } else if rawValue == "🅰️" {
-            self.init(baseEmoji: .a, skinTones: nil)
-        } else if rawValue == "🆎" {
-            self.init(baseEmoji: .ab, skinTones: nil)
-        } else if rawValue == "🅱️" {
-            self.init(baseEmoji: .b, skinTones: nil)
-        } else if rawValue == "🆑" {
-            self.init(baseEmoji: .cl, skinTones: nil)
-        } else if rawValue == "🆒" {
-            self.init(baseEmoji: .cool, skinTones: nil)
-        } else if rawValue == "🆓" {
-            self.init(baseEmoji: .free, skinTones: nil)
-        } else if rawValue == "ℹ️" {
-            self.init(baseEmoji: .informationSource, skinTones: nil)
-        } else if rawValue == "🆔" {
-            self.init(baseEmoji: .id, skinTones: nil)
-        } else if rawValue == "Ⓜ️" {
-            self.init(baseEmoji: .m, skinTones: nil)
-        } else if rawValue == "🆕" {
-            self.init(baseEmoji: .new, skinTones: nil)
-        } else if rawValue == "🆖" {
-            self.init(baseEmoji: .ng, skinTones: nil)
-        } else if rawValue == "🅾️" {
-            self.init(baseEmoji: .o2, skinTones: nil)
-        } else if rawValue == "🆗" {
-            self.init(baseEmoji: .ok, skinTones: nil)
-        } else if rawValue == "🅿️" {
-            self.init(baseEmoji: .parking, skinTones: nil)
-        } else if rawValue == "🆘" {
-            self.init(baseEmoji: .sos, skinTones: nil)
-        } else if rawValue == "🆙" {
-            self.init(baseEmoji: .up, skinTones: nil)
-        } else if rawValue == "🆚" {
-            self.init(baseEmoji: .vs, skinTones: nil)
-        } else if rawValue == "🈁" {
-            self.init(baseEmoji: .koko, skinTones: nil)
-        } else if rawValue == "🈂️" {
-            self.init(baseEmoji: .sa, skinTones: nil)
-        } else if rawValue == "🈷️" {
-            self.init(baseEmoji: .u6708, skinTones: nil)
-        } else if rawValue == "🈶" {
-            self.init(baseEmoji: .u6709, skinTones: nil)
-        } else if rawValue == "🈯" {
-            self.init(baseEmoji: .u6307, skinTones: nil)
-        } else if rawValue == "🉐" {
-            self.init(baseEmoji: .ideographAdvantage, skinTones: nil)
-        } else if rawValue == "🈹" {
-            self.init(baseEmoji: .u5272, skinTones: nil)
-        } else if rawValue == "🈚" {
-            self.init(baseEmoji: .u7121, skinTones: nil)
-        } else if rawValue == "🈲" {
-            self.init(baseEmoji: .u7981, skinTones: nil)
-        } else if rawValue == "🉑" {
-            self.init(baseEmoji: .accept, skinTones: nil)
-        } else if rawValue == "🈸" {
-            self.init(baseEmoji: .u7533, skinTones: nil)
-        } else if rawValue == "🈴" {
-            self.init(baseEmoji: .u5408, skinTones: nil)
-        } else if rawValue == "🈳" {
-            self.init(baseEmoji: .u7a7a, skinTones: nil)
-        } else if rawValue == "㊗️" {
-            self.init(baseEmoji: .congratulations, skinTones: nil)
-        } else if rawValue == "㊙️" {
-            self.init(baseEmoji: .secret, skinTones: nil)
-        } else if rawValue == "🈺" {
-            self.init(baseEmoji: .u55b6, skinTones: nil)
-        } else if rawValue == "🈵" {
-            self.init(baseEmoji: .u6e80, skinTones: nil)
-        } else if rawValue == "🔴" {
-            self.init(baseEmoji: .redCircle, skinTones: nil)
-        } else if rawValue == "🟠" {
-            self.init(baseEmoji: .largeOrangeCircle, skinTones: nil)
-        } else if rawValue == "🟡" {
-            self.init(baseEmoji: .largeYellowCircle, skinTones: nil)
-        } else if rawValue == "🟢" {
-            self.init(baseEmoji: .largeGreenCircle, skinTones: nil)
-        } else if rawValue == "🔵" {
-            self.init(baseEmoji: .largeBlueCircle, skinTones: nil)
-        } else if rawValue == "🟣" {
-            self.init(baseEmoji: .largePurpleCircle, skinTones: nil)
-        } else if rawValue == "🟤" {
-            self.init(baseEmoji: .largeBrownCircle, skinTones: nil)
-        } else if rawValue == "⚫" {
-            self.init(baseEmoji: .blackCircle, skinTones: nil)
-        } else if rawValue == "⚪" {
-            self.init(baseEmoji: .whiteCircle, skinTones: nil)
-        } else if rawValue == "🟥" {
-            self.init(baseEmoji: .largeRedSquare, skinTones: nil)
-        } else if rawValue == "🟧" {
-            self.init(baseEmoji: .largeOrangeSquare, skinTones: nil)
-        } else if rawValue == "🟨" {
-            self.init(baseEmoji: .largeYellowSquare, skinTones: nil)
-        } else if rawValue == "🟩" {
-            self.init(baseEmoji: .largeGreenSquare, skinTones: nil)
-        } else if rawValue == "🟦" {
-            self.init(baseEmoji: .largeBlueSquare, skinTones: nil)
-        } else if rawValue == "🟪" {
-            self.init(baseEmoji: .largePurpleSquare, skinTones: nil)
-        } else if rawValue == "🟫" {
-            self.init(baseEmoji: .largeBrownSquare, skinTones: nil)
-        } else if rawValue == "⬛" {
-            self.init(baseEmoji: .blackLargeSquare, skinTones: nil)
-        } else if rawValue == "⬜" {
-            self.init(baseEmoji: .whiteLargeSquare, skinTones: nil)
-        } else if rawValue == "◼️" {
-            self.init(baseEmoji: .blackMediumSquare, skinTones: nil)
-        } else if rawValue == "◻️" {
-            self.init(baseEmoji: .whiteMediumSquare, skinTones: nil)
-        } else if rawValue == "◾" {
-            self.init(baseEmoji: .blackMediumSmallSquare, skinTones: nil)
-        } else if rawValue == "◽" {
-            self.init(baseEmoji: .whiteMediumSmallSquare, skinTones: nil)
-        } else if rawValue == "▪️" {
-            self.init(baseEmoji: .blackSmallSquare, skinTones: nil)
-        } else if rawValue == "▫️" {
-            self.init(baseEmoji: .whiteSmallSquare, skinTones: nil)
-        } else if rawValue == "🔶" {
-            self.init(baseEmoji: .largeOrangeDiamond, skinTones: nil)
-        } else if rawValue == "🔷" {
-            self.init(baseEmoji: .largeBlueDiamond, skinTones: nil)
-        } else if rawValue == "🔸" {
-            self.init(baseEmoji: .smallOrangeDiamond, skinTones: nil)
-        } else if rawValue == "🔹" {
-            self.init(baseEmoji: .smallBlueDiamond, skinTones: nil)
-        } else if rawValue == "🔺" {
-            self.init(baseEmoji: .smallRedTriangle, skinTones: nil)
-        } else if rawValue == "🔻" {
-            self.init(baseEmoji: .smallRedTriangleDown, skinTones: nil)
-        } else if rawValue == "💠" {
-            self.init(baseEmoji: .diamondShapeWithADotInside, skinTones: nil)
-        } else if rawValue == "🔘" {
-            self.init(baseEmoji: .radioButton, skinTones: nil)
-        } else if rawValue == "🔳" {
-            self.init(baseEmoji: .whiteSquareButton, skinTones: nil)
-        } else if rawValue == "🔲" {
-            self.init(baseEmoji: .blackSquareButton, skinTones: nil)
-        } else if rawValue == "🏁" {
-            self.init(baseEmoji: .checkeredFlag, skinTones: nil)
-        } else if rawValue == "🚩" {
-            self.init(baseEmoji: .triangularFlagOnPost, skinTones: nil)
-        } else if rawValue == "🎌" {
-            self.init(baseEmoji: .crossedFlags, skinTones: nil)
-        } else if rawValue == "🏴" {
-            self.init(baseEmoji: .wavingBlackFlag, skinTones: nil)
-        } else if rawValue == "🏳️" {
-            self.init(baseEmoji: .wavingWhiteFlag, skinTones: nil)
-        } else if rawValue == "🏳️‍🌈" {
-            self.init(baseEmoji: .rainbowFlag, skinTones: nil)
-        } else if rawValue == "🏳️‍⚧️" {
-            self.init(baseEmoji: .transgenderFlag, skinTones: nil)
-        } else if rawValue == "🏴‍☠️" {
-            self.init(baseEmoji: .pirateFlag, skinTones: nil)
-        } else if rawValue == "🇦🇨" {
-            self.init(baseEmoji: .flagAc, skinTones: nil)
-        } else if rawValue == "🇦🇩" {
-            self.init(baseEmoji: .flagAd, skinTones: nil)
-        } else if rawValue == "🇦🇪" {
-            self.init(baseEmoji: .flagAe, skinTones: nil)
-        } else if rawValue == "🇦🇫" {
-            self.init(baseEmoji: .flagAf, skinTones: nil)
-        } else if rawValue == "🇦🇬" {
-            self.init(baseEmoji: .flagAg, skinTones: nil)
-        } else if rawValue == "🇦🇮" {
-            self.init(baseEmoji: .flagAi, skinTones: nil)
-        } else if rawValue == "🇦🇱" {
-            self.init(baseEmoji: .flagAl, skinTones: nil)
-        } else if rawValue == "🇦🇲" {
-            self.init(baseEmoji: .flagAm, skinTones: nil)
-        } else if rawValue == "🇦🇴" {
-            self.init(baseEmoji: .flagAo, skinTones: nil)
-        } else if rawValue == "🇦🇶" {
-            self.init(baseEmoji: .flagAq, skinTones: nil)
-        } else if rawValue == "🇦🇷" {
-            self.init(baseEmoji: .flagAr, skinTones: nil)
-        } else if rawValue == "🇦🇸" {
-            self.init(baseEmoji: .flagAs, skinTones: nil)
-        } else if rawValue == "🇦🇹" {
-            self.init(baseEmoji: .flagAt, skinTones: nil)
-        } else if rawValue == "🇦🇺" {
-            self.init(baseEmoji: .flagAu, skinTones: nil)
-        } else if rawValue == "🇦🇼" {
-            self.init(baseEmoji: .flagAw, skinTones: nil)
-        } else if rawValue == "🇦🇽" {
-            self.init(baseEmoji: .flagAx, skinTones: nil)
-        } else if rawValue == "🇦🇿" {
-            self.init(baseEmoji: .flagAz, skinTones: nil)
-        } else if rawValue == "🇧🇦" {
-            self.init(baseEmoji: .flagBa, skinTones: nil)
-        } else if rawValue == "🇧🇧" {
-            self.init(baseEmoji: .flagBb, skinTones: nil)
-        } else if rawValue == "🇧🇩" {
-            self.init(baseEmoji: .flagBd, skinTones: nil)
-        } else if rawValue == "🇧🇪" {
-            self.init(baseEmoji: .flagBe, skinTones: nil)
-        } else if rawValue == "🇧🇫" {
-            self.init(baseEmoji: .flagBf, skinTones: nil)
-        } else if rawValue == "🇧🇬" {
-            self.init(baseEmoji: .flagBg, skinTones: nil)
-        } else if rawValue == "🇧🇭" {
-            self.init(baseEmoji: .flagBh, skinTones: nil)
-        } else if rawValue == "🇧🇮" {
-            self.init(baseEmoji: .flagBi, skinTones: nil)
-        } else if rawValue == "🇧🇯" {
-            self.init(baseEmoji: .flagBj, skinTones: nil)
-        } else if rawValue == "🇧🇱" {
-            self.init(baseEmoji: .flagBl, skinTones: nil)
-        } else if rawValue == "🇧🇲" {
-            self.init(baseEmoji: .flagBm, skinTones: nil)
-        } else if rawValue == "🇧🇳" {
-            self.init(baseEmoji: .flagBn, skinTones: nil)
-        } else if rawValue == "🇧🇴" {
-            self.init(baseEmoji: .flagBo, skinTones: nil)
-        } else if rawValue == "🇧🇶" {
-            self.init(baseEmoji: .flagBq, skinTones: nil)
-        } else if rawValue == "🇧🇷" {
-            self.init(baseEmoji: .flagBr, skinTones: nil)
-        } else if rawValue == "🇧🇸" {
-            self.init(baseEmoji: .flagBs, skinTones: nil)
-        } else if rawValue == "🇧🇹" {
-            self.init(baseEmoji: .flagBt, skinTones: nil)
-        } else if rawValue == "🇧🇻" {
-            self.init(baseEmoji: .flagBv, skinTones: nil)
-        } else if rawValue == "🇧🇼" {
-            self.init(baseEmoji: .flagBw, skinTones: nil)
-        } else if rawValue == "🇧🇾" {
-            self.init(baseEmoji: .flagBy, skinTones: nil)
-        } else if rawValue == "🇧🇿" {
-            self.init(baseEmoji: .flagBz, skinTones: nil)
-        } else if rawValue == "🇨🇦" {
-            self.init(baseEmoji: .flagCa, skinTones: nil)
-        } else if rawValue == "🇨🇨" {
-            self.init(baseEmoji: .flagCc, skinTones: nil)
-        } else if rawValue == "🇨🇩" {
-            self.init(baseEmoji: .flagCd, skinTones: nil)
-        } else if rawValue == "🇨🇫" {
-            self.init(baseEmoji: .flagCf, skinTones: nil)
-        } else if rawValue == "🇨🇬" {
-            self.init(baseEmoji: .flagCg, skinTones: nil)
-        } else if rawValue == "🇨🇭" {
-            self.init(baseEmoji: .flagCh, skinTones: nil)
-        } else if rawValue == "🇨🇮" {
-            self.init(baseEmoji: .flagCi, skinTones: nil)
-        } else if rawValue == "🇨🇰" {
-            self.init(baseEmoji: .flagCk, skinTones: nil)
-        } else if rawValue == "🇨🇱" {
-            self.init(baseEmoji: .flagCl, skinTones: nil)
-        } else if rawValue == "🇨🇲" {
-            self.init(baseEmoji: .flagCm, skinTones: nil)
-        } else if rawValue == "🇨🇳" {
-            self.init(baseEmoji: .cn, skinTones: nil)
-        } else if rawValue == "🇨🇴" {
-            self.init(baseEmoji: .flagCo, skinTones: nil)
-        } else if rawValue == "🇨🇵" {
-            self.init(baseEmoji: .flagCp, skinTones: nil)
-        } else if rawValue == "🇨🇷" {
-            self.init(baseEmoji: .flagCr, skinTones: nil)
-        } else if rawValue == "🇨🇺" {
-            self.init(baseEmoji: .flagCu, skinTones: nil)
-        } else if rawValue == "🇨🇻" {
-            self.init(baseEmoji: .flagCv, skinTones: nil)
-        } else if rawValue == "🇨🇼" {
-            self.init(baseEmoji: .flagCw, skinTones: nil)
-        } else if rawValue == "🇨🇽" {
-            self.init(baseEmoji: .flagCx, skinTones: nil)
-        } else if rawValue == "🇨🇾" {
-            self.init(baseEmoji: .flagCy, skinTones: nil)
-        } else if rawValue == "🇨🇿" {
-            self.init(baseEmoji: .flagCz, skinTones: nil)
-        } else if rawValue == "🇩🇪" {
-            self.init(baseEmoji: .de, skinTones: nil)
-        } else if rawValue == "🇩🇬" {
-            self.init(baseEmoji: .flagDg, skinTones: nil)
-        } else if rawValue == "🇩🇯" {
-            self.init(baseEmoji: .flagDj, skinTones: nil)
-        } else if rawValue == "🇩🇰" {
-            self.init(baseEmoji: .flagDk, skinTones: nil)
-        } else if rawValue == "🇩🇲" {
-            self.init(baseEmoji: .flagDm, skinTones: nil)
-        } else if rawValue == "🇩🇴" {
-            self.init(baseEmoji: .flagDo, skinTones: nil)
-        } else if rawValue == "🇩🇿" {
-            self.init(baseEmoji: .flagDz, skinTones: nil)
-        } else if rawValue == "🇪🇦" {
-            self.init(baseEmoji: .flagEa, skinTones: nil)
-        } else if rawValue == "🇪🇨" {
-            self.init(baseEmoji: .flagEc, skinTones: nil)
-        } else if rawValue == "🇪🇪" {
-            self.init(baseEmoji: .flagEe, skinTones: nil)
-        } else if rawValue == "🇪🇬" {
-            self.init(baseEmoji: .flagEg, skinTones: nil)
-        } else if rawValue == "🇪🇭" {
-            self.init(baseEmoji: .flagEh, skinTones: nil)
-        } else if rawValue == "🇪🇷" {
-            self.init(baseEmoji: .flagEr, skinTones: nil)
-        } else if rawValue == "🇪🇸" {
-            self.init(baseEmoji: .es, skinTones: nil)
-        } else if rawValue == "🇪🇹" {
-            self.init(baseEmoji: .flagEt, skinTones: nil)
-        } else if rawValue == "🇪🇺" {
-            self.init(baseEmoji: .flagEu, skinTones: nil)
-        } else if rawValue == "🇫🇮" {
-            self.init(baseEmoji: .flagFi, skinTones: nil)
-        } else if rawValue == "🇫🇯" {
-            self.init(baseEmoji: .flagFj, skinTones: nil)
-        } else if rawValue == "🇫🇰" {
-            self.init(baseEmoji: .flagFk, skinTones: nil)
-        } else if rawValue == "🇫🇲" {
-            self.init(baseEmoji: .flagFm, skinTones: nil)
-        } else if rawValue == "🇫🇴" {
-            self.init(baseEmoji: .flagFo, skinTones: nil)
-        } else if rawValue == "🇫🇷" {
-            self.init(baseEmoji: .fr, skinTones: nil)
-        } else if rawValue == "🇬🇦" {
-            self.init(baseEmoji: .flagGa, skinTones: nil)
-        } else if rawValue == "🇬🇧" {
-            self.init(baseEmoji: .gb, skinTones: nil)
-        } else if rawValue == "🇬🇩" {
-            self.init(baseEmoji: .flagGd, skinTones: nil)
-        } else if rawValue == "🇬🇪" {
-            self.init(baseEmoji: .flagGe, skinTones: nil)
-        } else if rawValue == "🇬🇫" {
-            self.init(baseEmoji: .flagGf, skinTones: nil)
-        } else if rawValue == "🇬🇬" {
-            self.init(baseEmoji: .flagGg, skinTones: nil)
-        } else if rawValue == "🇬🇭" {
-            self.init(baseEmoji: .flagGh, skinTones: nil)
-        } else if rawValue == "🇬🇮" {
-            self.init(baseEmoji: .flagGi, skinTones: nil)
-        } else if rawValue == "🇬🇱" {
-            self.init(baseEmoji: .flagGl, skinTones: nil)
-        } else if rawValue == "🇬🇲" {
-            self.init(baseEmoji: .flagGm, skinTones: nil)
-        } else if rawValue == "🇬🇳" {
-            self.init(baseEmoji: .flagGn, skinTones: nil)
-        } else if rawValue == "🇬🇵" {
-            self.init(baseEmoji: .flagGp, skinTones: nil)
-        } else if rawValue == "🇬🇶" {
-            self.init(baseEmoji: .flagGq, skinTones: nil)
-        } else if rawValue == "🇬🇷" {
-            self.init(baseEmoji: .flagGr, skinTones: nil)
-        } else if rawValue == "🇬🇸" {
-            self.init(baseEmoji: .flagGs, skinTones: nil)
-        } else if rawValue == "🇬🇹" {
-            self.init(baseEmoji: .flagGt, skinTones: nil)
-        } else if rawValue == "🇬🇺" {
-            self.init(baseEmoji: .flagGu, skinTones: nil)
-        } else if rawValue == "🇬🇼" {
-            self.init(baseEmoji: .flagGw, skinTones: nil)
-        } else if rawValue == "🇬🇾" {
-            self.init(baseEmoji: .flagGy, skinTones: nil)
-        } else if rawValue == "🇭🇰" {
-            self.init(baseEmoji: .flagHk, skinTones: nil)
-        } else if rawValue == "🇭🇲" {
-            self.init(baseEmoji: .flagHm, skinTones: nil)
-        } else if rawValue == "🇭🇳" {
-            self.init(baseEmoji: .flagHn, skinTones: nil)
-        } else if rawValue == "🇭🇷" {
-            self.init(baseEmoji: .flagHr, skinTones: nil)
-        } else if rawValue == "🇭🇹" {
-            self.init(baseEmoji: .flagHt, skinTones: nil)
-        } else if rawValue == "🇭🇺" {
-            self.init(baseEmoji: .flagHu, skinTones: nil)
-        } else if rawValue == "🇮🇨" {
-            self.init(baseEmoji: .flagIc, skinTones: nil)
-        } else if rawValue == "🇮🇩" {
-            self.init(baseEmoji: .flagId, skinTones: nil)
-        } else if rawValue == "🇮🇪" {
-            self.init(baseEmoji: .flagIe, skinTones: nil)
-        } else if rawValue == "🇮🇱" {
-            self.init(baseEmoji: .flagIl, skinTones: nil)
-        } else if rawValue == "🇮🇲" {
-            self.init(baseEmoji: .flagIm, skinTones: nil)
-        } else if rawValue == "🇮🇳" {
-            self.init(baseEmoji: .flagIn, skinTones: nil)
-        } else if rawValue == "🇮🇴" {
-            self.init(baseEmoji: .flagIo, skinTones: nil)
-        } else if rawValue == "🇮🇶" {
-            self.init(baseEmoji: .flagIq, skinTones: nil)
-        } else if rawValue == "🇮🇷" {
-            self.init(baseEmoji: .flagIr, skinTones: nil)
-        } else if rawValue == "🇮🇸" {
-            self.init(baseEmoji: .flagIs, skinTones: nil)
-        } else if rawValue == "🇮🇹" {
-            self.init(baseEmoji: .it, skinTones: nil)
-        } else if rawValue == "🇯🇪" {
-            self.init(baseEmoji: .flagJe, skinTones: nil)
-        } else if rawValue == "🇯🇲" {
-            self.init(baseEmoji: .flagJm, skinTones: nil)
-        } else if rawValue == "🇯🇴" {
-            self.init(baseEmoji: .flagJo, skinTones: nil)
-        } else if rawValue == "🇯🇵" {
-            self.init(baseEmoji: .jp, skinTones: nil)
-        } else if rawValue == "🇰🇪" {
-            self.init(baseEmoji: .flagKe, skinTones: nil)
-        } else if rawValue == "🇰🇬" {
-            self.init(baseEmoji: .flagKg, skinTones: nil)
-        } else if rawValue == "🇰🇭" {
-            self.init(baseEmoji: .flagKh, skinTones: nil)
-        } else if rawValue == "🇰🇮" {
-            self.init(baseEmoji: .flagKi, skinTones: nil)
-        } else if rawValue == "🇰🇲" {
-            self.init(baseEmoji: .flagKm, skinTones: nil)
-        } else if rawValue == "🇰🇳" {
-            self.init(baseEmoji: .flagKn, skinTones: nil)
-        } else if rawValue == "🇰🇵" {
-            self.init(baseEmoji: .flagKp, skinTones: nil)
-        } else if rawValue == "🇰🇷" {
-            self.init(baseEmoji: .kr, skinTones: nil)
-        } else if rawValue == "🇰🇼" {
-            self.init(baseEmoji: .flagKw, skinTones: nil)
-        } else if rawValue == "🇰🇾" {
-            self.init(baseEmoji: .flagKy, skinTones: nil)
-        } else if rawValue == "🇰🇿" {
-            self.init(baseEmoji: .flagKz, skinTones: nil)
-        } else if rawValue == "🇱🇦" {
-            self.init(baseEmoji: .flagLa, skinTones: nil)
-        } else if rawValue == "🇱🇧" {
-            self.init(baseEmoji: .flagLb, skinTones: nil)
-        } else if rawValue == "🇱🇨" {
-            self.init(baseEmoji: .flagLc, skinTones: nil)
-        } else if rawValue == "🇱🇮" {
-            self.init(baseEmoji: .flagLi, skinTones: nil)
-        } else if rawValue == "🇱🇰" {
-            self.init(baseEmoji: .flagLk, skinTones: nil)
-        } else if rawValue == "🇱🇷" {
-            self.init(baseEmoji: .flagLr, skinTones: nil)
-        } else if rawValue == "🇱🇸" {
-            self.init(baseEmoji: .flagLs, skinTones: nil)
-        } else if rawValue == "🇱🇹" {
-            self.init(baseEmoji: .flagLt, skinTones: nil)
-        } else if rawValue == "🇱🇺" {
-            self.init(baseEmoji: .flagLu, skinTones: nil)
-        } else if rawValue == "🇱🇻" {
-            self.init(baseEmoji: .flagLv, skinTones: nil)
-        } else if rawValue == "🇱🇾" {
-            self.init(baseEmoji: .flagLy, skinTones: nil)
-        } else if rawValue == "🇲🇦" {
-            self.init(baseEmoji: .flagMa, skinTones: nil)
-        } else if rawValue == "🇲🇨" {
-            self.init(baseEmoji: .flagMc, skinTones: nil)
-        } else if rawValue == "🇲🇩" {
-            self.init(baseEmoji: .flagMd, skinTones: nil)
-        } else if rawValue == "🇲🇪" {
-            self.init(baseEmoji: .flagMe, skinTones: nil)
-        } else if rawValue == "🇲🇫" {
-            self.init(baseEmoji: .flagMf, skinTones: nil)
-        } else if rawValue == "🇲🇬" {
-            self.init(baseEmoji: .flagMg, skinTones: nil)
-        } else if rawValue == "🇲🇭" {
-            self.init(baseEmoji: .flagMh, skinTones: nil)
-        } else if rawValue == "🇲🇰" {
-            self.init(baseEmoji: .flagMk, skinTones: nil)
-        } else if rawValue == "🇲🇱" {
-            self.init(baseEmoji: .flagMl, skinTones: nil)
-        } else if rawValue == "🇲🇲" {
-            self.init(baseEmoji: .flagMm, skinTones: nil)
-        } else if rawValue == "🇲🇳" {
-            self.init(baseEmoji: .flagMn, skinTones: nil)
-        } else if rawValue == "🇲🇴" {
-            self.init(baseEmoji: .flagMo, skinTones: nil)
-        } else if rawValue == "🇲🇵" {
-            self.init(baseEmoji: .flagMp, skinTones: nil)
-        } else if rawValue == "🇲🇶" {
-            self.init(baseEmoji: .flagMq, skinTones: nil)
-        } else if rawValue == "🇲🇷" {
-            self.init(baseEmoji: .flagMr, skinTones: nil)
-        } else if rawValue == "🇲🇸" {
-            self.init(baseEmoji: .flagMs, skinTones: nil)
-        } else if rawValue == "🇲🇹" {
-            self.init(baseEmoji: .flagMt, skinTones: nil)
-        } else if rawValue == "🇲🇺" {
-            self.init(baseEmoji: .flagMu, skinTones: nil)
-        } else if rawValue == "🇲🇻" {
-            self.init(baseEmoji: .flagMv, skinTones: nil)
-        } else if rawValue == "🇲🇼" {
-            self.init(baseEmoji: .flagMw, skinTones: nil)
-        } else if rawValue == "🇲🇽" {
-            self.init(baseEmoji: .flagMx, skinTones: nil)
-        } else if rawValue == "🇲🇾" {
-            self.init(baseEmoji: .flagMy, skinTones: nil)
-        } else if rawValue == "🇲🇿" {
-            self.init(baseEmoji: .flagMz, skinTones: nil)
-        } else if rawValue == "🇳🇦" {
-            self.init(baseEmoji: .flagNa, skinTones: nil)
-        } else if rawValue == "🇳🇨" {
-            self.init(baseEmoji: .flagNc, skinTones: nil)
-        } else if rawValue == "🇳🇪" {
-            self.init(baseEmoji: .flagNe, skinTones: nil)
-        } else if rawValue == "🇳🇫" {
-            self.init(baseEmoji: .flagNf, skinTones: nil)
-        } else if rawValue == "🇳🇬" {
-            self.init(baseEmoji: .flagNg, skinTones: nil)
-        } else if rawValue == "🇳🇮" {
-            self.init(baseEmoji: .flagNi, skinTones: nil)
-        } else if rawValue == "🇳🇱" {
-            self.init(baseEmoji: .flagNl, skinTones: nil)
-        } else if rawValue == "🇳🇴" {
-            self.init(baseEmoji: .flagNo, skinTones: nil)
-        } else if rawValue == "🇳🇵" {
-            self.init(baseEmoji: .flagNp, skinTones: nil)
-        } else if rawValue == "🇳🇷" {
-            self.init(baseEmoji: .flagNr, skinTones: nil)
-        } else if rawValue == "🇳🇺" {
-            self.init(baseEmoji: .flagNu, skinTones: nil)
-        } else if rawValue == "🇳🇿" {
-            self.init(baseEmoji: .flagNz, skinTones: nil)
-        } else if rawValue == "🇴🇲" {
-            self.init(baseEmoji: .flagOm, skinTones: nil)
-        } else if rawValue == "🇵🇦" {
-            self.init(baseEmoji: .flagPa, skinTones: nil)
-        } else if rawValue == "🇵🇪" {
-            self.init(baseEmoji: .flagPe, skinTones: nil)
-        } else if rawValue == "🇵🇫" {
-            self.init(baseEmoji: .flagPf, skinTones: nil)
-        } else if rawValue == "🇵🇬" {
-            self.init(baseEmoji: .flagPg, skinTones: nil)
-        } else if rawValue == "🇵🇭" {
-            self.init(baseEmoji: .flagPh, skinTones: nil)
-        } else if rawValue == "🇵🇰" {
-            self.init(baseEmoji: .flagPk, skinTones: nil)
-        } else if rawValue == "🇵🇱" {
-            self.init(baseEmoji: .flagPl, skinTones: nil)
-        } else if rawValue == "🇵🇲" {
-            self.init(baseEmoji: .flagPm, skinTones: nil)
-        } else if rawValue == "🇵🇳" {
-            self.init(baseEmoji: .flagPn, skinTones: nil)
-        } else if rawValue == "🇵🇷" {
-            self.init(baseEmoji: .flagPr, skinTones: nil)
-        } else if rawValue == "🇵🇸" {
-            self.init(baseEmoji: .flagPs, skinTones: nil)
-        } else if rawValue == "🇵🇹" {
-            self.init(baseEmoji: .flagPt, skinTones: nil)
-        } else if rawValue == "🇵🇼" {
-            self.init(baseEmoji: .flagPw, skinTones: nil)
-        } else if rawValue == "🇵🇾" {
-            self.init(baseEmoji: .flagPy, skinTones: nil)
-        } else if rawValue == "🇶🇦" {
-            self.init(baseEmoji: .flagQa, skinTones: nil)
-        } else if rawValue == "🇷🇪" {
-            self.init(baseEmoji: .flagRe, skinTones: nil)
-        } else if rawValue == "🇷🇴" {
-            self.init(baseEmoji: .flagRo, skinTones: nil)
-        } else if rawValue == "🇷🇸" {
-            self.init(baseEmoji: .flagRs, skinTones: nil)
-        } else if rawValue == "🇷🇺" {
-            self.init(baseEmoji: .ru, skinTones: nil)
-        } else if rawValue == "🇷🇼" {
-            self.init(baseEmoji: .flagRw, skinTones: nil)
-        } else if rawValue == "🇸🇦" {
-            self.init(baseEmoji: .flagSa, skinTones: nil)
-        } else if rawValue == "🇸🇧" {
-            self.init(baseEmoji: .flagSb, skinTones: nil)
-        } else if rawValue == "🇸🇨" {
-            self.init(baseEmoji: .flagSc, skinTones: nil)
-        } else if rawValue == "🇸🇩" {
-            self.init(baseEmoji: .flagSd, skinTones: nil)
-        } else if rawValue == "🇸🇪" {
-            self.init(baseEmoji: .flagSe, skinTones: nil)
-        } else if rawValue == "🇸🇬" {
-            self.init(baseEmoji: .flagSg, skinTones: nil)
-        } else if rawValue == "🇸🇭" {
-            self.init(baseEmoji: .flagSh, skinTones: nil)
-        } else if rawValue == "🇸🇮" {
-            self.init(baseEmoji: .flagSi, skinTones: nil)
-        } else if rawValue == "🇸🇯" {
-            self.init(baseEmoji: .flagSj, skinTones: nil)
-        } else if rawValue == "🇸🇰" {
-            self.init(baseEmoji: .flagSk, skinTones: nil)
-        } else if rawValue == "🇸🇱" {
-            self.init(baseEmoji: .flagSl, skinTones: nil)
-        } else if rawValue == "🇸🇲" {
-            self.init(baseEmoji: .flagSm, skinTones: nil)
-        } else if rawValue == "🇸🇳" {
-            self.init(baseEmoji: .flagSn, skinTones: nil)
-        } else if rawValue == "🇸🇴" {
-            self.init(baseEmoji: .flagSo, skinTones: nil)
-        } else if rawValue == "🇸🇷" {
-            self.init(baseEmoji: .flagSr, skinTones: nil)
-        } else if rawValue == "🇸🇸" {
-            self.init(baseEmoji: .flagSs, skinTones: nil)
-        } else if rawValue == "🇸🇹" {
-            self.init(baseEmoji: .flagSt, skinTones: nil)
-        } else if rawValue == "🇸🇻" {
-            self.init(baseEmoji: .flagSv, skinTones: nil)
-        } else if rawValue == "🇸🇽" {
-            self.init(baseEmoji: .flagSx, skinTones: nil)
-        } else if rawValue == "🇸🇾" {
-            self.init(baseEmoji: .flagSy, skinTones: nil)
-        } else if rawValue == "🇸🇿" {
-            self.init(baseEmoji: .flagSz, skinTones: nil)
-        } else if rawValue == "🇹🇦" {
-            self.init(baseEmoji: .flagTa, skinTones: nil)
-        } else if rawValue == "🇹🇨" {
-            self.init(baseEmoji: .flagTc, skinTones: nil)
-        } else if rawValue == "🇹🇩" {
-            self.init(baseEmoji: .flagTd, skinTones: nil)
-        } else if rawValue == "🇹🇫" {
-            self.init(baseEmoji: .flagTf, skinTones: nil)
-        } else if rawValue == "🇹🇬" {
-            self.init(baseEmoji: .flagTg, skinTones: nil)
-        } else if rawValue == "🇹🇭" {
-            self.init(baseEmoji: .flagTh, skinTones: nil)
-        } else if rawValue == "🇹🇯" {
-            self.init(baseEmoji: .flagTj, skinTones: nil)
-        } else if rawValue == "🇹🇰" {
-            self.init(baseEmoji: .flagTk, skinTones: nil)
-        } else if rawValue == "🇹🇱" {
-            self.init(baseEmoji: .flagTl, skinTones: nil)
-        } else if rawValue == "🇹🇲" {
-            self.init(baseEmoji: .flagTm, skinTones: nil)
-        } else if rawValue == "🇹🇳" {
-            self.init(baseEmoji: .flagTn, skinTones: nil)
-        } else if rawValue == "🇹🇴" {
-            self.init(baseEmoji: .flagTo, skinTones: nil)
-        } else if rawValue == "🇹🇷" {
-            self.init(baseEmoji: .flagTr, skinTones: nil)
-        } else if rawValue == "🇹🇹" {
-            self.init(baseEmoji: .flagTt, skinTones: nil)
-        } else if rawValue == "🇹🇻" {
-            self.init(baseEmoji: .flagTv, skinTones: nil)
-        } else if rawValue == "🇹🇼" {
-            self.init(baseEmoji: .flagTw, skinTones: nil)
-        } else if rawValue == "🇹🇿" {
-            self.init(baseEmoji: .flagTz, skinTones: nil)
-        } else if rawValue == "🇺🇦" {
-            self.init(baseEmoji: .flagUa, skinTones: nil)
-        } else if rawValue == "🇺🇬" {
-            self.init(baseEmoji: .flagUg, skinTones: nil)
-        } else if rawValue == "🇺🇲" {
-            self.init(baseEmoji: .flagUm, skinTones: nil)
-        } else if rawValue == "🇺🇳" {
-            self.init(baseEmoji: .flagUn, skinTones: nil)
-        } else if rawValue == "🇺🇸" {
-            self.init(baseEmoji: .us, skinTones: nil)
-        } else if rawValue == "🇺🇾" {
-            self.init(baseEmoji: .flagUy, skinTones: nil)
-        } else if rawValue == "🇺🇿" {
-            self.init(baseEmoji: .flagUz, skinTones: nil)
-        } else if rawValue == "🇻🇦" {
-            self.init(baseEmoji: .flagVa, skinTones: nil)
-        } else if rawValue == "🇻🇨" {
-            self.init(baseEmoji: .flagVc, skinTones: nil)
-        } else if rawValue == "🇻🇪" {
-            self.init(baseEmoji: .flagVe, skinTones: nil)
-        } else if rawValue == "🇻🇬" {
-            self.init(baseEmoji: .flagVg, skinTones: nil)
-        } else if rawValue == "🇻🇮" {
-            self.init(baseEmoji: .flagVi, skinTones: nil)
-        } else if rawValue == "🇻🇳" {
-            self.init(baseEmoji: .flagVn, skinTones: nil)
-        } else if rawValue == "🇻🇺" {
-            self.init(baseEmoji: .flagVu, skinTones: nil)
-        } else if rawValue == "🇼🇫" {
-            self.init(baseEmoji: .flagWf, skinTones: nil)
-        } else if rawValue == "🇼🇸" {
-            self.init(baseEmoji: .flagWs, skinTones: nil)
-        } else if rawValue == "🇽🇰" {
-            self.init(baseEmoji: .flagXk, skinTones: nil)
-        } else if rawValue == "🇾🇪" {
-            self.init(baseEmoji: .flagYe, skinTones: nil)
-        } else if rawValue == "🇾🇹" {
-            self.init(baseEmoji: .flagYt, skinTones: nil)
-        } else if rawValue == "🇿🇦" {
-            self.init(baseEmoji: .flagZa, skinTones: nil)
-        } else if rawValue == "🇿🇲" {
-            self.init(baseEmoji: .flagZm, skinTones: nil)
-        } else if rawValue == "🇿🇼" {
-            self.init(baseEmoji: .flagZw, skinTones: nil)
-        } else if rawValue == "🏴󠁧󠁢󠁥󠁮󠁧󠁿" {
-            self.init(baseEmoji: .flagEngland, skinTones: nil)
-        } else if rawValue == "🏴󠁧󠁢󠁳󠁣󠁴󠁿" {
-            self.init(baseEmoji: .flagScotland, skinTones: nil)
-        } else if rawValue == "🏴󠁧󠁢󠁷󠁬󠁳󠁿" {
-            self.init(baseEmoji: .flagWales, skinTones: nil)
-        } else {
-            self.init(unsupportedValue: rawValue)
+        switch rawValue.unicodeScalars.map({ $0.value }).reduce(0, +) {
+            case 89: self = EmojiWithSkinTones.emojiFrom89(rawValue)
+            case 91: self = EmojiWithSkinTones.emojiFrom91(rawValue)
+            case 92: self = EmojiWithSkinTones.emojiFrom92(rawValue)
+            case 97: self = EmojiWithSkinTones.emojiFrom97(rawValue)
+            case 98: self = EmojiWithSkinTones.emojiFrom98(rawValue)
+            case 99: self = EmojiWithSkinTones.emojiFrom99(rawValue)
+            case 100: self = EmojiWithSkinTones.emojiFrom100(rawValue)
+            case 101: self = EmojiWithSkinTones.emojiFrom101(rawValue)
+            case 110: self = EmojiWithSkinTones.emojiFrom110(rawValue)
+            case 652: self = EmojiWithSkinTones.emojiFrom652(rawValue)
+            case 732: self = EmojiWithSkinTones.emojiFrom732(rawValue)
+            case 733: self = EmojiWithSkinTones.emojiFrom733(rawValue)
+            case 734: self = EmojiWithSkinTones.emojiFrom734(rawValue)
+            case 735: self = EmojiWithSkinTones.emojiFrom735(rawValue)
+            case 736: self = EmojiWithSkinTones.emojiFrom736(rawValue)
+            case 740: self = EmojiWithSkinTones.emojiFrom740(rawValue)
+            case 742: self = EmojiWithSkinTones.emojiFrom742(rawValue)
+            case 744: self = EmojiWithSkinTones.emojiFrom744(rawValue)
+            case 746: self = EmojiWithSkinTones.emojiFrom746(rawValue)
+            case 747: self = EmojiWithSkinTones.emojiFrom747(rawValue)
+            case 748: self = EmojiWithSkinTones.emojiFrom748(rawValue)
+            case 749: self = EmojiWithSkinTones.emojiFrom749(rawValue)
+            case 750: self = EmojiWithSkinTones.emojiFrom750(rawValue)
+            case 751: self = EmojiWithSkinTones.emojiFrom751(rawValue)
+            case 755: self = EmojiWithSkinTones.emojiFrom755(rawValue)
+            case 760: self = EmojiWithSkinTones.emojiFrom760(rawValue)
+            case 773: self = EmojiWithSkinTones.emojiFrom773(rawValue)
+            case 779: self = EmojiWithSkinTones.emojiFrom779(rawValue)
+            case 1269: self = EmojiWithSkinTones.emojiFrom1269(rawValue)
+            case 1271: self = EmojiWithSkinTones.emojiFrom1271(rawValue)
+            case 1273: self = EmojiWithSkinTones.emojiFrom1273(rawValue)
+            case 1274: self = EmojiWithSkinTones.emojiFrom1274(rawValue)
+            case 1275: self = EmojiWithSkinTones.emojiFrom1275(rawValue)
+            case 1277: self = EmojiWithSkinTones.emojiFrom1277(rawValue)
+            case 1278: self = EmojiWithSkinTones.emojiFrom1278(rawValue)
+            case 1279: self = EmojiWithSkinTones.emojiFrom1279(rawValue)
+            case 1280: self = EmojiWithSkinTones.emojiFrom1280(rawValue)
+            case 1281: self = EmojiWithSkinTones.emojiFrom1281(rawValue)
+            case 1282: self = EmojiWithSkinTones.emojiFrom1282(rawValue)
+            case 1283: self = EmojiWithSkinTones.emojiFrom1283(rawValue)
+            case 1284: self = EmojiWithSkinTones.emojiFrom1284(rawValue)
+            case 1285: self = EmojiWithSkinTones.emojiFrom1285(rawValue)
+            case 1286: self = EmojiWithSkinTones.emojiFrom1286(rawValue)
+            case 1287: self = EmojiWithSkinTones.emojiFrom1287(rawValue)
+            case 1289: self = EmojiWithSkinTones.emojiFrom1289(rawValue)
+            case 1290: self = EmojiWithSkinTones.emojiFrom1290(rawValue)
+            case 1292: self = EmojiWithSkinTones.emojiFrom1292(rawValue)
+            case 1293: self = EmojiWithSkinTones.emojiFrom1293(rawValue)
+            case 1294: self = EmojiWithSkinTones.emojiFrom1294(rawValue)
+            case 1295: self = EmojiWithSkinTones.emojiFrom1295(rawValue)
+            case 1296: self = EmojiWithSkinTones.emojiFrom1296(rawValue)
+            case 1297: self = EmojiWithSkinTones.emojiFrom1297(rawValue)
+            case 1377: self = EmojiWithSkinTones.emojiFrom1377(rawValue)
+            case 1379: self = EmojiWithSkinTones.emojiFrom1379(rawValue)
+            case 1472: self = EmojiWithSkinTones.emojiFrom1472(rawValue)
+            case 1580: self = EmojiWithSkinTones.emojiFrom1580(rawValue)
+            case 1923: self = EmojiWithSkinTones.emojiFrom1923(rawValue)
+            case 1925: self = EmojiWithSkinTones.emojiFrom1925(rawValue)
+            case 1928: self = EmojiWithSkinTones.emojiFrom1928(rawValue)
+            case 1929: self = EmojiWithSkinTones.emojiFrom1929(rawValue)
+            case 1930: self = EmojiWithSkinTones.emojiFrom1930(rawValue)
+            case 1931: self = EmojiWithSkinTones.emojiFrom1931(rawValue)
+            case 1932: self = EmojiWithSkinTones.emojiFrom1932(rawValue)
+            case 1933: self = EmojiWithSkinTones.emojiFrom1933(rawValue)
+            case 1934: self = EmojiWithSkinTones.emojiFrom1934(rawValue)
+            case 1935: self = EmojiWithSkinTones.emojiFrom1935(rawValue)
+            case 1937: self = EmojiWithSkinTones.emojiFrom1937(rawValue)
+            case 2109: self = EmojiWithSkinTones.emojiFrom2109(rawValue)
+            case 2111: self = EmojiWithSkinTones.emojiFrom2111(rawValue)
+            case 2112: self = EmojiWithSkinTones.emojiFrom2112(rawValue)
+            case 2113: self = EmojiWithSkinTones.emojiFrom2113(rawValue)
+            case 2116: self = EmojiWithSkinTones.emojiFrom2116(rawValue)
+            case 2117: self = EmojiWithSkinTones.emojiFrom2117(rawValue)
+            case 2123: self = EmojiWithSkinTones.emojiFrom2123(rawValue)
+            case 2125: self = EmojiWithSkinTones.emojiFrom2125(rawValue)
+            case 2126: self = EmojiWithSkinTones.emojiFrom2126(rawValue)
+            case 2127: self = EmojiWithSkinTones.emojiFrom2127(rawValue)
+            case 2129: self = EmojiWithSkinTones.emojiFrom2129(rawValue)
+            case 2210: self = EmojiWithSkinTones.emojiFrom2210(rawValue)
+            case 2549: self = EmojiWithSkinTones.emojiFrom2549(rawValue)
+            case 2558: self = EmojiWithSkinTones.emojiFrom2558(rawValue)
+            case 2559: self = EmojiWithSkinTones.emojiFrom2559(rawValue)
+            case 2560: self = EmojiWithSkinTones.emojiFrom2560(rawValue)
+            case 2561: self = EmojiWithSkinTones.emojiFrom2561(rawValue)
+            case 2563: self = EmojiWithSkinTones.emojiFrom2563(rawValue)
+            case 2564: self = EmojiWithSkinTones.emojiFrom2564(rawValue)
+            case 2565: self = EmojiWithSkinTones.emojiFrom2565(rawValue)
+            case 2566: self = EmojiWithSkinTones.emojiFrom2566(rawValue)
+            case 2567: self = EmojiWithSkinTones.emojiFrom2567(rawValue)
+            case 2572: self = EmojiWithSkinTones.emojiFrom2572(rawValue)
+            case 2573: self = EmojiWithSkinTones.emojiFrom2573(rawValue)
+            case 2574: self = EmojiWithSkinTones.emojiFrom2574(rawValue)
+            case 2575: self = EmojiWithSkinTones.emojiFrom2575(rawValue)
+            case 2577: self = EmojiWithSkinTones.emojiFrom2577(rawValue)
+            case 2641: self = EmojiWithSkinTones.emojiFrom2641(rawValue)
+            case 2642: self = EmojiWithSkinTones.emojiFrom2642(rawValue)
+            case 2644: self = EmojiWithSkinTones.emojiFrom2644(rawValue)
+            case 2646: self = EmojiWithSkinTones.emojiFrom2646(rawValue)
+            case 2649: self = EmojiWithSkinTones.emojiFrom2649(rawValue)
+            case 2655: self = EmojiWithSkinTones.emojiFrom2655(rawValue)
+            case 2656: self = EmojiWithSkinTones.emojiFrom2656(rawValue)
+            case 2657: self = EmojiWithSkinTones.emojiFrom2657(rawValue)
+            case 2658: self = EmojiWithSkinTones.emojiFrom2658(rawValue)
+            case 2659: self = EmojiWithSkinTones.emojiFrom2659(rawValue)
+            case 2663: self = EmojiWithSkinTones.emojiFrom2663(rawValue)
+            case 2671: self = EmojiWithSkinTones.emojiFrom2671(rawValue)
+            case 2760: self = EmojiWithSkinTones.emojiFrom2760(rawValue)
+            case 2761: self = EmojiWithSkinTones.emojiFrom2761(rawValue)
+            case 2764: self = EmojiWithSkinTones.emojiFrom2764(rawValue)
+            case 3289: self = EmojiWithSkinTones.emojiFrom3289(rawValue)
+            case 3295: self = EmojiWithSkinTones.emojiFrom3295(rawValue)
+            case 3389: self = EmojiWithSkinTones.emojiFrom3389(rawValue)
+            case 3391: self = EmojiWithSkinTones.emojiFrom3391(rawValue)
+            case 3392: self = EmojiWithSkinTones.emojiFrom3392(rawValue)
+            case 3393: self = EmojiWithSkinTones.emojiFrom3393(rawValue)
+            case 3394: self = EmojiWithSkinTones.emojiFrom3394(rawValue)
+            case 3396: self = EmojiWithSkinTones.emojiFrom3396(rawValue)
+            case 3397: self = EmojiWithSkinTones.emojiFrom3397(rawValue)
+            case 3403: self = EmojiWithSkinTones.emojiFrom3403(rawValue)
+            case 3404: self = EmojiWithSkinTones.emojiFrom3404(rawValue)
+            case 3405: self = EmojiWithSkinTones.emojiFrom3405(rawValue)
+            case 3406: self = EmojiWithSkinTones.emojiFrom3406(rawValue)
+            case 3407: self = EmojiWithSkinTones.emojiFrom3407(rawValue)
+            case 3477: self = EmojiWithSkinTones.emojiFrom3477(rawValue)
+            case 3921: self = EmojiWithSkinTones.emojiFrom3921(rawValue)
+            case 3922: self = EmojiWithSkinTones.emojiFrom3922(rawValue)
+            case 3924: self = EmojiWithSkinTones.emojiFrom3924(rawValue)
+            case 3925: self = EmojiWithSkinTones.emojiFrom3925(rawValue)
+            case 3926: self = EmojiWithSkinTones.emojiFrom3926(rawValue)
+            case 3929: self = EmojiWithSkinTones.emojiFrom3929(rawValue)
+            case 3934: self = EmojiWithSkinTones.emojiFrom3934(rawValue)
+            case 3935: self = EmojiWithSkinTones.emojiFrom3935(rawValue)
+            case 3936: self = EmojiWithSkinTones.emojiFrom3936(rawValue)
+            case 3937: self = EmojiWithSkinTones.emojiFrom3937(rawValue)
+            case 3938: self = EmojiWithSkinTones.emojiFrom3938(rawValue)
+            case 3939: self = EmojiWithSkinTones.emojiFrom3939(rawValue)
+            case 3943: self = EmojiWithSkinTones.emojiFrom3943(rawValue)
+            case 3948: self = EmojiWithSkinTones.emojiFrom3948(rawValue)
+            case 3951: self = EmojiWithSkinTones.emojiFrom3951(rawValue)
+            case 4007: self = EmojiWithSkinTones.emojiFrom4007(rawValue)
+            case 4046: self = EmojiWithSkinTones.emojiFrom4046(rawValue)
+            case 4840: self = EmojiWithSkinTones.emojiFrom4840(rawValue)
+            case 5237: self = EmojiWithSkinTones.emojiFrom5237(rawValue)
+            case 5370: self = EmojiWithSkinTones.emojiFrom5370(rawValue)
+            case 6037: self = EmojiWithSkinTones.emojiFrom6037(rawValue)
+            case 6065: self = EmojiWithSkinTones.emojiFrom6065(rawValue)
+            case 6579: self = EmojiWithSkinTones.emojiFrom6579(rawValue)
+            case 6606: self = EmojiWithSkinTones.emojiFrom6606(rawValue)
+            case 7400: self = EmojiWithSkinTones.emojiFrom7400(rawValue)
+            case 7428: self = EmojiWithSkinTones.emojiFrom7428(rawValue)
+            case 56336: self = EmojiWithSkinTones.emojiFrom56336(rawValue)
+            default: self = EmojiWithSkinTones(unsupportedValue: rawValue)
         }
     }
+    
+    private static func emojiFrom89(_ rawValue: String) -> EmojiWithSkinTones {
+        let lookup: [String: EmojiWithSkinTones] = [
+            "⌛": EmojiWithSkinTones(baseEmoji: .hourglass, skinTones: nil),
+            "⌚": EmojiWithSkinTones(baseEmoji: .watch, skinTones: nil)
+        ]
+        return (lookup[rawValue] ?? EmojiWithSkinTones(unsupportedValue: rawValue))
+    }
+    
+    private static func emojiFrom91(_ rawValue: String) -> EmojiWithSkinTones {
+        let lookup: [String: EmojiWithSkinTones] = [
+            "⏩": EmojiWithSkinTones(baseEmoji: .fastForward, skinTones: nil),
+            "⏪": EmojiWithSkinTones(baseEmoji: .rewind, skinTones: nil),
+            "⏫": EmojiWithSkinTones(baseEmoji: .arrowDoubleUp, skinTones: nil),
+            "⏬": EmojiWithSkinTones(baseEmoji: .arrowDoubleDown, skinTones: nil)
+        ]
+        return (lookup[rawValue] ?? EmojiWithSkinTones(unsupportedValue: rawValue))
+    }
+    
+    private static func emojiFrom92(_ rawValue: String) -> EmojiWithSkinTones {
+        let lookup: [String: EmojiWithSkinTones] = [
+            "⏳": EmojiWithSkinTones(baseEmoji: .hourglassFlowingSand, skinTones: nil),
+            "⏰": EmojiWithSkinTones(baseEmoji: .alarmClock, skinTones: nil)
+        ]
+        return (lookup[rawValue] ?? EmojiWithSkinTones(unsupportedValue: rawValue))
+    }
+    
+    private static func emojiFrom97(_ rawValue: String) -> EmojiWithSkinTones {
+        let lookup: [String: EmojiWithSkinTones] = [
+            "☕": EmojiWithSkinTones(baseEmoji: .coffee, skinTones: nil),
+            "☔": EmojiWithSkinTones(baseEmoji: .umbrellaWithRainDrops, skinTones: nil),
+            "◾": EmojiWithSkinTones(baseEmoji: .blackMediumSmallSquare, skinTones: nil),
+            "◽": EmojiWithSkinTones(baseEmoji: .whiteMediumSmallSquare, skinTones: nil)
+        ]
+        return (lookup[rawValue] ?? EmojiWithSkinTones(unsupportedValue: rawValue))
+    }
+    
+    private static func emojiFrom98(_ rawValue: String) -> EmojiWithSkinTones {
+        let lookup: [String: EmojiWithSkinTones] = [
+            "⚓": EmojiWithSkinTones(baseEmoji: .anchor, skinTones: nil),
+            "⚡": EmojiWithSkinTones(baseEmoji: .zap, skinTones: nil),
+            "♿": EmojiWithSkinTones(baseEmoji: .wheelchair, skinTones: nil),
+            "♈": EmojiWithSkinTones(baseEmoji: .aries, skinTones: nil),
+            "♉": EmojiWithSkinTones(baseEmoji: .taurus, skinTones: nil),
+            "♊": EmojiWithSkinTones(baseEmoji: .gemini, skinTones: nil),
+            "♋": EmojiWithSkinTones(baseEmoji: .cancer, skinTones: nil),
+            "♌": EmojiWithSkinTones(baseEmoji: .leo, skinTones: nil),
+            "♍": EmojiWithSkinTones(baseEmoji: .virgo, skinTones: nil),
+            "♎": EmojiWithSkinTones(baseEmoji: .libra, skinTones: nil),
+            "♏": EmojiWithSkinTones(baseEmoji: .scorpius, skinTones: nil),
+            "♐": EmojiWithSkinTones(baseEmoji: .sagittarius, skinTones: nil),
+            "♑": EmojiWithSkinTones(baseEmoji: .capricorn, skinTones: nil),
+            "♒": EmojiWithSkinTones(baseEmoji: .aquarius, skinTones: nil),
+            "♓": EmojiWithSkinTones(baseEmoji: .pisces, skinTones: nil),
+            "⚫": EmojiWithSkinTones(baseEmoji: .blackCircle, skinTones: nil),
+            "⚪": EmojiWithSkinTones(baseEmoji: .whiteCircle, skinTones: nil)
+        ]
+        return (lookup[rawValue] ?? EmojiWithSkinTones(unsupportedValue: rawValue))
+    }
+    
+    private static func emojiFrom99(_ rawValue: String) -> EmojiWithSkinTones {
+        let lookup: [String: EmojiWithSkinTones] = [
+            "✋": EmojiWithSkinTones(baseEmoji: .hand, skinTones: nil),
+            "✊": EmojiWithSkinTones(baseEmoji: .fist, skinTones: nil),
+            "⛪": EmojiWithSkinTones(baseEmoji: .church, skinTones: nil),
+            "⛲": EmojiWithSkinTones(baseEmoji: .fountain, skinTones: nil),
+            "⛺": EmojiWithSkinTones(baseEmoji: .tent, skinTones: nil),
+            "⛽": EmojiWithSkinTones(baseEmoji: .fuelpump, skinTones: nil),
+            "⛵": EmojiWithSkinTones(baseEmoji: .boat, skinTones: nil),
+            "⛅": EmojiWithSkinTones(baseEmoji: .partlySunny, skinTones: nil),
+            "⛄": EmojiWithSkinTones(baseEmoji: .snowmanWithoutSnow, skinTones: nil),
+            "⚽": EmojiWithSkinTones(baseEmoji: .soccer, skinTones: nil),
+            "⚾": EmojiWithSkinTones(baseEmoji: .baseball, skinTones: nil),
+            "⛳": EmojiWithSkinTones(baseEmoji: .golf, skinTones: nil),
+            "⛔": EmojiWithSkinTones(baseEmoji: .noEntry, skinTones: nil),
+            "⛎": EmojiWithSkinTones(baseEmoji: .ophiuchus, skinTones: nil),
+            "✅": EmojiWithSkinTones(baseEmoji: .whiteCheckMark, skinTones: nil)
+        ]
+        return (lookup[rawValue] ?? EmojiWithSkinTones(unsupportedValue: rawValue))
+    }
+    
+    private static func emojiFrom100(_ rawValue: String) -> EmojiWithSkinTones {
+        let lookup: [String: EmojiWithSkinTones] = [
+            "✨": EmojiWithSkinTones(baseEmoji: .sparkles, skinTones: nil),
+            "❓": EmojiWithSkinTones(baseEmoji: .question, skinTones: nil),
+            "❔": EmojiWithSkinTones(baseEmoji: .greyQuestion, skinTones: nil),
+            "❕": EmojiWithSkinTones(baseEmoji: .greyExclamation, skinTones: nil),
+            "❗": EmojiWithSkinTones(baseEmoji: .exclamation, skinTones: nil),
+            "❌": EmojiWithSkinTones(baseEmoji: .x, skinTones: nil),
+            "❎": EmojiWithSkinTones(baseEmoji: .negativeSquaredCrossMark, skinTones: nil)
+        ]
+        return (lookup[rawValue] ?? EmojiWithSkinTones(unsupportedValue: rawValue))
+    }
+    
+    private static func emojiFrom101(_ rawValue: String) -> EmojiWithSkinTones {
+        let lookup: [String: EmojiWithSkinTones] = [
+            "➕": EmojiWithSkinTones(baseEmoji: .heavyPlusSign, skinTones: nil),
+            "➖": EmojiWithSkinTones(baseEmoji: .heavyMinusSign, skinTones: nil),
+            "➗": EmojiWithSkinTones(baseEmoji: .heavyDivisionSign, skinTones: nil),
+            "➰": EmojiWithSkinTones(baseEmoji: .curlyLoop, skinTones: nil),
+            "➿": EmojiWithSkinTones(baseEmoji: .loop, skinTones: nil)
+        ]
+        return (lookup[rawValue] ?? EmojiWithSkinTones(unsupportedValue: rawValue))
+    }
+    
+    private static func emojiFrom110(_ rawValue: String) -> EmojiWithSkinTones {
+        let lookup: [String: EmojiWithSkinTones] = [
+            "⭐": EmojiWithSkinTones(baseEmoji: .star, skinTones: nil),
+            "⭕": EmojiWithSkinTones(baseEmoji: .o, skinTones: nil),
+            "⬛": EmojiWithSkinTones(baseEmoji: .blackLargeSquare, skinTones: nil),
+            "⬜": EmojiWithSkinTones(baseEmoji: .whiteLargeSquare, skinTones: nil)
+        ]
+        return (lookup[rawValue] ?? EmojiWithSkinTones(unsupportedValue: rawValue))
+    }
+    
+    private static func emojiFrom652(_ rawValue: String) -> EmojiWithSkinTones {
+        let lookup: [String: EmojiWithSkinTones] = [
+            "©️": EmojiWithSkinTones(baseEmoji: .copyright, skinTones: nil),
+            "®️": EmojiWithSkinTones(baseEmoji: .registered, skinTones: nil)
+        ]
+        return (lookup[rawValue] ?? EmojiWithSkinTones(unsupportedValue: rawValue))
+    }
+    
+    private static func emojiFrom732(_ rawValue: String) -> EmojiWithSkinTones {
+        let lookup: [String: EmojiWithSkinTones] = [
+            "‼️": EmojiWithSkinTones(baseEmoji: .bangbang, skinTones: nil)
+        ]
+        return (lookup[rawValue] ?? EmojiWithSkinTones(unsupportedValue: rawValue))
+    }
+    
+    private static func emojiFrom733(_ rawValue: String) -> EmojiWithSkinTones {
+        let lookup: [String: EmojiWithSkinTones] = [
+            "⁉️": EmojiWithSkinTones(baseEmoji: .interrobang, skinTones: nil)
+        ]
+        return (lookup[rawValue] ?? EmojiWithSkinTones(unsupportedValue: rawValue))
+    }
+    
+    private static func emojiFrom734(_ rawValue: String) -> EmojiWithSkinTones {
+        let lookup: [String: EmojiWithSkinTones] = [
+            "#️⃣": EmojiWithSkinTones(baseEmoji: .hash, skinTones: nil)
+        ]
+        return (lookup[rawValue] ?? EmojiWithSkinTones(unsupportedValue: rawValue))
+    }
+    
+    private static func emojiFrom735(_ rawValue: String) -> EmojiWithSkinTones {
+        let lookup: [String: EmojiWithSkinTones] = [
+            "™️": EmojiWithSkinTones(baseEmoji: .tm, skinTones: nil),
+            "*️⃣": EmojiWithSkinTones(baseEmoji: .keycapStar, skinTones: nil),
+            "0️⃣": EmojiWithSkinTones(baseEmoji: .zero, skinTones: nil),
+            "1️⃣": EmojiWithSkinTones(baseEmoji: .one, skinTones: nil),
+            "2️⃣": EmojiWithSkinTones(baseEmoji: .two, skinTones: nil),
+            "3️⃣": EmojiWithSkinTones(baseEmoji: .three, skinTones: nil),
+            "4️⃣": EmojiWithSkinTones(baseEmoji: .four, skinTones: nil),
+            "5️⃣": EmojiWithSkinTones(baseEmoji: .five, skinTones: nil),
+            "6️⃣": EmojiWithSkinTones(baseEmoji: .six, skinTones: nil),
+            "7️⃣": EmojiWithSkinTones(baseEmoji: .seven, skinTones: nil),
+            "8️⃣": EmojiWithSkinTones(baseEmoji: .eight, skinTones: nil),
+            "9️⃣": EmojiWithSkinTones(baseEmoji: .nine, skinTones: nil),
+            "ℹ️": EmojiWithSkinTones(baseEmoji: .informationSource, skinTones: nil)
+        ]
+        return (lookup[rawValue] ?? EmojiWithSkinTones(unsupportedValue: rawValue))
+    }
+    
+    private static func emojiFrom736(_ rawValue: String) -> EmojiWithSkinTones {
+        let lookup: [String: EmojiWithSkinTones] = [
+            "↗️": EmojiWithSkinTones(baseEmoji: .arrowUpperRight, skinTones: nil),
+            "↘️": EmojiWithSkinTones(baseEmoji: .arrowLowerRight, skinTones: nil),
+            "↙️": EmojiWithSkinTones(baseEmoji: .arrowLowerLeft, skinTones: nil),
+            "↖️": EmojiWithSkinTones(baseEmoji: .arrowUpperLeft, skinTones: nil),
+            "↕️": EmojiWithSkinTones(baseEmoji: .arrowUpDown, skinTones: nil),
+            "↔️": EmojiWithSkinTones(baseEmoji: .leftRightArrow, skinTones: nil),
+            "↩️": EmojiWithSkinTones(baseEmoji: .leftwardsArrowWithHook, skinTones: nil),
+            "↪️": EmojiWithSkinTones(baseEmoji: .arrowRightHook, skinTones: nil)
+        ]
+        return (lookup[rawValue] ?? EmojiWithSkinTones(unsupportedValue: rawValue))
+    }
+    
+    private static func emojiFrom740(_ rawValue: String) -> EmojiWithSkinTones {
+        let lookup: [String: EmojiWithSkinTones] = [
+            "⌨️": EmojiWithSkinTones(baseEmoji: .keyboard, skinTones: nil)
+        ]
+        return (lookup[rawValue] ?? EmojiWithSkinTones(unsupportedValue: rawValue))
+    }
+    
+    private static func emojiFrom742(_ rawValue: String) -> EmojiWithSkinTones {
+        let lookup: [String: EmojiWithSkinTones] = [
+            "⏱️": EmojiWithSkinTones(baseEmoji: .stopwatch, skinTones: nil),
+            "⏲️": EmojiWithSkinTones(baseEmoji: .timerClock, skinTones: nil),
+            "⏭️": EmojiWithSkinTones(baseEmoji: .blackRightPointingDoubleTriangleWithVerticalBar, skinTones: nil),
+            "⏯️": EmojiWithSkinTones(baseEmoji: .blackRightPointingTriangleWithDoubleVerticalBar, skinTones: nil),
+            "⏮️": EmojiWithSkinTones(baseEmoji: .blackLeftPointingDoubleTriangleWithVerticalBar, skinTones: nil),
+            "⏸️": EmojiWithSkinTones(baseEmoji: .doubleVerticalBar, skinTones: nil),
+            "⏹️": EmojiWithSkinTones(baseEmoji: .blackSquareForStop, skinTones: nil),
+            "⏺️": EmojiWithSkinTones(baseEmoji: .blackCircleForRecord, skinTones: nil),
+            "⏏️": EmojiWithSkinTones(baseEmoji: .eject, skinTones: nil)
+        ]
+        return (lookup[rawValue] ?? EmojiWithSkinTones(unsupportedValue: rawValue))
+    }
+    
+    private static func emojiFrom744(_ rawValue: String) -> EmojiWithSkinTones {
+        let lookup: [String: EmojiWithSkinTones] = [
+            "Ⓜ️": EmojiWithSkinTones(baseEmoji: .m, skinTones: nil)
+        ]
+        return (lookup[rawValue] ?? EmojiWithSkinTones(unsupportedValue: rawValue))
+    }
+    
+    private static func emojiFrom746(_ rawValue: String) -> EmojiWithSkinTones {
+        let lookup: [String: EmojiWithSkinTones] = [
+            "▶️": EmojiWithSkinTones(baseEmoji: .arrowForward, skinTones: nil),
+            "▪️": EmojiWithSkinTones(baseEmoji: .blackSmallSquare, skinTones: nil),
+            "▫️": EmojiWithSkinTones(baseEmoji: .whiteSmallSquare, skinTones: nil)
+        ]
+        return (lookup[rawValue] ?? EmojiWithSkinTones(unsupportedValue: rawValue))
+    }
+    
+    private static func emojiFrom747(_ rawValue: String) -> EmojiWithSkinTones {
+        let lookup: [String: EmojiWithSkinTones] = [
+            "☠️": EmojiWithSkinTones(baseEmoji: .skullAndCrossbones, skinTones: nil),
+            "☝️": EmojiWithSkinTones(baseEmoji: .pointUp, skinTones: nil),
+            "☘️": EmojiWithSkinTones(baseEmoji: .shamrock, skinTones: nil),
+            "☀️": EmojiWithSkinTones(baseEmoji: .sunny, skinTones: nil),
+            "☁️": EmojiWithSkinTones(baseEmoji: .cloud, skinTones: nil),
+            "☂️": EmojiWithSkinTones(baseEmoji: .umbrella, skinTones: nil),
+            "☃️": EmojiWithSkinTones(baseEmoji: .snowman, skinTones: nil),
+            "☄️": EmojiWithSkinTones(baseEmoji: .comet, skinTones: nil),
+            "☎️": EmojiWithSkinTones(baseEmoji: .phone, skinTones: nil),
+            "◀️": EmojiWithSkinTones(baseEmoji: .arrowBackward, skinTones: nil),
+            "☑️": EmojiWithSkinTones(baseEmoji: .ballotBoxWithCheck, skinTones: nil),
+            "◼️": EmojiWithSkinTones(baseEmoji: .blackMediumSquare, skinTones: nil),
+            "◻️": EmojiWithSkinTones(baseEmoji: .whiteMediumSquare, skinTones: nil)
+        ]
+        return (lookup[rawValue] ?? EmojiWithSkinTones(unsupportedValue: rawValue))
+    }
+    
+    private static func emojiFrom748(_ rawValue: String) -> EmojiWithSkinTones {
+        let lookup: [String: EmojiWithSkinTones] = [
+            "☺️": EmojiWithSkinTones(baseEmoji: .relaxed, skinTones: nil),
+            "☹️": EmojiWithSkinTones(baseEmoji: .whiteFrowningFace, skinTones: nil),
+            "♨️": EmojiWithSkinTones(baseEmoji: .hotsprings, skinTones: nil),
+            "♠️": EmojiWithSkinTones(baseEmoji: .spades, skinTones: nil),
+            "♥️": EmojiWithSkinTones(baseEmoji: .hearts, skinTones: nil),
+            "♦️": EmojiWithSkinTones(baseEmoji: .diamonds, skinTones: nil),
+            "♣️": EmojiWithSkinTones(baseEmoji: .clubs, skinTones: nil),
+            "♟️": EmojiWithSkinTones(baseEmoji: .chessPawn, skinTones: nil),
+            "☢️": EmojiWithSkinTones(baseEmoji: .radioactiveSign, skinTones: nil),
+            "☣️": EmojiWithSkinTones(baseEmoji: .biohazardSign, skinTones: nil),
+            "☸️": EmojiWithSkinTones(baseEmoji: .wheelOfDharma, skinTones: nil),
+            "☯️": EmojiWithSkinTones(baseEmoji: .yinYang, skinTones: nil),
+            "☦️": EmojiWithSkinTones(baseEmoji: .orthodoxCross, skinTones: nil),
+            "☪️": EmojiWithSkinTones(baseEmoji: .starAndCrescent, skinTones: nil),
+            "☮️": EmojiWithSkinTones(baseEmoji: .peaceSymbol, skinTones: nil),
+            "♀️": EmojiWithSkinTones(baseEmoji: .femaleSign, skinTones: nil),
+            "♂️": EmojiWithSkinTones(baseEmoji: .maleSign, skinTones: nil),
+            "♾️": EmojiWithSkinTones(baseEmoji: .infinity, skinTones: nil),
+            "♻️": EmojiWithSkinTones(baseEmoji: .recycle, skinTones: nil)
+        ]
+        return (lookup[rawValue] ?? EmojiWithSkinTones(unsupportedValue: rawValue))
+    }
+    
+    private static func emojiFrom749(_ rawValue: String) -> EmojiWithSkinTones {
+        let lookup: [String: EmojiWithSkinTones] = [
+            "⛈️": EmojiWithSkinTones(baseEmoji: .thunderCloudAndRain, skinTones: nil),
+            "⛑️": EmojiWithSkinTones(baseEmoji: .helmetWithWhiteCross, skinTones: nil),
+            "⛏️": EmojiWithSkinTones(baseEmoji: .pick, skinTones: nil),
+            "⚒️": EmojiWithSkinTones(baseEmoji: .hammerAndPick, skinTones: nil),
+            "⚔️": EmojiWithSkinTones(baseEmoji: .crossedSwords, skinTones: nil),
+            "⚙️": EmojiWithSkinTones(baseEmoji: .gear, skinTones: nil),
+            "⚖️": EmojiWithSkinTones(baseEmoji: .scales, skinTones: nil),
+            "⛓️": EmojiWithSkinTones(baseEmoji: .chains, skinTones: nil),
+            "⚗️": EmojiWithSkinTones(baseEmoji: .alembic, skinTones: nil),
+            "⚰️": EmojiWithSkinTones(baseEmoji: .coffin, skinTones: nil),
+            "⚱️": EmojiWithSkinTones(baseEmoji: .funeralUrn, skinTones: nil),
+            "⚠️": EmojiWithSkinTones(baseEmoji: .warning, skinTones: nil),
+            "⚛️": EmojiWithSkinTones(baseEmoji: .atomSymbol, skinTones: nil),
+            "⚧️": EmojiWithSkinTones(baseEmoji: .transgenderSymbol, skinTones: nil),
+            "⚕️": EmojiWithSkinTones(baseEmoji: .medicalSymbol, skinTones: nil),
+            "⚜️": EmojiWithSkinTones(baseEmoji: .fleurDeLis, skinTones: nil)
+        ]
+        return (lookup[rawValue] ?? EmojiWithSkinTones(unsupportedValue: rawValue))
+    }
+    
+    private static func emojiFrom750(_ rawValue: String) -> EmojiWithSkinTones {
+        let lookup: [String: EmojiWithSkinTones] = [
+            "✌️": EmojiWithSkinTones(baseEmoji: .v, skinTones: nil),
+            "✍️": EmojiWithSkinTones(baseEmoji: .writingHand, skinTones: nil),
+            "⛷️": EmojiWithSkinTones(baseEmoji: .skier, skinTones: nil),
+            "⛹️": EmojiWithSkinTones(baseEmoji: .personWithBall, skinTones: nil),
+            "⛰️": EmojiWithSkinTones(baseEmoji: .mountain, skinTones: nil),
+            "⛩️": EmojiWithSkinTones(baseEmoji: .shintoShrine, skinTones: nil),
+            "⛴️": EmojiWithSkinTones(baseEmoji: .ferry, skinTones: nil),
+            "✈️": EmojiWithSkinTones(baseEmoji: .airplane, skinTones: nil),
+            "⛱️": EmojiWithSkinTones(baseEmoji: .umbrellaOnGround, skinTones: nil),
+            "❄️": EmojiWithSkinTones(baseEmoji: .snowflake, skinTones: nil),
+            "⛸️": EmojiWithSkinTones(baseEmoji: .iceSkate, skinTones: nil),
+            "✉️": EmojiWithSkinTones(baseEmoji: .email, skinTones: nil),
+            "✏️": EmojiWithSkinTones(baseEmoji: .pencil2, skinTones: nil),
+            "✒️": EmojiWithSkinTones(baseEmoji: .blackNib, skinTones: nil),
+            "✂️": EmojiWithSkinTones(baseEmoji: .scissors, skinTones: nil),
+            "✡️": EmojiWithSkinTones(baseEmoji: .starOfDavid, skinTones: nil),
+            "✝️": EmojiWithSkinTones(baseEmoji: .latinCross, skinTones: nil),
+            "✖️": EmojiWithSkinTones(baseEmoji: .heavyMultiplicationX, skinTones: nil),
+            "✔️": EmojiWithSkinTones(baseEmoji: .heavyCheckMark, skinTones: nil),
+            "✳️": EmojiWithSkinTones(baseEmoji: .eightSpokedAsterisk, skinTones: nil),
+            "✴️": EmojiWithSkinTones(baseEmoji: .eightPointedBlackStar, skinTones: nil),
+            "❇️": EmojiWithSkinTones(baseEmoji: .sparkle, skinTones: nil)
+        ]
+        return (lookup[rawValue] ?? EmojiWithSkinTones(unsupportedValue: rawValue))
+    }
+    
+    private static func emojiFrom751(_ rawValue: String) -> EmojiWithSkinTones {
+        let lookup: [String: EmojiWithSkinTones] = [
+            "❣️": EmojiWithSkinTones(baseEmoji: .heavyHeartExclamationMarkOrnament, skinTones: nil),
+            "❤️": EmojiWithSkinTones(baseEmoji: .heart, skinTones: nil),
+            "➡️": EmojiWithSkinTones(baseEmoji: .arrowRight, skinTones: nil)
+        ]
+        return (lookup[rawValue] ?? EmojiWithSkinTones(unsupportedValue: rawValue))
+    }
+    
+    private static func emojiFrom755(_ rawValue: String) -> EmojiWithSkinTones {
+        let lookup: [String: EmojiWithSkinTones] = [
+            "⤴️": EmojiWithSkinTones(baseEmoji: .arrowHeadingUp, skinTones: nil),
+            "⤵️": EmojiWithSkinTones(baseEmoji: .arrowHeadingDown, skinTones: nil)
+        ]
+        return (lookup[rawValue] ?? EmojiWithSkinTones(unsupportedValue: rawValue))
+    }
+    
+    private static func emojiFrom760(_ rawValue: String) -> EmojiWithSkinTones {
+        let lookup: [String: EmojiWithSkinTones] = [
+            "⬆️": EmojiWithSkinTones(baseEmoji: .arrowUp, skinTones: nil),
+            "⬇️": EmojiWithSkinTones(baseEmoji: .arrowDown, skinTones: nil),
+            "⬅️": EmojiWithSkinTones(baseEmoji: .arrowLeft, skinTones: nil)
+        ]
+        return (lookup[rawValue] ?? EmojiWithSkinTones(unsupportedValue: rawValue))
+    }
+    
+    private static func emojiFrom773(_ rawValue: String) -> EmojiWithSkinTones {
+        let lookup: [String: EmojiWithSkinTones] = [
+            "〰️": EmojiWithSkinTones(baseEmoji: .wavyDash, skinTones: nil),
+            "〽️": EmojiWithSkinTones(baseEmoji: .partAlternationMark, skinTones: nil)
+        ]
+        return (lookup[rawValue] ?? EmojiWithSkinTones(unsupportedValue: rawValue))
+    }
+    
+    private static func emojiFrom779(_ rawValue: String) -> EmojiWithSkinTones {
+        let lookup: [String: EmojiWithSkinTones] = [
+            "㊗️": EmojiWithSkinTones(baseEmoji: .congratulations, skinTones: nil),
+            "㊙️": EmojiWithSkinTones(baseEmoji: .secret, skinTones: nil)
+        ]
+        return (lookup[rawValue] ?? EmojiWithSkinTones(unsupportedValue: rawValue))
+    }
+    
+    private static func emojiFrom1269(_ rawValue: String) -> EmojiWithSkinTones {
+        let lookup: [String: EmojiWithSkinTones] = [
+            "🀄": EmojiWithSkinTones(baseEmoji: .mahjong, skinTones: nil)
+        ]
+        return (lookup[rawValue] ?? EmojiWithSkinTones(unsupportedValue: rawValue))
+    }
+    
+    private static func emojiFrom1271(_ rawValue: String) -> EmojiWithSkinTones {
+        let lookup: [String: EmojiWithSkinTones] = [
+            "🃏": EmojiWithSkinTones(baseEmoji: .blackJoker, skinTones: nil)
+        ]
+        return (lookup[rawValue] ?? EmojiWithSkinTones(unsupportedValue: rawValue))
+    }
+    
+    private static func emojiFrom1273(_ rawValue: String) -> EmojiWithSkinTones {
+        let lookup: [String: EmojiWithSkinTones] = [
+            "🆎": EmojiWithSkinTones(baseEmoji: .ab, skinTones: nil),
+            "🆑": EmojiWithSkinTones(baseEmoji: .cl, skinTones: nil),
+            "🆒": EmojiWithSkinTones(baseEmoji: .cool, skinTones: nil),
+            "🆓": EmojiWithSkinTones(baseEmoji: .free, skinTones: nil),
+            "🆔": EmojiWithSkinTones(baseEmoji: .id, skinTones: nil),
+            "🆕": EmojiWithSkinTones(baseEmoji: .new, skinTones: nil),
+            "🆖": EmojiWithSkinTones(baseEmoji: .ng, skinTones: nil),
+            "🆗": EmojiWithSkinTones(baseEmoji: .ok, skinTones: nil),
+            "🆘": EmojiWithSkinTones(baseEmoji: .sos, skinTones: nil),
+            "🆙": EmojiWithSkinTones(baseEmoji: .up, skinTones: nil),
+            "🆚": EmojiWithSkinTones(baseEmoji: .vs, skinTones: nil)
+        ]
+        return (lookup[rawValue] ?? EmojiWithSkinTones(unsupportedValue: rawValue))
+    }
+    
+    private static func emojiFrom1274(_ rawValue: String) -> EmojiWithSkinTones {
+        let lookup: [String: EmojiWithSkinTones] = [
+            "🈁": EmojiWithSkinTones(baseEmoji: .koko, skinTones: nil)
+        ]
+        return (lookup[rawValue] ?? EmojiWithSkinTones(unsupportedValue: rawValue))
+    }
+    
+    private static func emojiFrom1275(_ rawValue: String) -> EmojiWithSkinTones {
+        let lookup: [String: EmojiWithSkinTones] = [
+            "🈶": EmojiWithSkinTones(baseEmoji: .u6709, skinTones: nil),
+            "🈯": EmojiWithSkinTones(baseEmoji: .u6307, skinTones: nil),
+            "🉐": EmojiWithSkinTones(baseEmoji: .ideographAdvantage, skinTones: nil),
+            "🈹": EmojiWithSkinTones(baseEmoji: .u5272, skinTones: nil),
+            "🈚": EmojiWithSkinTones(baseEmoji: .u7121, skinTones: nil),
+            "🈲": EmojiWithSkinTones(baseEmoji: .u7981, skinTones: nil),
+            "🉑": EmojiWithSkinTones(baseEmoji: .accept, skinTones: nil),
+            "🈸": EmojiWithSkinTones(baseEmoji: .u7533, skinTones: nil),
+            "🈴": EmojiWithSkinTones(baseEmoji: .u5408, skinTones: nil),
+            "🈳": EmojiWithSkinTones(baseEmoji: .u7a7a, skinTones: nil),
+            "🈺": EmojiWithSkinTones(baseEmoji: .u55b6, skinTones: nil),
+            "🈵": EmojiWithSkinTones(baseEmoji: .u6e80, skinTones: nil)
+        ]
+        return (lookup[rawValue] ?? EmojiWithSkinTones(unsupportedValue: rawValue))
+    }
+    
+    private static func emojiFrom1277(_ rawValue: String) -> EmojiWithSkinTones {
+        let lookup: [String: EmojiWithSkinTones] = [
+            "🌷": EmojiWithSkinTones(baseEmoji: .tulip, skinTones: nil),
+            "🌱": EmojiWithSkinTones(baseEmoji: .seedling, skinTones: nil),
+            "🌲": EmojiWithSkinTones(baseEmoji: .evergreenTree, skinTones: nil),
+            "🌳": EmojiWithSkinTones(baseEmoji: .deciduousTree, skinTones: nil),
+            "🌴": EmojiWithSkinTones(baseEmoji: .palmTree, skinTones: nil),
+            "🌵": EmojiWithSkinTones(baseEmoji: .cactus, skinTones: nil),
+            "🌰": EmojiWithSkinTones(baseEmoji: .chestnut, skinTones: nil),
+            "🌭": EmojiWithSkinTones(baseEmoji: .hotdog, skinTones: nil),
+            "🌮": EmojiWithSkinTones(baseEmoji: .taco, skinTones: nil),
+            "🌯": EmojiWithSkinTones(baseEmoji: .burrito, skinTones: nil),
+            "🌍": EmojiWithSkinTones(baseEmoji: .earthAfrica, skinTones: nil),
+            "🌎": EmojiWithSkinTones(baseEmoji: .earthAmericas, skinTones: nil),
+            "🌏": EmojiWithSkinTones(baseEmoji: .earthAsia, skinTones: nil),
+            "🌐": EmojiWithSkinTones(baseEmoji: .globeWithMeridians, skinTones: nil),
+            "🌋": EmojiWithSkinTones(baseEmoji: .volcano, skinTones: nil),
+            "🌁": EmojiWithSkinTones(baseEmoji: .foggy, skinTones: nil),
+            "🌃": EmojiWithSkinTones(baseEmoji: .nightWithStars, skinTones: nil),
+            "🌄": EmojiWithSkinTones(baseEmoji: .sunriseOverMountains, skinTones: nil),
+            "🌅": EmojiWithSkinTones(baseEmoji: .sunrise, skinTones: nil),
+            "🌆": EmojiWithSkinTones(baseEmoji: .citySunset, skinTones: nil),
+            "🌇": EmojiWithSkinTones(baseEmoji: .citySunrise, skinTones: nil),
+            "🌉": EmojiWithSkinTones(baseEmoji: .bridgeAtNight, skinTones: nil),
+            "🌑": EmojiWithSkinTones(baseEmoji: .newMoon, skinTones: nil),
+            "🌒": EmojiWithSkinTones(baseEmoji: .waxingCrescentMoon, skinTones: nil),
+            "🌓": EmojiWithSkinTones(baseEmoji: .firstQuarterMoon, skinTones: nil),
+            "🌔": EmojiWithSkinTones(baseEmoji: .moon, skinTones: nil),
+            "🌕": EmojiWithSkinTones(baseEmoji: .fullMoon, skinTones: nil),
+            "🌖": EmojiWithSkinTones(baseEmoji: .waningGibbousMoon, skinTones: nil),
+            "🌗": EmojiWithSkinTones(baseEmoji: .lastQuarterMoon, skinTones: nil),
+            "🌘": EmojiWithSkinTones(baseEmoji: .waningCrescentMoon, skinTones: nil),
+            "🌙": EmojiWithSkinTones(baseEmoji: .crescentMoon, skinTones: nil),
+            "🌚": EmojiWithSkinTones(baseEmoji: .newMoonWithFace, skinTones: nil),
+            "🌛": EmojiWithSkinTones(baseEmoji: .firstQuarterMoonWithFace, skinTones: nil),
+            "🌜": EmojiWithSkinTones(baseEmoji: .lastQuarterMoonWithFace, skinTones: nil),
+            "🌝": EmojiWithSkinTones(baseEmoji: .fullMoonWithFace, skinTones: nil),
+            "🌞": EmojiWithSkinTones(baseEmoji: .sunWithFace, skinTones: nil),
+            "🌟": EmojiWithSkinTones(baseEmoji: .star2, skinTones: nil),
+            "🌠": EmojiWithSkinTones(baseEmoji: .stars, skinTones: nil),
+            "🌌": EmojiWithSkinTones(baseEmoji: .milkyWay, skinTones: nil),
+            "🌀": EmojiWithSkinTones(baseEmoji: .cyclone, skinTones: nil),
+            "🌈": EmojiWithSkinTones(baseEmoji: .rainbow, skinTones: nil),
+            "🌂": EmojiWithSkinTones(baseEmoji: .closedUmbrella, skinTones: nil),
+            "🌊": EmojiWithSkinTones(baseEmoji: .ocean, skinTones: nil)
+        ]
+        return (lookup[rawValue] ?? EmojiWithSkinTones(unsupportedValue: rawValue))
+    }
+    
+    private static func emojiFrom1278(_ rawValue: String) -> EmojiWithSkinTones {
+        let lookup: [String: EmojiWithSkinTones] = [
+            "🎅": EmojiWithSkinTones(baseEmoji: .santa, skinTones: nil),
+            "🌸": EmojiWithSkinTones(baseEmoji: .cherryBlossom, skinTones: nil),
+            "🌹": EmojiWithSkinTones(baseEmoji: .rose, skinTones: nil),
+            "🌺": EmojiWithSkinTones(baseEmoji: .hibiscus, skinTones: nil),
+            "🌻": EmojiWithSkinTones(baseEmoji: .sunflower, skinTones: nil),
+            "🌼": EmojiWithSkinTones(baseEmoji: .blossom, skinTones: nil),
+            "🌾": EmojiWithSkinTones(baseEmoji: .earOfRice, skinTones: nil),
+            "🌿": EmojiWithSkinTones(baseEmoji: .herb, skinTones: nil),
+            "🍀": EmojiWithSkinTones(baseEmoji: .fourLeafClover, skinTones: nil),
+            "🍁": EmojiWithSkinTones(baseEmoji: .mapleLeaf, skinTones: nil),
+            "🍂": EmojiWithSkinTones(baseEmoji: .fallenLeaf, skinTones: nil),
+            "🍃": EmojiWithSkinTones(baseEmoji: .leaves, skinTones: nil),
+            "🍄": EmojiWithSkinTones(baseEmoji: .mushroom, skinTones: nil),
+            "🍇": EmojiWithSkinTones(baseEmoji: .grapes, skinTones: nil),
+            "🍈": EmojiWithSkinTones(baseEmoji: .melon, skinTones: nil),
+            "🍉": EmojiWithSkinTones(baseEmoji: .watermelon, skinTones: nil),
+            "🍊": EmojiWithSkinTones(baseEmoji: .tangerine, skinTones: nil),
+            "🍋": EmojiWithSkinTones(baseEmoji: .lemon, skinTones: nil),
+            "🍌": EmojiWithSkinTones(baseEmoji: .banana, skinTones: nil),
+            "🍍": EmojiWithSkinTones(baseEmoji: .pineapple, skinTones: nil),
+            "🍎": EmojiWithSkinTones(baseEmoji: .apple, skinTones: nil),
+            "🍏": EmojiWithSkinTones(baseEmoji: .greenApple, skinTones: nil),
+            "🍐": EmojiWithSkinTones(baseEmoji: .pear, skinTones: nil),
+            "🍑": EmojiWithSkinTones(baseEmoji: .peach, skinTones: nil),
+            "🍒": EmojiWithSkinTones(baseEmoji: .cherries, skinTones: nil),
+            "🍓": EmojiWithSkinTones(baseEmoji: .strawberry, skinTones: nil),
+            "🍅": EmojiWithSkinTones(baseEmoji: .tomato, skinTones: nil),
+            "🍆": EmojiWithSkinTones(baseEmoji: .eggplant, skinTones: nil),
+            "🌽": EmojiWithSkinTones(baseEmoji: .corn, skinTones: nil),
+            "🍞": EmojiWithSkinTones(baseEmoji: .bread, skinTones: nil),
+            "🍖": EmojiWithSkinTones(baseEmoji: .meatOnBone, skinTones: nil),
+            "🍗": EmojiWithSkinTones(baseEmoji: .poultryLeg, skinTones: nil),
+            "🍔": EmojiWithSkinTones(baseEmoji: .hamburger, skinTones: nil),
+            "🍟": EmojiWithSkinTones(baseEmoji: .fries, skinTones: nil),
+            "🍕": EmojiWithSkinTones(baseEmoji: .pizza, skinTones: nil),
+            "🍳": EmojiWithSkinTones(baseEmoji: .friedEgg, skinTones: nil),
+            "🍲": EmojiWithSkinTones(baseEmoji: .stew, skinTones: nil),
+            "🍿": EmojiWithSkinTones(baseEmoji: .popcorn, skinTones: nil),
+            "🍱": EmojiWithSkinTones(baseEmoji: .bento, skinTones: nil),
+            "🍘": EmojiWithSkinTones(baseEmoji: .riceCracker, skinTones: nil),
+            "🍙": EmojiWithSkinTones(baseEmoji: .riceBall, skinTones: nil),
+            "🍚": EmojiWithSkinTones(baseEmoji: .rice, skinTones: nil),
+            "🍛": EmojiWithSkinTones(baseEmoji: .curry, skinTones: nil),
+            "🍜": EmojiWithSkinTones(baseEmoji: .ramen, skinTones: nil),
+            "🍝": EmojiWithSkinTones(baseEmoji: .spaghetti, skinTones: nil),
+            "🍠": EmojiWithSkinTones(baseEmoji: .sweetPotato, skinTones: nil),
+            "🍢": EmojiWithSkinTones(baseEmoji: .oden, skinTones: nil),
+            "🍣": EmojiWithSkinTones(baseEmoji: .sushi, skinTones: nil),
+            "🍤": EmojiWithSkinTones(baseEmoji: .friedShrimp, skinTones: nil),
+            "🍥": EmojiWithSkinTones(baseEmoji: .fishCake, skinTones: nil),
+            "🍡": EmojiWithSkinTones(baseEmoji: .dango, skinTones: nil),
+            "🍦": EmojiWithSkinTones(baseEmoji: .icecream, skinTones: nil),
+            "🍧": EmojiWithSkinTones(baseEmoji: .shavedIce, skinTones: nil),
+            "🍨": EmojiWithSkinTones(baseEmoji: .iceCream, skinTones: nil),
+            "🍩": EmojiWithSkinTones(baseEmoji: .doughnut, skinTones: nil),
+            "🍪": EmojiWithSkinTones(baseEmoji: .cookie, skinTones: nil),
+            "🎂": EmojiWithSkinTones(baseEmoji: .birthday, skinTones: nil),
+            "🍰": EmojiWithSkinTones(baseEmoji: .cake, skinTones: nil),
+            "🍫": EmojiWithSkinTones(baseEmoji: .chocolateBar, skinTones: nil),
+            "🍬": EmojiWithSkinTones(baseEmoji: .candy, skinTones: nil),
+            "🍭": EmojiWithSkinTones(baseEmoji: .lollipop, skinTones: nil),
+            "🍮": EmojiWithSkinTones(baseEmoji: .custard, skinTones: nil),
+            "🍯": EmojiWithSkinTones(baseEmoji: .honeyPot, skinTones: nil),
+            "🍼": EmojiWithSkinTones(baseEmoji: .babyBottle, skinTones: nil),
+            "🍵": EmojiWithSkinTones(baseEmoji: .tea, skinTones: nil),
+            "🍶": EmojiWithSkinTones(baseEmoji: .sake, skinTones: nil),
+            "🍾": EmojiWithSkinTones(baseEmoji: .champagne, skinTones: nil),
+            "🍷": EmojiWithSkinTones(baseEmoji: .wineGlass, skinTones: nil),
+            "🍸": EmojiWithSkinTones(baseEmoji: .cocktail, skinTones: nil),
+            "🍹": EmojiWithSkinTones(baseEmoji: .tropicalDrink, skinTones: nil),
+            "🍺": EmojiWithSkinTones(baseEmoji: .beer, skinTones: nil),
+            "🍻": EmojiWithSkinTones(baseEmoji: .beers, skinTones: nil),
+            "🍴": EmojiWithSkinTones(baseEmoji: .forkAndKnife, skinTones: nil),
+            "🎃": EmojiWithSkinTones(baseEmoji: .jackOLantern, skinTones: nil),
+            "🎄": EmojiWithSkinTones(baseEmoji: .christmasTree, skinTones: nil),
+            "🎆": EmojiWithSkinTones(baseEmoji: .fireworks, skinTones: nil),
+            "🎇": EmojiWithSkinTones(baseEmoji: .sparkler, skinTones: nil),
+            "🎈": EmojiWithSkinTones(baseEmoji: .balloon, skinTones: nil),
+            "🎉": EmojiWithSkinTones(baseEmoji: .tada, skinTones: nil),
+            "🎊": EmojiWithSkinTones(baseEmoji: .confettiBall, skinTones: nil),
+            "🎋": EmojiWithSkinTones(baseEmoji: .tanabataTree, skinTones: nil),
+            "🎍": EmojiWithSkinTones(baseEmoji: .bamboo, skinTones: nil),
+            "🎎": EmojiWithSkinTones(baseEmoji: .dolls, skinTones: nil),
+            "🎏": EmojiWithSkinTones(baseEmoji: .flags, skinTones: nil),
+            "🎐": EmojiWithSkinTones(baseEmoji: .windChime, skinTones: nil),
+            "🎑": EmojiWithSkinTones(baseEmoji: .riceScene, skinTones: nil),
+            "🎀": EmojiWithSkinTones(baseEmoji: .ribbon, skinTones: nil),
+            "🎁": EmojiWithSkinTones(baseEmoji: .gift, skinTones: nil),
+            "🎒": EmojiWithSkinTones(baseEmoji: .schoolSatchel, skinTones: nil),
+            "🎓": EmojiWithSkinTones(baseEmoji: .mortarBoard, skinTones: nil),
+            "🎌": EmojiWithSkinTones(baseEmoji: .crossedFlags, skinTones: nil)
+        ]
+        return (lookup[rawValue] ?? EmojiWithSkinTones(unsupportedValue: rawValue))
+    }
+    
+    private static func emojiFrom1279(_ rawValue: String) -> EmojiWithSkinTones {
+        let lookup: [String: EmojiWithSkinTones] = [
+            "🏃": EmojiWithSkinTones(baseEmoji: .runner, skinTones: nil),
+            "🏇": EmojiWithSkinTones(baseEmoji: .horseRacing, skinTones: nil),
+            "🏂": EmojiWithSkinTones(baseEmoji: .snowboarder, skinTones: nil),
+            "🏄": EmojiWithSkinTones(baseEmoji: .surfer, skinTones: nil),
+            "🏊": EmojiWithSkinTones(baseEmoji: .swimmer, skinTones: nil),
+            "🏻": EmojiWithSkinTones(baseEmoji: .skinTone2, skinTones: nil),
+            "🏼": EmojiWithSkinTones(baseEmoji: .skinTone3, skinTones: nil),
+            "🏽": EmojiWithSkinTones(baseEmoji: .skinTone4, skinTones: nil),
+            "🏾": EmojiWithSkinTones(baseEmoji: .skinTone5, skinTones: nil),
+            "🏿": EmojiWithSkinTones(baseEmoji: .skinTone6, skinTones: nil),
+            "🏺": EmojiWithSkinTones(baseEmoji: .amphora, skinTones: nil),
+            "🏠": EmojiWithSkinTones(baseEmoji: .house, skinTones: nil),
+            "🏡": EmojiWithSkinTones(baseEmoji: .houseWithGarden, skinTones: nil),
+            "🏢": EmojiWithSkinTones(baseEmoji: .office, skinTones: nil),
+            "🏣": EmojiWithSkinTones(baseEmoji: .postOffice, skinTones: nil),
+            "🏤": EmojiWithSkinTones(baseEmoji: .europeanPostOffice, skinTones: nil),
+            "🏥": EmojiWithSkinTones(baseEmoji: .hospital, skinTones: nil),
+            "🏦": EmojiWithSkinTones(baseEmoji: .bank, skinTones: nil),
+            "🏨": EmojiWithSkinTones(baseEmoji: .hotel, skinTones: nil),
+            "🏩": EmojiWithSkinTones(baseEmoji: .loveHotel, skinTones: nil),
+            "🏪": EmojiWithSkinTones(baseEmoji: .convenienceStore, skinTones: nil),
+            "🏫": EmojiWithSkinTones(baseEmoji: .school, skinTones: nil),
+            "🏬": EmojiWithSkinTones(baseEmoji: .departmentStore, skinTones: nil),
+            "🏭": EmojiWithSkinTones(baseEmoji: .factory, skinTones: nil),
+            "🏯": EmojiWithSkinTones(baseEmoji: .japaneseCastle, skinTones: nil),
+            "🏰": EmojiWithSkinTones(baseEmoji: .europeanCastle, skinTones: nil),
+            "🎠": EmojiWithSkinTones(baseEmoji: .carouselHorse, skinTones: nil),
+            "🎡": EmojiWithSkinTones(baseEmoji: .ferrisWheel, skinTones: nil),
+            "🎢": EmojiWithSkinTones(baseEmoji: .rollerCoaster, skinTones: nil),
+            "🎪": EmojiWithSkinTones(baseEmoji: .circusTent, skinTones: nil),
+            "🎫": EmojiWithSkinTones(baseEmoji: .ticket, skinTones: nil),
+            "🏆": EmojiWithSkinTones(baseEmoji: .trophy, skinTones: nil),
+            "🏅": EmojiWithSkinTones(baseEmoji: .sportsMedal, skinTones: nil),
+            "🏀": EmojiWithSkinTones(baseEmoji: .basketball, skinTones: nil),
+            "🏐": EmojiWithSkinTones(baseEmoji: .volleyball, skinTones: nil),
+            "🏈": EmojiWithSkinTones(baseEmoji: .football, skinTones: nil),
+            "🏉": EmojiWithSkinTones(baseEmoji: .rugbyFootball, skinTones: nil),
+            "🎾": EmojiWithSkinTones(baseEmoji: .tennis, skinTones: nil),
+            "🎳": EmojiWithSkinTones(baseEmoji: .bowling, skinTones: nil),
+            "🏏": EmojiWithSkinTones(baseEmoji: .cricketBatAndBall, skinTones: nil),
+            "🏑": EmojiWithSkinTones(baseEmoji: .fieldHockeyStickAndBall, skinTones: nil),
+            "🏒": EmojiWithSkinTones(baseEmoji: .iceHockeyStickAndPuck, skinTones: nil),
+            "🏓": EmojiWithSkinTones(baseEmoji: .tableTennisPaddleAndBall, skinTones: nil),
+            "🏸": EmojiWithSkinTones(baseEmoji: .badmintonRacquetAndShuttlecock, skinTones: nil),
+            "🎣": EmojiWithSkinTones(baseEmoji: .fishingPoleAndFish, skinTones: nil),
+            "🎽": EmojiWithSkinTones(baseEmoji: .runningShirtWithSash, skinTones: nil),
+            "🎿": EmojiWithSkinTones(baseEmoji: .ski, skinTones: nil),
+            "🎯": EmojiWithSkinTones(baseEmoji: .dart, skinTones: nil),
+            "🎱": EmojiWithSkinTones(baseEmoji: .eightBall, skinTones: nil),
+            "🎮": EmojiWithSkinTones(baseEmoji: .videoGame, skinTones: nil),
+            "🎰": EmojiWithSkinTones(baseEmoji: .slotMachine, skinTones: nil),
+            "🎲": EmojiWithSkinTones(baseEmoji: .gameDie, skinTones: nil),
+            "🎴": EmojiWithSkinTones(baseEmoji: .flowerPlayingCards, skinTones: nil),
+            "🎭": EmojiWithSkinTones(baseEmoji: .performingArts, skinTones: nil),
+            "🎨": EmojiWithSkinTones(baseEmoji: .art, skinTones: nil),
+            "🎩": EmojiWithSkinTones(baseEmoji: .tophat, skinTones: nil),
+            "🎼": EmojiWithSkinTones(baseEmoji: .musicalScore, skinTones: nil),
+            "🎵": EmojiWithSkinTones(baseEmoji: .musicalNote, skinTones: nil),
+            "🎶": EmojiWithSkinTones(baseEmoji: .notes, skinTones: nil),
+            "🎤": EmojiWithSkinTones(baseEmoji: .microphone, skinTones: nil),
+            "🎧": EmojiWithSkinTones(baseEmoji: .headphones, skinTones: nil),
+            "🎷": EmojiWithSkinTones(baseEmoji: .saxophone, skinTones: nil),
+            "🎸": EmojiWithSkinTones(baseEmoji: .guitar, skinTones: nil),
+            "🎹": EmojiWithSkinTones(baseEmoji: .musicalKeyboard, skinTones: nil),
+            "🎺": EmojiWithSkinTones(baseEmoji: .trumpet, skinTones: nil),
+            "🎻": EmojiWithSkinTones(baseEmoji: .violin, skinTones: nil),
+            "🎥": EmojiWithSkinTones(baseEmoji: .movieCamera, skinTones: nil),
+            "🎬": EmojiWithSkinTones(baseEmoji: .clapper, skinTones: nil),
+            "🏮": EmojiWithSkinTones(baseEmoji: .izakayaLantern, skinTones: nil),
+            "🏹": EmojiWithSkinTones(baseEmoji: .bowAndArrow, skinTones: nil),
+            "🏧": EmojiWithSkinTones(baseEmoji: .atm, skinTones: nil),
+            "🎦": EmojiWithSkinTones(baseEmoji: .cinema, skinTones: nil),
+            "🏁": EmojiWithSkinTones(baseEmoji: .checkeredFlag, skinTones: nil),
+            "🏴": EmojiWithSkinTones(baseEmoji: .wavingBlackFlag, skinTones: nil)
+        ]
+        return (lookup[rawValue] ?? EmojiWithSkinTones(unsupportedValue: rawValue))
+    }
+    
+    private static func emojiFrom1280(_ rawValue: String) -> EmojiWithSkinTones {
+        let lookup: [String: EmojiWithSkinTones] = [
+            "👋": EmojiWithSkinTones(baseEmoji: .wave, skinTones: nil),
+            "👌": EmojiWithSkinTones(baseEmoji: .okHand, skinTones: nil),
+            "👈": EmojiWithSkinTones(baseEmoji: .pointLeft, skinTones: nil),
+            "👉": EmojiWithSkinTones(baseEmoji: .pointRight, skinTones: nil),
+            "👆": EmojiWithSkinTones(baseEmoji: .pointUp2, skinTones: nil),
+            "👇": EmojiWithSkinTones(baseEmoji: .pointDown, skinTones: nil),
+            "👍": EmojiWithSkinTones(baseEmoji: .plusOne, skinTones: nil),
+            "👎": EmojiWithSkinTones(baseEmoji: .negativeOne, skinTones: nil),
+            "👊": EmojiWithSkinTones(baseEmoji: .facepunch, skinTones: nil),
+            "👏": EmojiWithSkinTones(baseEmoji: .clap, skinTones: nil),
+            "👐": EmojiWithSkinTones(baseEmoji: .openHands, skinTones: nil),
+            "👂": EmojiWithSkinTones(baseEmoji: .ear, skinTones: nil),
+            "👃": EmojiWithSkinTones(baseEmoji: .nose, skinTones: nil),
+            "👀": EmojiWithSkinTones(baseEmoji: .eyes, skinTones: nil),
+            "👅": EmojiWithSkinTones(baseEmoji: .tongue, skinTones: nil),
+            "👄": EmojiWithSkinTones(baseEmoji: .lips, skinTones: nil),
+            "👣": EmojiWithSkinTones(baseEmoji: .footprints, skinTones: nil),
+            "🐵": EmojiWithSkinTones(baseEmoji: .monkeyFace, skinTones: nil),
+            "🐒": EmojiWithSkinTones(baseEmoji: .monkey, skinTones: nil),
+            "🐶": EmojiWithSkinTones(baseEmoji: .dog, skinTones: nil),
+            "🐕": EmojiWithSkinTones(baseEmoji: .dog2, skinTones: nil),
+            "🐩": EmojiWithSkinTones(baseEmoji: .poodle, skinTones: nil),
+            "🐺": EmojiWithSkinTones(baseEmoji: .wolf, skinTones: nil),
+            "🐱": EmojiWithSkinTones(baseEmoji: .cat, skinTones: nil),
+            "🐈": EmojiWithSkinTones(baseEmoji: .cat2, skinTones: nil),
+            "🐯": EmojiWithSkinTones(baseEmoji: .tiger, skinTones: nil),
+            "🐅": EmojiWithSkinTones(baseEmoji: .tiger2, skinTones: nil),
+            "🐆": EmojiWithSkinTones(baseEmoji: .leopard, skinTones: nil),
+            "🐴": EmojiWithSkinTones(baseEmoji: .horse, skinTones: nil),
+            "🐎": EmojiWithSkinTones(baseEmoji: .racehorse, skinTones: nil),
+            "🐮": EmojiWithSkinTones(baseEmoji: .cow, skinTones: nil),
+            "🐂": EmojiWithSkinTones(baseEmoji: .ox, skinTones: nil),
+            "🐃": EmojiWithSkinTones(baseEmoji: .waterBuffalo, skinTones: nil),
+            "🐄": EmojiWithSkinTones(baseEmoji: .cow2, skinTones: nil),
+            "🐷": EmojiWithSkinTones(baseEmoji: .pig, skinTones: nil),
+            "🐖": EmojiWithSkinTones(baseEmoji: .pig2, skinTones: nil),
+            "🐗": EmojiWithSkinTones(baseEmoji: .boar, skinTones: nil),
+            "🐽": EmojiWithSkinTones(baseEmoji: .pigNose, skinTones: nil),
+            "🐏": EmojiWithSkinTones(baseEmoji: .ram, skinTones: nil),
+            "🐑": EmojiWithSkinTones(baseEmoji: .sheep, skinTones: nil),
+            "🐐": EmojiWithSkinTones(baseEmoji: .goat, skinTones: nil),
+            "🐪": EmojiWithSkinTones(baseEmoji: .dromedaryCamel, skinTones: nil),
+            "🐫": EmojiWithSkinTones(baseEmoji: .camel, skinTones: nil),
+            "🐘": EmojiWithSkinTones(baseEmoji: .elephant, skinTones: nil),
+            "🐭": EmojiWithSkinTones(baseEmoji: .mouse, skinTones: nil),
+            "🐁": EmojiWithSkinTones(baseEmoji: .mouse2, skinTones: nil),
+            "🐀": EmojiWithSkinTones(baseEmoji: .rat, skinTones: nil),
+            "🐹": EmojiWithSkinTones(baseEmoji: .hamster, skinTones: nil),
+            "🐰": EmojiWithSkinTones(baseEmoji: .rabbit, skinTones: nil),
+            "🐇": EmojiWithSkinTones(baseEmoji: .rabbit2, skinTones: nil),
+            "🐻": EmojiWithSkinTones(baseEmoji: .bear, skinTones: nil),
+            "🐨": EmojiWithSkinTones(baseEmoji: .koala, skinTones: nil),
+            "🐼": EmojiWithSkinTones(baseEmoji: .pandaFace, skinTones: nil),
+            "🐾": EmojiWithSkinTones(baseEmoji: .feet, skinTones: nil),
+            "🐔": EmojiWithSkinTones(baseEmoji: .chicken, skinTones: nil),
+            "🐓": EmojiWithSkinTones(baseEmoji: .rooster, skinTones: nil),
+            "🐣": EmojiWithSkinTones(baseEmoji: .hatchingChick, skinTones: nil),
+            "🐤": EmojiWithSkinTones(baseEmoji: .babyChick, skinTones: nil),
+            "🐥": EmojiWithSkinTones(baseEmoji: .hatchedChick, skinTones: nil),
+            "🐦": EmojiWithSkinTones(baseEmoji: .bird, skinTones: nil),
+            "🐧": EmojiWithSkinTones(baseEmoji: .penguin, skinTones: nil),
+            "🐸": EmojiWithSkinTones(baseEmoji: .frog, skinTones: nil),
+            "🐊": EmojiWithSkinTones(baseEmoji: .crocodile, skinTones: nil),
+            "🐢": EmojiWithSkinTones(baseEmoji: .turtle, skinTones: nil),
+            "🐍": EmojiWithSkinTones(baseEmoji: .snake, skinTones: nil),
+            "🐲": EmojiWithSkinTones(baseEmoji: .dragonFace, skinTones: nil),
+            "🐉": EmojiWithSkinTones(baseEmoji: .dragon, skinTones: nil),
+            "🐳": EmojiWithSkinTones(baseEmoji: .whale, skinTones: nil),
+            "🐋": EmojiWithSkinTones(baseEmoji: .whale2, skinTones: nil),
+            "🐬": EmojiWithSkinTones(baseEmoji: .dolphin, skinTones: nil),
+            "🐟": EmojiWithSkinTones(baseEmoji: .fish, skinTones: nil),
+            "🐠": EmojiWithSkinTones(baseEmoji: .tropicalFish, skinTones: nil),
+            "🐡": EmojiWithSkinTones(baseEmoji: .blowfish, skinTones: nil),
+            "🐙": EmojiWithSkinTones(baseEmoji: .octopus, skinTones: nil),
+            "🐚": EmojiWithSkinTones(baseEmoji: .shell, skinTones: nil),
+            "🐌": EmojiWithSkinTones(baseEmoji: .snail, skinTones: nil),
+            "🐛": EmojiWithSkinTones(baseEmoji: .bug, skinTones: nil),
+            "🐜": EmojiWithSkinTones(baseEmoji: .ant, skinTones: nil),
+            "🐝": EmojiWithSkinTones(baseEmoji: .bee, skinTones: nil),
+            "🐞": EmojiWithSkinTones(baseEmoji: .ladybug, skinTones: nil),
+            "👓": EmojiWithSkinTones(baseEmoji: .eyeglasses, skinTones: nil),
+            "👔": EmojiWithSkinTones(baseEmoji: .necktie, skinTones: nil),
+            "👕": EmojiWithSkinTones(baseEmoji: .shirt, skinTones: nil),
+            "👖": EmojiWithSkinTones(baseEmoji: .jeans, skinTones: nil),
+            "👗": EmojiWithSkinTones(baseEmoji: .dress, skinTones: nil),
+            "👘": EmojiWithSkinTones(baseEmoji: .kimono, skinTones: nil),
+            "👙": EmojiWithSkinTones(baseEmoji: .bikini, skinTones: nil),
+            "👚": EmojiWithSkinTones(baseEmoji: .womansClothes, skinTones: nil),
+            "👛": EmojiWithSkinTones(baseEmoji: .purse, skinTones: nil),
+            "👜": EmojiWithSkinTones(baseEmoji: .handbag, skinTones: nil),
+            "👝": EmojiWithSkinTones(baseEmoji: .pouch, skinTones: nil),
+            "👞": EmojiWithSkinTones(baseEmoji: .mansShoe, skinTones: nil),
+            "👟": EmojiWithSkinTones(baseEmoji: .athleticShoe, skinTones: nil),
+            "👠": EmojiWithSkinTones(baseEmoji: .highHeel, skinTones: nil),
+            "👡": EmojiWithSkinTones(baseEmoji: .sandal, skinTones: nil),
+            "👢": EmojiWithSkinTones(baseEmoji: .boot, skinTones: nil),
+            "👑": EmojiWithSkinTones(baseEmoji: .crown, skinTones: nil),
+            "👒": EmojiWithSkinTones(baseEmoji: .womansHat, skinTones: nil)
+        ]
+        return (lookup[rawValue] ?? EmojiWithSkinTones(unsupportedValue: rawValue))
+    }
+    
+    private static func emojiFrom1281(_ rawValue: String) -> EmojiWithSkinTones {
+        let lookup: [String: EmojiWithSkinTones] = [
+            "👿": EmojiWithSkinTones(baseEmoji: .imp, skinTones: nil),
+            "💀": EmojiWithSkinTones(baseEmoji: .skull, skinTones: nil),
+            "💩": EmojiWithSkinTones(baseEmoji: .hankey, skinTones: nil),
+            "👹": EmojiWithSkinTones(baseEmoji: .japaneseOgre, skinTones: nil),
+            "👺": EmojiWithSkinTones(baseEmoji: .japaneseGoblin, skinTones: nil),
+            "👻": EmojiWithSkinTones(baseEmoji: .ghost, skinTones: nil),
+            "👽": EmojiWithSkinTones(baseEmoji: .alien, skinTones: nil),
+            "👾": EmojiWithSkinTones(baseEmoji: .spaceInvader, skinTones: nil),
+            "💌": EmojiWithSkinTones(baseEmoji: .loveLetter, skinTones: nil),
+            "💘": EmojiWithSkinTones(baseEmoji: .cupid, skinTones: nil),
+            "💝": EmojiWithSkinTones(baseEmoji: .giftHeart, skinTones: nil),
+            "💖": EmojiWithSkinTones(baseEmoji: .sparklingHeart, skinTones: nil),
+            "💗": EmojiWithSkinTones(baseEmoji: .heartpulse, skinTones: nil),
+            "💓": EmojiWithSkinTones(baseEmoji: .heartbeat, skinTones: nil),
+            "💞": EmojiWithSkinTones(baseEmoji: .revolvingHearts, skinTones: nil),
+            "💕": EmojiWithSkinTones(baseEmoji: .twoHearts, skinTones: nil),
+            "💟": EmojiWithSkinTones(baseEmoji: .heartDecoration, skinTones: nil),
+            "💔": EmojiWithSkinTones(baseEmoji: .brokenHeart, skinTones: nil),
+            "💛": EmojiWithSkinTones(baseEmoji: .yellowHeart, skinTones: nil),
+            "💚": EmojiWithSkinTones(baseEmoji: .greenHeart, skinTones: nil),
+            "💙": EmojiWithSkinTones(baseEmoji: .blueHeart, skinTones: nil),
+            "💜": EmojiWithSkinTones(baseEmoji: .purpleHeart, skinTones: nil),
+            "💋": EmojiWithSkinTones(baseEmoji: .kiss, skinTones: nil),
+            "💯": EmojiWithSkinTones(baseEmoji: .oneHundred, skinTones: nil),
+            "💢": EmojiWithSkinTones(baseEmoji: .anger, skinTones: nil),
+            "💥": EmojiWithSkinTones(baseEmoji: .boom, skinTones: nil),
+            "💫": EmojiWithSkinTones(baseEmoji: .dizzy, skinTones: nil),
+            "💦": EmojiWithSkinTones(baseEmoji: .sweatDrops, skinTones: nil),
+            "💨": EmojiWithSkinTones(baseEmoji: .dash, skinTones: nil),
+            "💬": EmojiWithSkinTones(baseEmoji: .speechBalloon, skinTones: nil),
+            "💭": EmojiWithSkinTones(baseEmoji: .thoughtBalloon, skinTones: nil),
+            "💤": EmojiWithSkinTones(baseEmoji: .zzz, skinTones: nil),
+            "💅": EmojiWithSkinTones(baseEmoji: .nailCare, skinTones: nil),
+            "💪": EmojiWithSkinTones(baseEmoji: .muscle, skinTones: nil),
+            "👶": EmojiWithSkinTones(baseEmoji: .baby, skinTones: nil),
+            "👦": EmojiWithSkinTones(baseEmoji: .boy, skinTones: nil),
+            "👧": EmojiWithSkinTones(baseEmoji: .girl, skinTones: nil),
+            "👱": EmojiWithSkinTones(baseEmoji: .personWithBlondHair, skinTones: nil),
+            "👨": EmojiWithSkinTones(baseEmoji: .man, skinTones: nil),
+            "👩": EmojiWithSkinTones(baseEmoji: .woman, skinTones: nil),
+            "👴": EmojiWithSkinTones(baseEmoji: .olderMan, skinTones: nil),
+            "👵": EmojiWithSkinTones(baseEmoji: .olderWoman, skinTones: nil),
+            "💁": EmojiWithSkinTones(baseEmoji: .informationDeskPerson, skinTones: nil),
+            "👮": EmojiWithSkinTones(baseEmoji: .cop, skinTones: nil),
+            "💂": EmojiWithSkinTones(baseEmoji: .guardsman, skinTones: nil),
+            "👷": EmojiWithSkinTones(baseEmoji: .constructionWorker, skinTones: nil),
+            "👸": EmojiWithSkinTones(baseEmoji: .princess, skinTones: nil),
+            "👳": EmojiWithSkinTones(baseEmoji: .manWithTurban, skinTones: nil),
+            "👲": EmojiWithSkinTones(baseEmoji: .manWithGuaPiMao, skinTones: nil),
+            "👰": EmojiWithSkinTones(baseEmoji: .brideWithVeil, skinTones: nil),
+            "👼": EmojiWithSkinTones(baseEmoji: .angel, skinTones: nil),
+            "💆": EmojiWithSkinTones(baseEmoji: .massage, skinTones: nil),
+            "💇": EmojiWithSkinTones(baseEmoji: .haircut, skinTones: nil),
+            "💃": EmojiWithSkinTones(baseEmoji: .dancer, skinTones: nil),
+            "👯": EmojiWithSkinTones(baseEmoji: .dancers, skinTones: nil),
+            "👭": EmojiWithSkinTones(baseEmoji: .twoWomenHoldingHands, skinTones: nil),
+            "👫": EmojiWithSkinTones(baseEmoji: .manAndWomanHoldingHands, skinTones: nil),
+            "👬": EmojiWithSkinTones(baseEmoji: .twoMenHoldingHands, skinTones: nil),
+            "💏": EmojiWithSkinTones(baseEmoji: .personKissPerson, skinTones: nil),
+            "💑": EmojiWithSkinTones(baseEmoji: .personHeartPerson, skinTones: nil),
+            "👪": EmojiWithSkinTones(baseEmoji: .family, skinTones: nil),
+            "👤": EmojiWithSkinTones(baseEmoji: .bustInSilhouette, skinTones: nil),
+            "👥": EmojiWithSkinTones(baseEmoji: .bustsInSilhouette, skinTones: nil),
+            "💐": EmojiWithSkinTones(baseEmoji: .bouquet, skinTones: nil),
+            "💮": EmojiWithSkinTones(baseEmoji: .whiteFlower, skinTones: nil),
+            "💒": EmojiWithSkinTones(baseEmoji: .wedding, skinTones: nil),
+            "💈": EmojiWithSkinTones(baseEmoji: .barber, skinTones: nil),
+            "💺": EmojiWithSkinTones(baseEmoji: .seat, skinTones: nil),
+            "💧": EmojiWithSkinTones(baseEmoji: .droplet, skinTones: nil),
+            "💄": EmojiWithSkinTones(baseEmoji: .lipstick, skinTones: nil),
+            "💍": EmojiWithSkinTones(baseEmoji: .ring, skinTones: nil),
+            "💎": EmojiWithSkinTones(baseEmoji: .gem, skinTones: nil),
+            "💻": EmojiWithSkinTones(baseEmoji: .computer, skinTones: nil),
+            "💽": EmojiWithSkinTones(baseEmoji: .minidisc, skinTones: nil),
+            "💾": EmojiWithSkinTones(baseEmoji: .floppyDisk, skinTones: nil),
+            "💿": EmojiWithSkinTones(baseEmoji: .cd, skinTones: nil),
+            "📀": EmojiWithSkinTones(baseEmoji: .dvd, skinTones: nil),
+            "💡": EmojiWithSkinTones(baseEmoji: .bulb, skinTones: nil),
+            "📃": EmojiWithSkinTones(baseEmoji: .pageWithCurl, skinTones: nil),
+            "📄": EmojiWithSkinTones(baseEmoji: .pageFacingUp, skinTones: nil),
+            "💰": EmojiWithSkinTones(baseEmoji: .moneybag, skinTones: nil),
+            "💴": EmojiWithSkinTones(baseEmoji: .yen, skinTones: nil),
+            "💵": EmojiWithSkinTones(baseEmoji: .dollar, skinTones: nil),
+            "💶": EmojiWithSkinTones(baseEmoji: .euro, skinTones: nil),
+            "💷": EmojiWithSkinTones(baseEmoji: .pound, skinTones: nil),
+            "💸": EmojiWithSkinTones(baseEmoji: .moneyWithWings, skinTones: nil),
+            "💳": EmojiWithSkinTones(baseEmoji: .creditCard, skinTones: nil),
+            "💹": EmojiWithSkinTones(baseEmoji: .chart, skinTones: nil),
+            "💼": EmojiWithSkinTones(baseEmoji: .briefcase, skinTones: nil),
+            "📁": EmojiWithSkinTones(baseEmoji: .fileFolder, skinTones: nil),
+            "📂": EmojiWithSkinTones(baseEmoji: .openFileFolder, skinTones: nil),
+            "📅": EmojiWithSkinTones(baseEmoji: .date, skinTones: nil),
+            "📆": EmojiWithSkinTones(baseEmoji: .calendar, skinTones: nil),
+            "📇": EmojiWithSkinTones(baseEmoji: .cardIndex, skinTones: nil),
+            "💣": EmojiWithSkinTones(baseEmoji: .bomb, skinTones: nil),
+            "💉": EmojiWithSkinTones(baseEmoji: .syringe, skinTones: nil),
+            "💊": EmojiWithSkinTones(baseEmoji: .pill, skinTones: nil),
+            "💱": EmojiWithSkinTones(baseEmoji: .currencyExchange, skinTones: nil),
+            "💲": EmojiWithSkinTones(baseEmoji: .heavyDollarSign, skinTones: nil),
+            "💠": EmojiWithSkinTones(baseEmoji: .diamondShapeWithADotInside, skinTones: nil)
+        ]
+        return (lookup[rawValue] ?? EmojiWithSkinTones(unsupportedValue: rawValue))
+    }
+    
+    private static func emojiFrom1282(_ rawValue: String) -> EmojiWithSkinTones {
+        let lookup: [String: EmojiWithSkinTones] = [
+            "🔪": EmojiWithSkinTones(baseEmoji: .hocho, skinTones: nil),
+            "🔥": EmojiWithSkinTones(baseEmoji: .fire, skinTones: nil),
+            "🔫": EmojiWithSkinTones(baseEmoji: .gun, skinTones: nil),
+            "📿": EmojiWithSkinTones(baseEmoji: .prayerBeads, skinTones: nil),
+            "🔇": EmojiWithSkinTones(baseEmoji: .mute, skinTones: nil),
+            "🔈": EmojiWithSkinTones(baseEmoji: .speaker, skinTones: nil),
+            "🔉": EmojiWithSkinTones(baseEmoji: .sound, skinTones: nil),
+            "🔊": EmojiWithSkinTones(baseEmoji: .loudSound, skinTones: nil),
+            "📢": EmojiWithSkinTones(baseEmoji: .loudspeaker, skinTones: nil),
+            "📣": EmojiWithSkinTones(baseEmoji: .mega, skinTones: nil),
+            "📯": EmojiWithSkinTones(baseEmoji: .postalHorn, skinTones: nil),
+            "🔔": EmojiWithSkinTones(baseEmoji: .bell, skinTones: nil),
+            "🔕": EmojiWithSkinTones(baseEmoji: .noBell, skinTones: nil),
+            "📻": EmojiWithSkinTones(baseEmoji: .radio, skinTones: nil),
+            "📱": EmojiWithSkinTones(baseEmoji: .iphone, skinTones: nil),
+            "📲": EmojiWithSkinTones(baseEmoji: .calling, skinTones: nil),
+            "📞": EmojiWithSkinTones(baseEmoji: .telephoneReceiver, skinTones: nil),
+            "📟": EmojiWithSkinTones(baseEmoji: .pager, skinTones: nil),
+            "📠": EmojiWithSkinTones(baseEmoji: .fax, skinTones: nil),
+            "🔋": EmojiWithSkinTones(baseEmoji: .battery, skinTones: nil),
+            "🔌": EmojiWithSkinTones(baseEmoji: .electricPlug, skinTones: nil),
+            "📺": EmojiWithSkinTones(baseEmoji: .tv, skinTones: nil),
+            "📷": EmojiWithSkinTones(baseEmoji: .camera, skinTones: nil),
+            "📸": EmojiWithSkinTones(baseEmoji: .cameraWithFlash, skinTones: nil),
+            "📹": EmojiWithSkinTones(baseEmoji: .videoCamera, skinTones: nil),
+            "📼": EmojiWithSkinTones(baseEmoji: .vhs, skinTones: nil),
+            "🔍": EmojiWithSkinTones(baseEmoji: .mag, skinTones: nil),
+            "🔎": EmojiWithSkinTones(baseEmoji: .magRight, skinTones: nil),
+            "🔦": EmojiWithSkinTones(baseEmoji: .flashlight, skinTones: nil),
+            "📔": EmojiWithSkinTones(baseEmoji: .notebookWithDecorativeCover, skinTones: nil),
+            "📕": EmojiWithSkinTones(baseEmoji: .closedBook, skinTones: nil),
+            "📖": EmojiWithSkinTones(baseEmoji: .book, skinTones: nil),
+            "📗": EmojiWithSkinTones(baseEmoji: .greenBook, skinTones: nil),
+            "📘": EmojiWithSkinTones(baseEmoji: .blueBook, skinTones: nil),
+            "📙": EmojiWithSkinTones(baseEmoji: .orangeBook, skinTones: nil),
+            "📚": EmojiWithSkinTones(baseEmoji: .books, skinTones: nil),
+            "📓": EmojiWithSkinTones(baseEmoji: .notebook, skinTones: nil),
+            "📒": EmojiWithSkinTones(baseEmoji: .ledger, skinTones: nil),
+            "📜": EmojiWithSkinTones(baseEmoji: .scroll, skinTones: nil),
+            "📰": EmojiWithSkinTones(baseEmoji: .newspaper, skinTones: nil),
+            "📑": EmojiWithSkinTones(baseEmoji: .bookmarkTabs, skinTones: nil),
+            "🔖": EmojiWithSkinTones(baseEmoji: .bookmark, skinTones: nil),
+            "📧": EmojiWithSkinTones(baseEmoji: .eMail, skinTones: nil),
+            "📨": EmojiWithSkinTones(baseEmoji: .incomingEnvelope, skinTones: nil),
+            "📩": EmojiWithSkinTones(baseEmoji: .envelopeWithArrow, skinTones: nil),
+            "📤": EmojiWithSkinTones(baseEmoji: .outboxTray, skinTones: nil),
+            "📥": EmojiWithSkinTones(baseEmoji: .inboxTray, skinTones: nil),
+            "📦": EmojiWithSkinTones(baseEmoji: .package, skinTones: nil),
+            "📫": EmojiWithSkinTones(baseEmoji: .mailbox, skinTones: nil),
+            "📪": EmojiWithSkinTones(baseEmoji: .mailboxClosed, skinTones: nil),
+            "📬": EmojiWithSkinTones(baseEmoji: .mailboxWithMail, skinTones: nil),
+            "📭": EmojiWithSkinTones(baseEmoji: .mailboxWithNoMail, skinTones: nil),
+            "📮": EmojiWithSkinTones(baseEmoji: .postbox, skinTones: nil),
+            "📝": EmojiWithSkinTones(baseEmoji: .memo, skinTones: nil),
+            "📈": EmojiWithSkinTones(baseEmoji: .chartWithUpwardsTrend, skinTones: nil),
+            "📉": EmojiWithSkinTones(baseEmoji: .chartWithDownwardsTrend, skinTones: nil),
+            "📊": EmojiWithSkinTones(baseEmoji: .barChart, skinTones: nil),
+            "📋": EmojiWithSkinTones(baseEmoji: .clipboard, skinTones: nil),
+            "📌": EmojiWithSkinTones(baseEmoji: .pushpin, skinTones: nil),
+            "📍": EmojiWithSkinTones(baseEmoji: .roundPushpin, skinTones: nil),
+            "📎": EmojiWithSkinTones(baseEmoji: .paperclip, skinTones: nil),
+            "📏": EmojiWithSkinTones(baseEmoji: .straightRuler, skinTones: nil),
+            "📐": EmojiWithSkinTones(baseEmoji: .triangularRuler, skinTones: nil),
+            "🔒": EmojiWithSkinTones(baseEmoji: .lock, skinTones: nil),
+            "🔓": EmojiWithSkinTones(baseEmoji: .unlock, skinTones: nil),
+            "🔏": EmojiWithSkinTones(baseEmoji: .lockWithInkPen, skinTones: nil),
+            "🔐": EmojiWithSkinTones(baseEmoji: .closedLockWithKey, skinTones: nil),
+            "🔑": EmojiWithSkinTones(baseEmoji: .key, skinTones: nil),
+            "🔨": EmojiWithSkinTones(baseEmoji: .hammer, skinTones: nil),
+            "🔧": EmojiWithSkinTones(baseEmoji: .wrench, skinTones: nil),
+            "🔩": EmojiWithSkinTones(baseEmoji: .nutAndBolt, skinTones: nil),
+            "🔗": EmojiWithSkinTones(baseEmoji: .link, skinTones: nil),
+            "📡": EmojiWithSkinTones(baseEmoji: .satelliteAntenna, skinTones: nil),
+            "📵": EmojiWithSkinTones(baseEmoji: .noMobilePhones, skinTones: nil),
+            "🔞": EmojiWithSkinTones(baseEmoji: .underage, skinTones: nil),
+            "🔃": EmojiWithSkinTones(baseEmoji: .arrowsClockwise, skinTones: nil),
+            "🔄": EmojiWithSkinTones(baseEmoji: .arrowsCounterclockwise, skinTones: nil),
+            "🔙": EmojiWithSkinTones(baseEmoji: .back, skinTones: nil),
+            "🔚": EmojiWithSkinTones(baseEmoji: .end, skinTones: nil),
+            "🔛": EmojiWithSkinTones(baseEmoji: .on, skinTones: nil),
+            "🔜": EmojiWithSkinTones(baseEmoji: .soon, skinTones: nil),
+            "🔝": EmojiWithSkinTones(baseEmoji: .top, skinTones: nil),
+            "🔀": EmojiWithSkinTones(baseEmoji: .twistedRightwardsArrows, skinTones: nil),
+            "🔁": EmojiWithSkinTones(baseEmoji: .`repeat`, skinTones: nil),
+            "🔂": EmojiWithSkinTones(baseEmoji: .repeatOne, skinTones: nil),
+            "🔅": EmojiWithSkinTones(baseEmoji: .lowBrightness, skinTones: nil),
+            "🔆": EmojiWithSkinTones(baseEmoji: .highBrightness, skinTones: nil),
+            "📶": EmojiWithSkinTones(baseEmoji: .signalStrength, skinTones: nil),
+            "📳": EmojiWithSkinTones(baseEmoji: .vibrationMode, skinTones: nil),
+            "📴": EmojiWithSkinTones(baseEmoji: .mobilePhoneOff, skinTones: nil),
+            "📛": EmojiWithSkinTones(baseEmoji: .nameBadge, skinTones: nil),
+            "🔟": EmojiWithSkinTones(baseEmoji: .keycapTen, skinTones: nil),
+            "🔠": EmojiWithSkinTones(baseEmoji: .capitalAbcd, skinTones: nil),
+            "🔡": EmojiWithSkinTones(baseEmoji: .abcd, skinTones: nil),
+            "🔢": EmojiWithSkinTones(baseEmoji: .oneTwoThreeFour, skinTones: nil),
+            "🔣": EmojiWithSkinTones(baseEmoji: .symbols, skinTones: nil),
+            "🔤": EmojiWithSkinTones(baseEmoji: .abc, skinTones: nil),
+            "🔘": EmojiWithSkinTones(baseEmoji: .radioButton, skinTones: nil)
+        ]
+        return (lookup[rawValue] ?? EmojiWithSkinTones(unsupportedValue: rawValue))
+    }
+    
+    private static func emojiFrom1283(_ rawValue: String) -> EmojiWithSkinTones {
+        let lookup: [String: EmojiWithSkinTones] = [
+            "🕺": EmojiWithSkinTones(baseEmoji: .manDancing, skinTones: nil),
+            "🕌": EmojiWithSkinTones(baseEmoji: .mosque, skinTones: nil),
+            "🕍": EmojiWithSkinTones(baseEmoji: .synagogue, skinTones: nil),
+            "🕋": EmojiWithSkinTones(baseEmoji: .kaaba, skinTones: nil),
+            "🕛": EmojiWithSkinTones(baseEmoji: .clock12, skinTones: nil),
+            "🕧": EmojiWithSkinTones(baseEmoji: .clock1230, skinTones: nil),
+            "🕐": EmojiWithSkinTones(baseEmoji: .clock1, skinTones: nil),
+            "🕜": EmojiWithSkinTones(baseEmoji: .clock130, skinTones: nil),
+            "🕑": EmojiWithSkinTones(baseEmoji: .clock2, skinTones: nil),
+            "🕝": EmojiWithSkinTones(baseEmoji: .clock230, skinTones: nil),
+            "🕒": EmojiWithSkinTones(baseEmoji: .clock3, skinTones: nil),
+            "🕞": EmojiWithSkinTones(baseEmoji: .clock330, skinTones: nil),
+            "🕓": EmojiWithSkinTones(baseEmoji: .clock4, skinTones: nil),
+            "🕟": EmojiWithSkinTones(baseEmoji: .clock430, skinTones: nil),
+            "🕔": EmojiWithSkinTones(baseEmoji: .clock5, skinTones: nil),
+            "🕠": EmojiWithSkinTones(baseEmoji: .clock530, skinTones: nil),
+            "🕕": EmojiWithSkinTones(baseEmoji: .clock6, skinTones: nil),
+            "🕡": EmojiWithSkinTones(baseEmoji: .clock630, skinTones: nil),
+            "🕖": EmojiWithSkinTones(baseEmoji: .clock7, skinTones: nil),
+            "🕢": EmojiWithSkinTones(baseEmoji: .clock730, skinTones: nil),
+            "🕗": EmojiWithSkinTones(baseEmoji: .clock8, skinTones: nil),
+            "🕣": EmojiWithSkinTones(baseEmoji: .clock830, skinTones: nil),
+            "🕘": EmojiWithSkinTones(baseEmoji: .clock9, skinTones: nil),
+            "🕤": EmojiWithSkinTones(baseEmoji: .clock930, skinTones: nil),
+            "🕙": EmojiWithSkinTones(baseEmoji: .clock10, skinTones: nil),
+            "🕥": EmojiWithSkinTones(baseEmoji: .clock1030, skinTones: nil),
+            "🕚": EmojiWithSkinTones(baseEmoji: .clock11, skinTones: nil),
+            "🕦": EmojiWithSkinTones(baseEmoji: .clock1130, skinTones: nil),
+            "🔮": EmojiWithSkinTones(baseEmoji: .crystalBall, skinTones: nil),
+            "🔬": EmojiWithSkinTones(baseEmoji: .microscope, skinTones: nil),
+            "🔭": EmojiWithSkinTones(baseEmoji: .telescope, skinTones: nil),
+            "🕎": EmojiWithSkinTones(baseEmoji: .menorahWithNineBranches, skinTones: nil),
+            "🔯": EmojiWithSkinTones(baseEmoji: .sixPointedStar, skinTones: nil),
+            "🔼": EmojiWithSkinTones(baseEmoji: .arrowUpSmall, skinTones: nil),
+            "🔽": EmojiWithSkinTones(baseEmoji: .arrowDownSmall, skinTones: nil),
+            "🔱": EmojiWithSkinTones(baseEmoji: .trident, skinTones: nil),
+            "🔰": EmojiWithSkinTones(baseEmoji: .beginner, skinTones: nil),
+            "🔴": EmojiWithSkinTones(baseEmoji: .redCircle, skinTones: nil),
+            "🔵": EmojiWithSkinTones(baseEmoji: .largeBlueCircle, skinTones: nil),
+            "🔶": EmojiWithSkinTones(baseEmoji: .largeOrangeDiamond, skinTones: nil),
+            "🔷": EmojiWithSkinTones(baseEmoji: .largeBlueDiamond, skinTones: nil),
+            "🔸": EmojiWithSkinTones(baseEmoji: .smallOrangeDiamond, skinTones: nil),
+            "🔹": EmojiWithSkinTones(baseEmoji: .smallBlueDiamond, skinTones: nil),
+            "🔺": EmojiWithSkinTones(baseEmoji: .smallRedTriangle, skinTones: nil),
+            "🔻": EmojiWithSkinTones(baseEmoji: .smallRedTriangleDown, skinTones: nil),
+            "🔳": EmojiWithSkinTones(baseEmoji: .whiteSquareButton, skinTones: nil),
+            "🔲": EmojiWithSkinTones(baseEmoji: .blackSquareButton, skinTones: nil)
+        ]
+        return (lookup[rawValue] ?? EmojiWithSkinTones(unsupportedValue: rawValue))
+    }
+    
+    private static func emojiFrom1284(_ rawValue: String) -> EmojiWithSkinTones {
+        let lookup: [String: EmojiWithSkinTones] = [
+            "🖤": EmojiWithSkinTones(baseEmoji: .blackHeart, skinTones: nil),
+            "🖖": EmojiWithSkinTones(baseEmoji: .spockHand, skinTones: nil),
+            "🖕": EmojiWithSkinTones(baseEmoji: .middleFinger, skinTones: nil)
+        ]
+        return (lookup[rawValue] ?? EmojiWithSkinTones(unsupportedValue: rawValue))
+    }
+    
+    private static func emojiFrom1285(_ rawValue: String) -> EmojiWithSkinTones {
+        let lookup: [String: EmojiWithSkinTones] = [
+            "😀": EmojiWithSkinTones(baseEmoji: .grinning, skinTones: nil),
+            "😃": EmojiWithSkinTones(baseEmoji: .smiley, skinTones: nil),
+            "😄": EmojiWithSkinTones(baseEmoji: .smile, skinTones: nil),
+            "😁": EmojiWithSkinTones(baseEmoji: .grin, skinTones: nil),
+            "😆": EmojiWithSkinTones(baseEmoji: .laughing, skinTones: nil),
+            "😅": EmojiWithSkinTones(baseEmoji: .sweatSmile, skinTones: nil),
+            "😂": EmojiWithSkinTones(baseEmoji: .joy, skinTones: nil),
+            "🙂": EmojiWithSkinTones(baseEmoji: .slightlySmilingFace, skinTones: nil),
+            "🙃": EmojiWithSkinTones(baseEmoji: .upsideDownFace, skinTones: nil),
+            "😉": EmojiWithSkinTones(baseEmoji: .wink, skinTones: nil),
+            "😊": EmojiWithSkinTones(baseEmoji: .blush, skinTones: nil),
+            "😇": EmojiWithSkinTones(baseEmoji: .innocent, skinTones: nil),
+            "😍": EmojiWithSkinTones(baseEmoji: .heartEyes, skinTones: nil),
+            "😘": EmojiWithSkinTones(baseEmoji: .kissingHeart, skinTones: nil),
+            "😗": EmojiWithSkinTones(baseEmoji: .kissing, skinTones: nil),
+            "😚": EmojiWithSkinTones(baseEmoji: .kissingClosedEyes, skinTones: nil),
+            "😙": EmojiWithSkinTones(baseEmoji: .kissingSmilingEyes, skinTones: nil),
+            "😋": EmojiWithSkinTones(baseEmoji: .yum, skinTones: nil),
+            "😛": EmojiWithSkinTones(baseEmoji: .stuckOutTongue, skinTones: nil),
+            "😜": EmojiWithSkinTones(baseEmoji: .stuckOutTongueWinkingEye, skinTones: nil),
+            "😝": EmojiWithSkinTones(baseEmoji: .stuckOutTongueClosedEyes, skinTones: nil),
+            "😐": EmojiWithSkinTones(baseEmoji: .neutralFace, skinTones: nil),
+            "😑": EmojiWithSkinTones(baseEmoji: .expressionless, skinTones: nil),
+            "😶": EmojiWithSkinTones(baseEmoji: .noMouth, skinTones: nil),
+            "😏": EmojiWithSkinTones(baseEmoji: .smirk, skinTones: nil),
+            "😒": EmojiWithSkinTones(baseEmoji: .unamused, skinTones: nil),
+            "🙄": EmojiWithSkinTones(baseEmoji: .faceWithRollingEyes, skinTones: nil),
+            "😬": EmojiWithSkinTones(baseEmoji: .grimacing, skinTones: nil),
+            "😌": EmojiWithSkinTones(baseEmoji: .relieved, skinTones: nil),
+            "😔": EmojiWithSkinTones(baseEmoji: .pensive, skinTones: nil),
+            "😪": EmojiWithSkinTones(baseEmoji: .sleepy, skinTones: nil),
+            "😴": EmojiWithSkinTones(baseEmoji: .sleeping, skinTones: nil),
+            "😷": EmojiWithSkinTones(baseEmoji: .mask, skinTones: nil),
+            "😵": EmojiWithSkinTones(baseEmoji: .dizzyFace, skinTones: nil),
+            "😎": EmojiWithSkinTones(baseEmoji: .sunglasses, skinTones: nil),
+            "😕": EmojiWithSkinTones(baseEmoji: .confused, skinTones: nil),
+            "😟": EmojiWithSkinTones(baseEmoji: .worried, skinTones: nil),
+            "🙁": EmojiWithSkinTones(baseEmoji: .slightlyFrowningFace, skinTones: nil),
+            "😮": EmojiWithSkinTones(baseEmoji: .openMouth, skinTones: nil),
+            "😯": EmojiWithSkinTones(baseEmoji: .hushed, skinTones: nil),
+            "😲": EmojiWithSkinTones(baseEmoji: .astonished, skinTones: nil),
+            "😳": EmojiWithSkinTones(baseEmoji: .flushed, skinTones: nil),
+            "😦": EmojiWithSkinTones(baseEmoji: .frowning, skinTones: nil),
+            "😧": EmojiWithSkinTones(baseEmoji: .anguished, skinTones: nil),
+            "😨": EmojiWithSkinTones(baseEmoji: .fearful, skinTones: nil),
+            "😰": EmojiWithSkinTones(baseEmoji: .coldSweat, skinTones: nil),
+            "😥": EmojiWithSkinTones(baseEmoji: .disappointedRelieved, skinTones: nil),
+            "😢": EmojiWithSkinTones(baseEmoji: .cry, skinTones: nil),
+            "😭": EmojiWithSkinTones(baseEmoji: .sob, skinTones: nil),
+            "😱": EmojiWithSkinTones(baseEmoji: .scream, skinTones: nil),
+            "😖": EmojiWithSkinTones(baseEmoji: .confounded, skinTones: nil),
+            "😣": EmojiWithSkinTones(baseEmoji: .persevere, skinTones: nil),
+            "😞": EmojiWithSkinTones(baseEmoji: .disappointed, skinTones: nil),
+            "😓": EmojiWithSkinTones(baseEmoji: .sweat, skinTones: nil),
+            "😩": EmojiWithSkinTones(baseEmoji: .weary, skinTones: nil),
+            "😫": EmojiWithSkinTones(baseEmoji: .tiredFace, skinTones: nil),
+            "😤": EmojiWithSkinTones(baseEmoji: .triumph, skinTones: nil),
+            "😡": EmojiWithSkinTones(baseEmoji: .rage, skinTones: nil),
+            "😠": EmojiWithSkinTones(baseEmoji: .angry, skinTones: nil),
+            "😈": EmojiWithSkinTones(baseEmoji: .smilingImp, skinTones: nil),
+            "😺": EmojiWithSkinTones(baseEmoji: .smileyCat, skinTones: nil),
+            "😸": EmojiWithSkinTones(baseEmoji: .smileCat, skinTones: nil),
+            "😹": EmojiWithSkinTones(baseEmoji: .joyCat, skinTones: nil),
+            "😻": EmojiWithSkinTones(baseEmoji: .heartEyesCat, skinTones: nil),
+            "😼": EmojiWithSkinTones(baseEmoji: .smirkCat, skinTones: nil),
+            "😽": EmojiWithSkinTones(baseEmoji: .kissingCat, skinTones: nil),
+            "🙀": EmojiWithSkinTones(baseEmoji: .screamCat, skinTones: nil),
+            "😿": EmojiWithSkinTones(baseEmoji: .cryingCatFace, skinTones: nil),
+            "😾": EmojiWithSkinTones(baseEmoji: .poutingCat, skinTones: nil),
+            "🙈": EmojiWithSkinTones(baseEmoji: .seeNoEvil, skinTones: nil),
+            "🙉": EmojiWithSkinTones(baseEmoji: .hearNoEvil, skinTones: nil),
+            "🙊": EmojiWithSkinTones(baseEmoji: .speakNoEvil, skinTones: nil),
+            "🙌": EmojiWithSkinTones(baseEmoji: .raisedHands, skinTones: nil),
+            "🙏": EmojiWithSkinTones(baseEmoji: .pray, skinTones: nil),
+            "🙍": EmojiWithSkinTones(baseEmoji: .personFrowning, skinTones: nil),
+            "🙎": EmojiWithSkinTones(baseEmoji: .personWithPoutingFace, skinTones: nil),
+            "🙅": EmojiWithSkinTones(baseEmoji: .noGood, skinTones: nil),
+            "🙆": EmojiWithSkinTones(baseEmoji: .okWoman, skinTones: nil),
+            "🙋": EmojiWithSkinTones(baseEmoji: .raisingHand, skinTones: nil),
+            "🙇": EmojiWithSkinTones(baseEmoji: .bow, skinTones: nil),
+            "🗾": EmojiWithSkinTones(baseEmoji: .japan, skinTones: nil),
+            "🗻": EmojiWithSkinTones(baseEmoji: .mountFuji, skinTones: nil),
+            "🗼": EmojiWithSkinTones(baseEmoji: .tokyoTower, skinTones: nil),
+            "🗽": EmojiWithSkinTones(baseEmoji: .statueOfLiberty, skinTones: nil),
+            "🗿": EmojiWithSkinTones(baseEmoji: .moyai, skinTones: nil)
+        ]
+        return (lookup[rawValue] ?? EmojiWithSkinTones(unsupportedValue: rawValue))
+    }
+    
+    private static func emojiFrom1286(_ rawValue: String) -> EmojiWithSkinTones {
+        let lookup: [String: EmojiWithSkinTones] = [
+            "🚶": EmojiWithSkinTones(baseEmoji: .walking, skinTones: nil),
+            "🚣": EmojiWithSkinTones(baseEmoji: .rowboat, skinTones: nil),
+            "🚴": EmojiWithSkinTones(baseEmoji: .bicyclist, skinTones: nil),
+            "🚵": EmojiWithSkinTones(baseEmoji: .mountainBicyclist, skinTones: nil),
+            "🚂": EmojiWithSkinTones(baseEmoji: .steamLocomotive, skinTones: nil),
+            "🚃": EmojiWithSkinTones(baseEmoji: .railwayCar, skinTones: nil),
+            "🚄": EmojiWithSkinTones(baseEmoji: .bullettrainSide, skinTones: nil),
+            "🚅": EmojiWithSkinTones(baseEmoji: .bullettrainFront, skinTones: nil),
+            "🚆": EmojiWithSkinTones(baseEmoji: .train2, skinTones: nil),
+            "🚇": EmojiWithSkinTones(baseEmoji: .metro, skinTones: nil),
+            "🚈": EmojiWithSkinTones(baseEmoji: .lightRail, skinTones: nil),
+            "🚉": EmojiWithSkinTones(baseEmoji: .station, skinTones: nil),
+            "🚊": EmojiWithSkinTones(baseEmoji: .tram, skinTones: nil),
+            "🚝": EmojiWithSkinTones(baseEmoji: .monorail, skinTones: nil),
+            "🚞": EmojiWithSkinTones(baseEmoji: .mountainRailway, skinTones: nil),
+            "🚋": EmojiWithSkinTones(baseEmoji: .train, skinTones: nil),
+            "🚌": EmojiWithSkinTones(baseEmoji: .bus, skinTones: nil),
+            "🚍": EmojiWithSkinTones(baseEmoji: .oncomingBus, skinTones: nil),
+            "🚎": EmojiWithSkinTones(baseEmoji: .trolleybus, skinTones: nil),
+            "🚐": EmojiWithSkinTones(baseEmoji: .minibus, skinTones: nil),
+            "🚑": EmojiWithSkinTones(baseEmoji: .ambulance, skinTones: nil),
+            "🚒": EmojiWithSkinTones(baseEmoji: .fireEngine, skinTones: nil),
+            "🚓": EmojiWithSkinTones(baseEmoji: .policeCar, skinTones: nil),
+            "🚔": EmojiWithSkinTones(baseEmoji: .oncomingPoliceCar, skinTones: nil),
+            "🚕": EmojiWithSkinTones(baseEmoji: .taxi, skinTones: nil),
+            "🚖": EmojiWithSkinTones(baseEmoji: .oncomingTaxi, skinTones: nil),
+            "🚗": EmojiWithSkinTones(baseEmoji: .car, skinTones: nil),
+            "🚘": EmojiWithSkinTones(baseEmoji: .oncomingAutomobile, skinTones: nil),
+            "🚙": EmojiWithSkinTones(baseEmoji: .blueCar, skinTones: nil),
+            "🚚": EmojiWithSkinTones(baseEmoji: .truck, skinTones: nil),
+            "🚛": EmojiWithSkinTones(baseEmoji: .articulatedLorry, skinTones: nil),
+            "🚜": EmojiWithSkinTones(baseEmoji: .tractor, skinTones: nil),
+            "🚲": EmojiWithSkinTones(baseEmoji: .bike, skinTones: nil),
+            "🚏": EmojiWithSkinTones(baseEmoji: .busstop, skinTones: nil),
+            "🚨": EmojiWithSkinTones(baseEmoji: .rotatingLight, skinTones: nil),
+            "🚥": EmojiWithSkinTones(baseEmoji: .trafficLight, skinTones: nil),
+            "🚦": EmojiWithSkinTones(baseEmoji: .verticalTrafficLight, skinTones: nil),
+            "🚧": EmojiWithSkinTones(baseEmoji: .construction, skinTones: nil),
+            "🚤": EmojiWithSkinTones(baseEmoji: .speedboat, skinTones: nil),
+            "🚢": EmojiWithSkinTones(baseEmoji: .ship, skinTones: nil),
+            "🚁": EmojiWithSkinTones(baseEmoji: .helicopter, skinTones: nil),
+            "🚟": EmojiWithSkinTones(baseEmoji: .suspensionRailway, skinTones: nil),
+            "🚠": EmojiWithSkinTones(baseEmoji: .mountainCableway, skinTones: nil),
+            "🚡": EmojiWithSkinTones(baseEmoji: .aerialTramway, skinTones: nil),
+            "🚀": EmojiWithSkinTones(baseEmoji: .rocket, skinTones: nil),
+            "🚪": EmojiWithSkinTones(baseEmoji: .door, skinTones: nil),
+            "🚬": EmojiWithSkinTones(baseEmoji: .smoking, skinTones: nil),
+            "🚮": EmojiWithSkinTones(baseEmoji: .putLitterInItsPlace, skinTones: nil),
+            "🚰": EmojiWithSkinTones(baseEmoji: .potableWater, skinTones: nil),
+            "🚹": EmojiWithSkinTones(baseEmoji: .mens, skinTones: nil),
+            "🚺": EmojiWithSkinTones(baseEmoji: .womens, skinTones: nil),
+            "🚻": EmojiWithSkinTones(baseEmoji: .restroom, skinTones: nil),
+            "🚸": EmojiWithSkinTones(baseEmoji: .childrenCrossing, skinTones: nil),
+            "🚫": EmojiWithSkinTones(baseEmoji: .noEntrySign, skinTones: nil),
+            "🚳": EmojiWithSkinTones(baseEmoji: .noBicycles, skinTones: nil),
+            "🚭": EmojiWithSkinTones(baseEmoji: .noSmoking, skinTones: nil),
+            "🚯": EmojiWithSkinTones(baseEmoji: .doNotLitter, skinTones: nil),
+            "🚱": EmojiWithSkinTones(baseEmoji: .nonPotableWater, skinTones: nil),
+            "🚷": EmojiWithSkinTones(baseEmoji: .noPedestrians, skinTones: nil),
+            "🚩": EmojiWithSkinTones(baseEmoji: .triangularFlagOnPost, skinTones: nil)
+        ]
+        return (lookup[rawValue] ?? EmojiWithSkinTones(unsupportedValue: rawValue))
+    }
+    
+    private static func emojiFrom1287(_ rawValue: String) -> EmojiWithSkinTones {
+        let lookup: [String: EmojiWithSkinTones] = [
+            "🛀": EmojiWithSkinTones(baseEmoji: .bath, skinTones: nil),
+            "🛌": EmojiWithSkinTones(baseEmoji: .sleepingAccommodation, skinTones: nil),
+            "🛖": EmojiWithSkinTones(baseEmoji: .hut, skinTones: nil),
+            "🛕": EmojiWithSkinTones(baseEmoji: .hinduTemple, skinTones: nil),
+            "🛝": EmojiWithSkinTones(baseEmoji: .playgroundSlide, skinTones: nil),
+            "🛻": EmojiWithSkinTones(baseEmoji: .pickupTruck, skinTones: nil),
+            "🛵": EmojiWithSkinTones(baseEmoji: .motorScooter, skinTones: nil),
+            "🛺": EmojiWithSkinTones(baseEmoji: .autoRickshaw, skinTones: nil),
+            "🛴": EmojiWithSkinTones(baseEmoji: .scooter, skinTones: nil),
+            "🛹": EmojiWithSkinTones(baseEmoji: .skateboard, skinTones: nil),
+            "🛼": EmojiWithSkinTones(baseEmoji: .rollerSkate, skinTones: nil),
+            "🛞": EmojiWithSkinTones(baseEmoji: .wheel, skinTones: nil),
+            "🛑": EmojiWithSkinTones(baseEmoji: .octagonalSign, skinTones: nil),
+            "🛟": EmojiWithSkinTones(baseEmoji: .ringBuoy, skinTones: nil),
+            "🛶": EmojiWithSkinTones(baseEmoji: .canoe, skinTones: nil),
+            "🛫": EmojiWithSkinTones(baseEmoji: .airplaneDeparture, skinTones: nil),
+            "🛬": EmojiWithSkinTones(baseEmoji: .airplaneArriving, skinTones: nil),
+            "🛸": EmojiWithSkinTones(baseEmoji: .flyingSaucer, skinTones: nil),
+            "🛷": EmojiWithSkinTones(baseEmoji: .sled, skinTones: nil),
+            "🛗": EmojiWithSkinTones(baseEmoji: .elevator, skinTones: nil),
+            "🚽": EmojiWithSkinTones(baseEmoji: .toilet, skinTones: nil),
+            "🚿": EmojiWithSkinTones(baseEmoji: .shower, skinTones: nil),
+            "🛁": EmojiWithSkinTones(baseEmoji: .bathtub, skinTones: nil),
+            "🛒": EmojiWithSkinTones(baseEmoji: .shoppingTrolley, skinTones: nil),
+            "🚼": EmojiWithSkinTones(baseEmoji: .babySymbol, skinTones: nil),
+            "🚾": EmojiWithSkinTones(baseEmoji: .wc, skinTones: nil),
+            "🛂": EmojiWithSkinTones(baseEmoji: .passportControl, skinTones: nil),
+            "🛃": EmojiWithSkinTones(baseEmoji: .customs, skinTones: nil),
+            "🛄": EmojiWithSkinTones(baseEmoji: .baggageClaim, skinTones: nil),
+            "🛅": EmojiWithSkinTones(baseEmoji: .leftLuggage, skinTones: nil),
+            "🛐": EmojiWithSkinTones(baseEmoji: .placeOfWorship, skinTones: nil),
+            "🛜": EmojiWithSkinTones(baseEmoji: .wireless, skinTones: nil)
+        ]
+        return (lookup[rawValue] ?? EmojiWithSkinTones(unsupportedValue: rawValue))
+    }
+    
+    private static func emojiFrom1289(_ rawValue: String) -> EmojiWithSkinTones {
+        let lookup: [String: EmojiWithSkinTones] = [
+            "🟠": EmojiWithSkinTones(baseEmoji: .largeOrangeCircle, skinTones: nil),
+            "🟡": EmojiWithSkinTones(baseEmoji: .largeYellowCircle, skinTones: nil),
+            "🟢": EmojiWithSkinTones(baseEmoji: .largeGreenCircle, skinTones: nil),
+            "🟣": EmojiWithSkinTones(baseEmoji: .largePurpleCircle, skinTones: nil),
+            "🟤": EmojiWithSkinTones(baseEmoji: .largeBrownCircle, skinTones: nil),
+            "🟥": EmojiWithSkinTones(baseEmoji: .largeRedSquare, skinTones: nil),
+            "🟧": EmojiWithSkinTones(baseEmoji: .largeOrangeSquare, skinTones: nil),
+            "🟦": EmojiWithSkinTones(baseEmoji: .largeBlueSquare, skinTones: nil)
+        ]
+        return (lookup[rawValue] ?? EmojiWithSkinTones(unsupportedValue: rawValue))
+    }
+    
+    private static func emojiFrom1290(_ rawValue: String) -> EmojiWithSkinTones {
+        let lookup: [String: EmojiWithSkinTones] = [
+            "🟰": EmojiWithSkinTones(baseEmoji: .heavyEqualsSign, skinTones: nil),
+            "🟨": EmojiWithSkinTones(baseEmoji: .largeYellowSquare, skinTones: nil),
+            "🟩": EmojiWithSkinTones(baseEmoji: .largeGreenSquare, skinTones: nil),
+            "🟪": EmojiWithSkinTones(baseEmoji: .largePurpleSquare, skinTones: nil),
+            "🟫": EmojiWithSkinTones(baseEmoji: .largeBrownSquare, skinTones: nil)
+        ]
+        return (lookup[rawValue] ?? EmojiWithSkinTones(unsupportedValue: rawValue))
+    }
+    
+    private static func emojiFrom1292(_ rawValue: String) -> EmojiWithSkinTones {
+        let lookup: [String: EmojiWithSkinTones] = [
+            "🤑": EmojiWithSkinTones(baseEmoji: .moneyMouthFace, skinTones: nil),
+            "🤐": EmojiWithSkinTones(baseEmoji: .zipperMouthFace, skinTones: nil),
+            "🤒": EmojiWithSkinTones(baseEmoji: .faceWithThermometer, skinTones: nil),
+            "🤓": EmojiWithSkinTones(baseEmoji: .nerdFace, skinTones: nil),
+            "🤎": EmojiWithSkinTones(baseEmoji: .brownHeart, skinTones: nil),
+            "🤍": EmojiWithSkinTones(baseEmoji: .whiteHeart, skinTones: nil),
+            "🤌": EmojiWithSkinTones(baseEmoji: .pinchedFingers, skinTones: nil),
+            "🤏": EmojiWithSkinTones(baseEmoji: .pinchingHand, skinTones: nil)
+        ]
+        return (lookup[rawValue] ?? EmojiWithSkinTones(unsupportedValue: rawValue))
+    }
+    
+    private static func emojiFrom1293(_ rawValue: String) -> EmojiWithSkinTones {
+        let lookup: [String: EmojiWithSkinTones] = [
+            "🤣": EmojiWithSkinTones(baseEmoji: .rollingOnTheFloorLaughing, skinTones: nil),
+            "🥰": EmojiWithSkinTones(baseEmoji: .smilingFaceWith3Hearts, skinTones: nil),
+            "🤩": EmojiWithSkinTones(baseEmoji: .starStruck, skinTones: nil),
+            "🥲": EmojiWithSkinTones(baseEmoji: .smilingFaceWithTear, skinTones: nil),
+            "🤪": EmojiWithSkinTones(baseEmoji: .zanyFace, skinTones: nil),
+            "🤗": EmojiWithSkinTones(baseEmoji: .huggingFace, skinTones: nil),
+            "🤭": EmojiWithSkinTones(baseEmoji: .faceWithHandOverMouth, skinTones: nil),
+            "🤫": EmojiWithSkinTones(baseEmoji: .shushingFace, skinTones: nil),
+            "🤔": EmojiWithSkinTones(baseEmoji: .thinkingFace, skinTones: nil),
+            "🤨": EmojiWithSkinTones(baseEmoji: .faceWithRaisedEyebrow, skinTones: nil),
+            "🤥": EmojiWithSkinTones(baseEmoji: .lyingFace, skinTones: nil),
+            "🤤": EmojiWithSkinTones(baseEmoji: .droolingFace, skinTones: nil),
+            "🤕": EmojiWithSkinTones(baseEmoji: .faceWithHeadBandage, skinTones: nil),
+            "🤢": EmojiWithSkinTones(baseEmoji: .nauseatedFace, skinTones: nil),
+            "🤮": EmojiWithSkinTones(baseEmoji: .faceVomiting, skinTones: nil),
+            "🤧": EmojiWithSkinTones(baseEmoji: .sneezingFace, skinTones: nil),
+            "🥵": EmojiWithSkinTones(baseEmoji: .hotFace, skinTones: nil),
+            "🥶": EmojiWithSkinTones(baseEmoji: .coldFace, skinTones: nil),
+            "🥴": EmojiWithSkinTones(baseEmoji: .woozyFace, skinTones: nil),
+            "🤯": EmojiWithSkinTones(baseEmoji: .explodingHead, skinTones: nil),
+            "🤠": EmojiWithSkinTones(baseEmoji: .faceWithCowboyHat, skinTones: nil),
+            "🥳": EmojiWithSkinTones(baseEmoji: .partyingFace, skinTones: nil),
+            "🥱": EmojiWithSkinTones(baseEmoji: .yawningFace, skinTones: nil),
+            "🤬": EmojiWithSkinTones(baseEmoji: .faceWithSymbolsOnMouth, skinTones: nil),
+            "🤡": EmojiWithSkinTones(baseEmoji: .clownFace, skinTones: nil),
+            "🤖": EmojiWithSkinTones(baseEmoji: .robotFace, skinTones: nil),
+            "🤚": EmojiWithSkinTones(baseEmoji: .raisedBackOfHand, skinTones: nil),
+            "🤞": EmojiWithSkinTones(baseEmoji: .crossedFingers, skinTones: nil),
+            "🤟": EmojiWithSkinTones(baseEmoji: .iLoveYouHandSign, skinTones: nil),
+            "🤘": EmojiWithSkinTones(baseEmoji: .theHorns, skinTones: nil),
+            "🤙": EmojiWithSkinTones(baseEmoji: .callMeHand, skinTones: nil),
+            "🤛": EmojiWithSkinTones(baseEmoji: .leftFacingFist, skinTones: nil),
+            "🤜": EmojiWithSkinTones(baseEmoji: .rightFacingFist, skinTones: nil),
+            "🤲": EmojiWithSkinTones(baseEmoji: .palmsUpTogether, skinTones: nil),
+            "🤝": EmojiWithSkinTones(baseEmoji: .handshake, skinTones: nil),
+            "🤳": EmojiWithSkinTones(baseEmoji: .selfie, skinTones: nil),
+            "🤦": EmojiWithSkinTones(baseEmoji: .facePalm, skinTones: nil),
+            "🤷": EmojiWithSkinTones(baseEmoji: .shrug, skinTones: nil),
+            "🥷": EmojiWithSkinTones(baseEmoji: .ninja, skinTones: nil),
+            "🤴": EmojiWithSkinTones(baseEmoji: .prince, skinTones: nil),
+            "🤵": EmojiWithSkinTones(baseEmoji: .personInTuxedo, skinTones: nil),
+            "🤰": EmojiWithSkinTones(baseEmoji: .pregnantWoman, skinTones: nil),
+            "🤱": EmojiWithSkinTones(baseEmoji: .breastFeeding, skinTones: nil),
+            "🤶": EmojiWithSkinTones(baseEmoji: .mrsClaus, skinTones: nil),
+            "🤺": EmojiWithSkinTones(baseEmoji: .fencer, skinTones: nil),
+            "🤸": EmojiWithSkinTones(baseEmoji: .personDoingCartwheel, skinTones: nil),
+            "🤼": EmojiWithSkinTones(baseEmoji: .wrestlers, skinTones: nil),
+            "🤽": EmojiWithSkinTones(baseEmoji: .waterPolo, skinTones: nil),
+            "🤾": EmojiWithSkinTones(baseEmoji: .handball, skinTones: nil),
+            "🤹": EmojiWithSkinTones(baseEmoji: .juggling, skinTones: nil),
+            "🥀": EmojiWithSkinTones(baseEmoji: .wiltedFlower, skinTones: nil),
+            "🥭": EmojiWithSkinTones(baseEmoji: .mango, skinTones: nil),
+            "🥝": EmojiWithSkinTones(baseEmoji: .kiwifruit, skinTones: nil),
+            "🥥": EmojiWithSkinTones(baseEmoji: .coconut, skinTones: nil),
+            "🥑": EmojiWithSkinTones(baseEmoji: .avocado, skinTones: nil),
+            "🥔": EmojiWithSkinTones(baseEmoji: .potato, skinTones: nil),
+            "🥕": EmojiWithSkinTones(baseEmoji: .carrot, skinTones: nil),
+            "🥒": EmojiWithSkinTones(baseEmoji: .cucumber, skinTones: nil),
+            "🥬": EmojiWithSkinTones(baseEmoji: .leafyGreen, skinTones: nil),
+            "🥦": EmojiWithSkinTones(baseEmoji: .broccoli, skinTones: nil),
+            "🥜": EmojiWithSkinTones(baseEmoji: .peanuts, skinTones: nil),
+            "🥐": EmojiWithSkinTones(baseEmoji: .croissant, skinTones: nil),
+            "🥖": EmojiWithSkinTones(baseEmoji: .baguetteBread, skinTones: nil),
+            "🥨": EmojiWithSkinTones(baseEmoji: .pretzel, skinTones: nil),
+            "🥯": EmojiWithSkinTones(baseEmoji: .bagel, skinTones: nil),
+            "🥞": EmojiWithSkinTones(baseEmoji: .pancakes, skinTones: nil),
+            "🥩": EmojiWithSkinTones(baseEmoji: .cutOfMeat, skinTones: nil),
+            "🥓": EmojiWithSkinTones(baseEmoji: .bacon, skinTones: nil),
+            "🥪": EmojiWithSkinTones(baseEmoji: .sandwich, skinTones: nil),
+            "🥙": EmojiWithSkinTones(baseEmoji: .stuffedFlatbread, skinTones: nil),
+            "🥚": EmojiWithSkinTones(baseEmoji: .egg, skinTones: nil),
+            "🥘": EmojiWithSkinTones(baseEmoji: .shallowPanOfFood, skinTones: nil),
+            "🥣": EmojiWithSkinTones(baseEmoji: .bowlWithSpoon, skinTones: nil),
+            "🥗": EmojiWithSkinTones(baseEmoji: .greenSalad, skinTones: nil),
+            "🥫": EmojiWithSkinTones(baseEmoji: .cannedFood, skinTones: nil),
+            "🥮": EmojiWithSkinTones(baseEmoji: .moonCake, skinTones: nil),
+            "🥟": EmojiWithSkinTones(baseEmoji: .dumpling, skinTones: nil),
+            "🥠": EmojiWithSkinTones(baseEmoji: .fortuneCookie, skinTones: nil),
+            "🥡": EmojiWithSkinTones(baseEmoji: .takeoutBox, skinTones: nil),
+            "🥧": EmojiWithSkinTones(baseEmoji: .pie, skinTones: nil),
+            "🥛": EmojiWithSkinTones(baseEmoji: .glassOfMilk, skinTones: nil),
+            "🥂": EmojiWithSkinTones(baseEmoji: .clinkingGlasses, skinTones: nil),
+            "🥃": EmojiWithSkinTones(baseEmoji: .tumblerGlass, skinTones: nil),
+            "🥤": EmojiWithSkinTones(baseEmoji: .cupWithStraw, skinTones: nil),
+            "🥢": EmojiWithSkinTones(baseEmoji: .chopsticks, skinTones: nil),
+            "🥄": EmojiWithSkinTones(baseEmoji: .spoon, skinTones: nil),
+            "🥇": EmojiWithSkinTones(baseEmoji: .firstPlaceMedal, skinTones: nil),
+            "🥈": EmojiWithSkinTones(baseEmoji: .secondPlaceMedal, skinTones: nil),
+            "🥉": EmojiWithSkinTones(baseEmoji: .thirdPlaceMedal, skinTones: nil),
+            "🥎": EmojiWithSkinTones(baseEmoji: .softball, skinTones: nil),
+            "🥏": EmojiWithSkinTones(baseEmoji: .flyingDisc, skinTones: nil),
+            "🥍": EmojiWithSkinTones(baseEmoji: .lacrosse, skinTones: nil),
+            "🥊": EmojiWithSkinTones(baseEmoji: .boxingGlove, skinTones: nil),
+            "🥋": EmojiWithSkinTones(baseEmoji: .martialArtsUniform, skinTones: nil),
+            "🥅": EmojiWithSkinTones(baseEmoji: .goalNet, skinTones: nil),
+            "🤿": EmojiWithSkinTones(baseEmoji: .divingMask, skinTones: nil),
+            "🥌": EmojiWithSkinTones(baseEmoji: .curlingStone, skinTones: nil),
+            "🥁": EmojiWithSkinTones(baseEmoji: .drumWithDrumsticks, skinTones: nil)
+        ]
+        return (lookup[rawValue] ?? EmojiWithSkinTones(unsupportedValue: rawValue))
+    }
+    
+    private static func emojiFrom1294(_ rawValue: String) -> EmojiWithSkinTones {
+        let lookup: [String: EmojiWithSkinTones] = [
+            "🥸": EmojiWithSkinTones(baseEmoji: .disguisedFace, skinTones: nil),
+            "🧐": EmojiWithSkinTones(baseEmoji: .faceWithMonocle, skinTones: nil),
+            "🥺": EmojiWithSkinTones(baseEmoji: .pleadingFace, skinTones: nil),
+            "🥹": EmojiWithSkinTones(baseEmoji: .faceHoldingBackTears, skinTones: nil),
+            "🦾": EmojiWithSkinTones(baseEmoji: .mechanicalArm, skinTones: nil),
+            "🦿": EmojiWithSkinTones(baseEmoji: .mechanicalLeg, skinTones: nil),
+            "🦵": EmojiWithSkinTones(baseEmoji: .leg, skinTones: nil),
+            "🦶": EmojiWithSkinTones(baseEmoji: .foot, skinTones: nil),
+            "🦻": EmojiWithSkinTones(baseEmoji: .earWithHearingAid, skinTones: nil),
+            "🦷": EmojiWithSkinTones(baseEmoji: .tooth, skinTones: nil),
+            "🦴": EmojiWithSkinTones(baseEmoji: .bone, skinTones: nil),
+            "🧒": EmojiWithSkinTones(baseEmoji: .child, skinTones: nil),
+            "🧑": EmojiWithSkinTones(baseEmoji: .adult, skinTones: nil),
+            "🧔": EmojiWithSkinTones(baseEmoji: .beardedPerson, skinTones: nil),
+            "🧓": EmojiWithSkinTones(baseEmoji: .olderAdult, skinTones: nil),
+            "🧏": EmojiWithSkinTones(baseEmoji: .deafPerson, skinTones: nil),
+            "🧕": EmojiWithSkinTones(baseEmoji: .personWithHeadscarf, skinTones: nil),
+            "🦸": EmojiWithSkinTones(baseEmoji: .superhero, skinTones: nil),
+            "🦹": EmojiWithSkinTones(baseEmoji: .supervillain, skinTones: nil),
+            "🧙": EmojiWithSkinTones(baseEmoji: .mage, skinTones: nil),
+            "🧚": EmojiWithSkinTones(baseEmoji: .fairy, skinTones: nil),
+            "🧛": EmojiWithSkinTones(baseEmoji: .vampire, skinTones: nil),
+            "🧌": EmojiWithSkinTones(baseEmoji: .troll, skinTones: nil),
+            "🧍": EmojiWithSkinTones(baseEmoji: .standingPerson, skinTones: nil),
+            "🧎": EmojiWithSkinTones(baseEmoji: .kneelingPerson, skinTones: nil),
+            "🧖": EmojiWithSkinTones(baseEmoji: .personInSteamyRoom, skinTones: nil),
+            "🧗": EmojiWithSkinTones(baseEmoji: .personClimbing, skinTones: nil),
+            "🧘": EmojiWithSkinTones(baseEmoji: .personInLotusPosition, skinTones: nil),
+            "🦍": EmojiWithSkinTones(baseEmoji: .gorilla, skinTones: nil),
+            "🦧": EmojiWithSkinTones(baseEmoji: .orangutan, skinTones: nil),
+            "🦮": EmojiWithSkinTones(baseEmoji: .guideDog, skinTones: nil),
+            "🦊": EmojiWithSkinTones(baseEmoji: .foxFace, skinTones: nil),
+            "🦝": EmojiWithSkinTones(baseEmoji: .raccoon, skinTones: nil),
+            "🦁": EmojiWithSkinTones(baseEmoji: .lionFace, skinTones: nil),
+            "🦄": EmojiWithSkinTones(baseEmoji: .unicornFace, skinTones: nil),
+            "🦓": EmojiWithSkinTones(baseEmoji: .zebraFace, skinTones: nil),
+            "🦌": EmojiWithSkinTones(baseEmoji: .deer, skinTones: nil),
+            "🦬": EmojiWithSkinTones(baseEmoji: .bison, skinTones: nil),
+            "🦙": EmojiWithSkinTones(baseEmoji: .llama, skinTones: nil),
+            "🦒": EmojiWithSkinTones(baseEmoji: .giraffeFace, skinTones: nil),
+            "🦣": EmojiWithSkinTones(baseEmoji: .mammoth, skinTones: nil),
+            "🦏": EmojiWithSkinTones(baseEmoji: .rhinoceros, skinTones: nil),
+            "🦛": EmojiWithSkinTones(baseEmoji: .hippopotamus, skinTones: nil),
+            "🦫": EmojiWithSkinTones(baseEmoji: .beaver, skinTones: nil),
+            "🦔": EmojiWithSkinTones(baseEmoji: .hedgehog, skinTones: nil),
+            "🦇": EmojiWithSkinTones(baseEmoji: .bat, skinTones: nil),
+            "🦥": EmojiWithSkinTones(baseEmoji: .sloth, skinTones: nil),
+            "🦦": EmojiWithSkinTones(baseEmoji: .otter, skinTones: nil),
+            "🦨": EmojiWithSkinTones(baseEmoji: .skunk, skinTones: nil),
+            "🦘": EmojiWithSkinTones(baseEmoji: .kangaroo, skinTones: nil),
+            "🦡": EmojiWithSkinTones(baseEmoji: .badger, skinTones: nil),
+            "🦃": EmojiWithSkinTones(baseEmoji: .turkey, skinTones: nil),
+            "🦅": EmojiWithSkinTones(baseEmoji: .eagle, skinTones: nil),
+            "🦆": EmojiWithSkinTones(baseEmoji: .duck, skinTones: nil),
+            "🦢": EmojiWithSkinTones(baseEmoji: .swan, skinTones: nil),
+            "🦉": EmojiWithSkinTones(baseEmoji: .owl, skinTones: nil),
+            "🦤": EmojiWithSkinTones(baseEmoji: .dodo, skinTones: nil),
+            "🦩": EmojiWithSkinTones(baseEmoji: .flamingo, skinTones: nil),
+            "🦚": EmojiWithSkinTones(baseEmoji: .peacock, skinTones: nil),
+            "🦜": EmojiWithSkinTones(baseEmoji: .parrot, skinTones: nil),
+            "🦎": EmojiWithSkinTones(baseEmoji: .lizard, skinTones: nil),
+            "🦕": EmojiWithSkinTones(baseEmoji: .sauropod, skinTones: nil),
+            "🦖": EmojiWithSkinTones(baseEmoji: .tRex, skinTones: nil),
+            "🦭": EmojiWithSkinTones(baseEmoji: .seal, skinTones: nil),
+            "🦈": EmojiWithSkinTones(baseEmoji: .shark, skinTones: nil),
+            "🦋": EmojiWithSkinTones(baseEmoji: .butterfly, skinTones: nil),
+            "🦗": EmojiWithSkinTones(baseEmoji: .cricket, skinTones: nil),
+            "🦂": EmojiWithSkinTones(baseEmoji: .scorpion, skinTones: nil),
+            "🦟": EmojiWithSkinTones(baseEmoji: .mosquito, skinTones: nil),
+            "🦠": EmojiWithSkinTones(baseEmoji: .microbe, skinTones: nil),
+            "🧄": EmojiWithSkinTones(baseEmoji: .garlic, skinTones: nil),
+            "🧅": EmojiWithSkinTones(baseEmoji: .onion, skinTones: nil),
+            "🧇": EmojiWithSkinTones(baseEmoji: .waffle, skinTones: nil),
+            "🧀": EmojiWithSkinTones(baseEmoji: .cheeseWedge, skinTones: nil),
+            "🧆": EmojiWithSkinTones(baseEmoji: .falafel, skinTones: nil),
+            "🧈": EmojiWithSkinTones(baseEmoji: .butter, skinTones: nil),
+            "🧂": EmojiWithSkinTones(baseEmoji: .salt, skinTones: nil),
+            "🦀": EmojiWithSkinTones(baseEmoji: .crab, skinTones: nil),
+            "🦞": EmojiWithSkinTones(baseEmoji: .lobster, skinTones: nil),
+            "🦐": EmojiWithSkinTones(baseEmoji: .shrimp, skinTones: nil),
+            "🦑": EmojiWithSkinTones(baseEmoji: .squid, skinTones: nil),
+            "🦪": EmojiWithSkinTones(baseEmoji: .oyster, skinTones: nil),
+            "🧁": EmojiWithSkinTones(baseEmoji: .cupcake, skinTones: nil),
+            "🧋": EmojiWithSkinTones(baseEmoji: .bubbleTea, skinTones: nil),
+            "🧃": EmojiWithSkinTones(baseEmoji: .beverageBox, skinTones: nil),
+            "🧉": EmojiWithSkinTones(baseEmoji: .mateDrink, skinTones: nil),
+            "🧊": EmojiWithSkinTones(baseEmoji: .iceCube, skinTones: nil),
+            "🦽": EmojiWithSkinTones(baseEmoji: .manualWheelchair, skinTones: nil),
+            "🦼": EmojiWithSkinTones(baseEmoji: .motorizedWheelchair, skinTones: nil),
+            "🥽": EmojiWithSkinTones(baseEmoji: .goggles, skinTones: nil),
+            "🥼": EmojiWithSkinTones(baseEmoji: .labCoat, skinTones: nil),
+            "🦺": EmojiWithSkinTones(baseEmoji: .safetyVest, skinTones: nil),
+            "🥻": EmojiWithSkinTones(baseEmoji: .sari, skinTones: nil),
+            "🥾": EmojiWithSkinTones(baseEmoji: .hikingBoot, skinTones: nil),
+            "🥿": EmojiWithSkinTones(baseEmoji: .womansFlatShoe, skinTones: nil),
+            "🦯": EmojiWithSkinTones(baseEmoji: .probingCane, skinTones: nil)
+        ]
+        return (lookup[rawValue] ?? EmojiWithSkinTones(unsupportedValue: rawValue))
+    }
+    
+    private static func emojiFrom1295(_ rawValue: String) -> EmojiWithSkinTones {
+        let lookup: [String: EmojiWithSkinTones] = [
+            "🧡": EmojiWithSkinTones(baseEmoji: .orangeHeart, skinTones: nil),
+            "🧠": EmojiWithSkinTones(baseEmoji: .brain, skinTones: nil),
+            "🧜": EmojiWithSkinTones(baseEmoji: .merperson, skinTones: nil),
+            "🧝": EmojiWithSkinTones(baseEmoji: .elf, skinTones: nil),
+            "🧞": EmojiWithSkinTones(baseEmoji: .genie, skinTones: nil),
+            "🧟": EmojiWithSkinTones(baseEmoji: .zombie, skinTones: nil),
+            "🧭": EmojiWithSkinTones(baseEmoji: .compass, skinTones: nil),
+            "🧱": EmojiWithSkinTones(baseEmoji: .bricks, skinTones: nil),
+            "🧳": EmojiWithSkinTones(baseEmoji: .luggage, skinTones: nil),
+            "🧨": EmojiWithSkinTones(baseEmoji: .firecracker, skinTones: nil),
+            "🧧": EmojiWithSkinTones(baseEmoji: .redEnvelope, skinTones: nil),
+            "🧩": EmojiWithSkinTones(baseEmoji: .jigsaw, skinTones: nil),
+            "🧸": EmojiWithSkinTones(baseEmoji: .teddyBear, skinTones: nil),
+            "🧵": EmojiWithSkinTones(baseEmoji: .thread, skinTones: nil),
+            "🧶": EmojiWithSkinTones(baseEmoji: .yarn, skinTones: nil),
+            "🧣": EmojiWithSkinTones(baseEmoji: .scarf, skinTones: nil),
+            "🧤": EmojiWithSkinTones(baseEmoji: .gloves, skinTones: nil),
+            "🧥": EmojiWithSkinTones(baseEmoji: .coat, skinTones: nil),
+            "🧦": EmojiWithSkinTones(baseEmoji: .socks, skinTones: nil),
+            "🧢": EmojiWithSkinTones(baseEmoji: .billedCap, skinTones: nil),
+            "🧮": EmojiWithSkinTones(baseEmoji: .abacus, skinTones: nil),
+            "🧾": EmojiWithSkinTones(baseEmoji: .receipt, skinTones: nil),
+            "🧰": EmojiWithSkinTones(baseEmoji: .toolbox, skinTones: nil),
+            "🧲": EmojiWithSkinTones(baseEmoji: .magnet, skinTones: nil),
+            "🧪": EmojiWithSkinTones(baseEmoji: .testTube, skinTones: nil),
+            "🧫": EmojiWithSkinTones(baseEmoji: .petriDish, skinTones: nil),
+            "🧬": EmojiWithSkinTones(baseEmoji: .dna, skinTones: nil),
+            "🧴": EmojiWithSkinTones(baseEmoji: .lotionBottle, skinTones: nil),
+            "🧷": EmojiWithSkinTones(baseEmoji: .safetyPin, skinTones: nil),
+            "🧹": EmojiWithSkinTones(baseEmoji: .broom, skinTones: nil),
+            "🧺": EmojiWithSkinTones(baseEmoji: .basket, skinTones: nil),
+            "🧻": EmojiWithSkinTones(baseEmoji: .rollOfPaper, skinTones: nil),
+            "🧼": EmojiWithSkinTones(baseEmoji: .soap, skinTones: nil),
+            "🧽": EmojiWithSkinTones(baseEmoji: .sponge, skinTones: nil),
+            "🧯": EmojiWithSkinTones(baseEmoji: .fireExtinguisher, skinTones: nil),
+            "🧿": EmojiWithSkinTones(baseEmoji: .nazarAmulet, skinTones: nil)
+        ]
+        return (lookup[rawValue] ?? EmojiWithSkinTones(unsupportedValue: rawValue))
+    }
+    
+    private static func emojiFrom1296(_ rawValue: String) -> EmojiWithSkinTones {
+        let lookup: [String: EmojiWithSkinTones] = [
+            "🩷": EmojiWithSkinTones(baseEmoji: .pinkHeart, skinTones: nil),
+            "🩵": EmojiWithSkinTones(baseEmoji: .lightBlueHeart, skinTones: nil),
+            "🩶": EmojiWithSkinTones(baseEmoji: .greyHeart, skinTones: nil),
+            "🪂": EmojiWithSkinTones(baseEmoji: .parachute, skinTones: nil),
+            "🪐": EmojiWithSkinTones(baseEmoji: .ringedPlanet, skinTones: nil),
+            "🪀": EmojiWithSkinTones(baseEmoji: .yoYo, skinTones: nil),
+            "🪁": EmojiWithSkinTones(baseEmoji: .kite, skinTones: nil),
+            "🪄": EmojiWithSkinTones(baseEmoji: .magicWand, skinTones: nil),
+            "🪅": EmojiWithSkinTones(baseEmoji: .pinata, skinTones: nil),
+            "🪆": EmojiWithSkinTones(baseEmoji: .nestingDolls, skinTones: nil),
+            "🪡": EmojiWithSkinTones(baseEmoji: .sewingNeedle, skinTones: nil),
+            "🪢": EmojiWithSkinTones(baseEmoji: .knot, skinTones: nil),
+            "🩱": EmojiWithSkinTones(baseEmoji: .onePieceSwimsuit, skinTones: nil),
+            "🩲": EmojiWithSkinTones(baseEmoji: .briefs, skinTones: nil),
+            "🩳": EmojiWithSkinTones(baseEmoji: .shorts, skinTones: nil),
+            "🩴": EmojiWithSkinTones(baseEmoji: .thongSandal, skinTones: nil),
+            "🩰": EmojiWithSkinTones(baseEmoji: .balletShoes, skinTones: nil),
+            "🪖": EmojiWithSkinTones(baseEmoji: .militaryHelmet, skinTones: nil),
+            "🪗": EmojiWithSkinTones(baseEmoji: .accordion, skinTones: nil),
+            "🪕": EmojiWithSkinTones(baseEmoji: .banjo, skinTones: nil),
+            "🪘": EmojiWithSkinTones(baseEmoji: .longDrum, skinTones: nil),
+            "🪇": EmojiWithSkinTones(baseEmoji: .maracas, skinTones: nil),
+            "🪈": EmojiWithSkinTones(baseEmoji: .flute, skinTones: nil),
+            "🪔": EmojiWithSkinTones(baseEmoji: .diyaLamp, skinTones: nil),
+            "🪙": EmojiWithSkinTones(baseEmoji: .coin, skinTones: nil),
+            "🪓": EmojiWithSkinTones(baseEmoji: .axe, skinTones: nil),
+            "🪃": EmojiWithSkinTones(baseEmoji: .boomerang, skinTones: nil),
+            "🪚": EmojiWithSkinTones(baseEmoji: .carpentrySaw, skinTones: nil),
+            "🪛": EmojiWithSkinTones(baseEmoji: .screwdriver, skinTones: nil),
+            "🪝": EmojiWithSkinTones(baseEmoji: .hook, skinTones: nil),
+            "🪜": EmojiWithSkinTones(baseEmoji: .ladder, skinTones: nil),
+            "🩸": EmojiWithSkinTones(baseEmoji: .dropOfBlood, skinTones: nil),
+            "🩹": EmojiWithSkinTones(baseEmoji: .adhesiveBandage, skinTones: nil),
+            "🩼": EmojiWithSkinTones(baseEmoji: .crutch, skinTones: nil),
+            "🩺": EmojiWithSkinTones(baseEmoji: .stethoscope, skinTones: nil),
+            "🩻": EmojiWithSkinTones(baseEmoji: .xRay, skinTones: nil),
+            "🪞": EmojiWithSkinTones(baseEmoji: .mirror, skinTones: nil),
+            "🪟": EmojiWithSkinTones(baseEmoji: .window, skinTones: nil),
+            "🪑": EmojiWithSkinTones(baseEmoji: .chair, skinTones: nil),
+            "🪠": EmojiWithSkinTones(baseEmoji: .plunger, skinTones: nil),
+            "🪒": EmojiWithSkinTones(baseEmoji: .razor, skinTones: nil),
+            "🪣": EmojiWithSkinTones(baseEmoji: .bucket, skinTones: nil)
+        ]
+        return (lookup[rawValue] ?? EmojiWithSkinTones(unsupportedValue: rawValue))
+    }
+    
+    private static func emojiFrom1297(_ rawValue: String) -> EmojiWithSkinTones {
+        let lookup: [String: EmojiWithSkinTones] = [
+            "🫠": EmojiWithSkinTones(baseEmoji: .meltingFace, skinTones: nil),
+            "🫢": EmojiWithSkinTones(baseEmoji: .faceWithOpenEyesAndHandOverMouth, skinTones: nil),
+            "🫣": EmojiWithSkinTones(baseEmoji: .faceWithPeekingEye, skinTones: nil),
+            "🫡": EmojiWithSkinTones(baseEmoji: .salutingFace, skinTones: nil),
+            "🫥": EmojiWithSkinTones(baseEmoji: .dottedLineFace, skinTones: nil),
+            "🫨": EmojiWithSkinTones(baseEmoji: .shakingFace, skinTones: nil),
+            "🫤": EmojiWithSkinTones(baseEmoji: .faceWithDiagonalMouth, skinTones: nil),
+            "🫱": EmojiWithSkinTones(baseEmoji: .rightwardsHand, skinTones: nil),
+            "🫲": EmojiWithSkinTones(baseEmoji: .leftwardsHand, skinTones: nil),
+            "🫳": EmojiWithSkinTones(baseEmoji: .palmDownHand, skinTones: nil),
+            "🫴": EmojiWithSkinTones(baseEmoji: .palmUpHand, skinTones: nil),
+            "🫷": EmojiWithSkinTones(baseEmoji: .leftwardsPushingHand, skinTones: nil),
+            "🫸": EmojiWithSkinTones(baseEmoji: .rightwardsPushingHand, skinTones: nil),
+            "🫰": EmojiWithSkinTones(baseEmoji: .handWithIndexFingerAndThumbCrossed, skinTones: nil),
+            "🫵": EmojiWithSkinTones(baseEmoji: .indexPointingAtTheViewer, skinTones: nil),
+            "🫶": EmojiWithSkinTones(baseEmoji: .heartHands, skinTones: nil),
+            "🫀": EmojiWithSkinTones(baseEmoji: .anatomicalHeart, skinTones: nil),
+            "🫁": EmojiWithSkinTones(baseEmoji: .lungs, skinTones: nil),
+            "🫦": EmojiWithSkinTones(baseEmoji: .bitingLip, skinTones: nil),
+            "🫅": EmojiWithSkinTones(baseEmoji: .personWithCrown, skinTones: nil),
+            "🫃": EmojiWithSkinTones(baseEmoji: .pregnantMan, skinTones: nil),
+            "🫄": EmojiWithSkinTones(baseEmoji: .pregnantPerson, skinTones: nil),
+            "🫂": EmojiWithSkinTones(baseEmoji: .peopleHugging, skinTones: nil),
+            "🫎": EmojiWithSkinTones(baseEmoji: .moose, skinTones: nil),
+            "🫏": EmojiWithSkinTones(baseEmoji: .donkey, skinTones: nil),
+            "🪶": EmojiWithSkinTones(baseEmoji: .feather, skinTones: nil),
+            "🪽": EmojiWithSkinTones(baseEmoji: .wing, skinTones: nil),
+            "🪿": EmojiWithSkinTones(baseEmoji: .goose, skinTones: nil),
+            "🪸": EmojiWithSkinTones(baseEmoji: .coral, skinTones: nil),
+            "🪼": EmojiWithSkinTones(baseEmoji: .jellyfish, skinTones: nil),
+            "🪲": EmojiWithSkinTones(baseEmoji: .beetle, skinTones: nil),
+            "🪳": EmojiWithSkinTones(baseEmoji: .cockroach, skinTones: nil),
+            "🪰": EmojiWithSkinTones(baseEmoji: .fly, skinTones: nil),
+            "🪱": EmojiWithSkinTones(baseEmoji: .worm, skinTones: nil),
+            "🪷": EmojiWithSkinTones(baseEmoji: .lotus, skinTones: nil),
+            "🪻": EmojiWithSkinTones(baseEmoji: .hyacinth, skinTones: nil),
+            "🪴": EmojiWithSkinTones(baseEmoji: .pottedPlant, skinTones: nil),
+            "🪹": EmojiWithSkinTones(baseEmoji: .emptyNest, skinTones: nil),
+            "🪺": EmojiWithSkinTones(baseEmoji: .nestWithEggs, skinTones: nil),
+            "🫐": EmojiWithSkinTones(baseEmoji: .blueberries, skinTones: nil),
+            "🫒": EmojiWithSkinTones(baseEmoji: .olive, skinTones: nil),
+            "🫑": EmojiWithSkinTones(baseEmoji: .bellPepper, skinTones: nil),
+            "🫘": EmojiWithSkinTones(baseEmoji: .beans, skinTones: nil),
+            "🫚": EmojiWithSkinTones(baseEmoji: .gingerRoot, skinTones: nil),
+            "🫛": EmojiWithSkinTones(baseEmoji: .peaPod, skinTones: nil),
+            "🫓": EmojiWithSkinTones(baseEmoji: .flatbread, skinTones: nil),
+            "🫔": EmojiWithSkinTones(baseEmoji: .tamale, skinTones: nil),
+            "🫕": EmojiWithSkinTones(baseEmoji: .fondue, skinTones: nil),
+            "🫖": EmojiWithSkinTones(baseEmoji: .teapot, skinTones: nil),
+            "🫗": EmojiWithSkinTones(baseEmoji: .pouringLiquid, skinTones: nil),
+            "🫙": EmojiWithSkinTones(baseEmoji: .jar, skinTones: nil),
+            "🪨": EmojiWithSkinTones(baseEmoji: .rock, skinTones: nil),
+            "🪵": EmojiWithSkinTones(baseEmoji: .wood, skinTones: nil),
+            "🪩": EmojiWithSkinTones(baseEmoji: .mirrorBall, skinTones: nil),
+            "🪭": EmojiWithSkinTones(baseEmoji: .foldingHandFan, skinTones: nil),
+            "🪮": EmojiWithSkinTones(baseEmoji: .hairPick, skinTones: nil),
+            "🪫": EmojiWithSkinTones(baseEmoji: .lowBattery, skinTones: nil),
+            "🪤": EmojiWithSkinTones(baseEmoji: .mouseTrap, skinTones: nil),
+            "🫧": EmojiWithSkinTones(baseEmoji: .bubbles, skinTones: nil),
+            "🪥": EmojiWithSkinTones(baseEmoji: .toothbrush, skinTones: nil),
+            "🪦": EmojiWithSkinTones(baseEmoji: .headstone, skinTones: nil),
+            "🪬": EmojiWithSkinTones(baseEmoji: .hamsa, skinTones: nil),
+            "🪧": EmojiWithSkinTones(baseEmoji: .placard, skinTones: nil),
+            "🪪": EmojiWithSkinTones(baseEmoji: .identificationCard, skinTones: nil),
+            "🪯": EmojiWithSkinTones(baseEmoji: .khanda, skinTones: nil)
+        ]
+        return (lookup[rawValue] ?? EmojiWithSkinTones(unsupportedValue: rawValue))
+    }
+    
+    private static func emojiFrom1377(_ rawValue: String) -> EmojiWithSkinTones {
+        let lookup: [String: EmojiWithSkinTones] = [
+            "☝🏻": EmojiWithSkinTones(baseEmoji: .pointUp, skinTones: [.light]),
+            "☝🏼": EmojiWithSkinTones(baseEmoji: .pointUp, skinTones: [.mediumLight]),
+            "☝🏽": EmojiWithSkinTones(baseEmoji: .pointUp, skinTones: [.medium]),
+            "☝🏾": EmojiWithSkinTones(baseEmoji: .pointUp, skinTones: [.mediumDark]),
+            "☝🏿": EmojiWithSkinTones(baseEmoji: .pointUp, skinTones: [.dark])
+        ]
+        return (lookup[rawValue] ?? EmojiWithSkinTones(unsupportedValue: rawValue))
+    }
+    
+    private static func emojiFrom1379(_ rawValue: String) -> EmojiWithSkinTones {
+        let lookup: [String: EmojiWithSkinTones] = [
+            "✋🏻": EmojiWithSkinTones(baseEmoji: .hand, skinTones: [.light]),
+            "✌🏻": EmojiWithSkinTones(baseEmoji: .v, skinTones: [.light]),
+            "✊🏻": EmojiWithSkinTones(baseEmoji: .fist, skinTones: [.light]),
+            "✍🏻": EmojiWithSkinTones(baseEmoji: .writingHand, skinTones: [.light]),
+            "⛹🏻": EmojiWithSkinTones(baseEmoji: .personWithBall, skinTones: [.light]),
+            "✋🏼": EmojiWithSkinTones(baseEmoji: .hand, skinTones: [.mediumLight]),
+            "✌🏼": EmojiWithSkinTones(baseEmoji: .v, skinTones: [.mediumLight]),
+            "✊🏼": EmojiWithSkinTones(baseEmoji: .fist, skinTones: [.mediumLight]),
+            "✍🏼": EmojiWithSkinTones(baseEmoji: .writingHand, skinTones: [.mediumLight]),
+            "⛹🏼": EmojiWithSkinTones(baseEmoji: .personWithBall, skinTones: [.mediumLight]),
+            "✋🏽": EmojiWithSkinTones(baseEmoji: .hand, skinTones: [.medium]),
+            "✌🏽": EmojiWithSkinTones(baseEmoji: .v, skinTones: [.medium]),
+            "✊🏽": EmojiWithSkinTones(baseEmoji: .fist, skinTones: [.medium]),
+            "✍🏽": EmojiWithSkinTones(baseEmoji: .writingHand, skinTones: [.medium]),
+            "⛹🏽": EmojiWithSkinTones(baseEmoji: .personWithBall, skinTones: [.medium]),
+            "✋🏾": EmojiWithSkinTones(baseEmoji: .hand, skinTones: [.mediumDark]),
+            "✌🏾": EmojiWithSkinTones(baseEmoji: .v, skinTones: [.mediumDark]),
+            "✊🏾": EmojiWithSkinTones(baseEmoji: .fist, skinTones: [.mediumDark]),
+            "✍🏾": EmojiWithSkinTones(baseEmoji: .writingHand, skinTones: [.mediumDark]),
+            "⛹🏾": EmojiWithSkinTones(baseEmoji: .personWithBall, skinTones: [.mediumDark]),
+            "✋🏿": EmojiWithSkinTones(baseEmoji: .hand, skinTones: [.dark]),
+            "✌🏿": EmojiWithSkinTones(baseEmoji: .v, skinTones: [.dark]),
+            "✊🏿": EmojiWithSkinTones(baseEmoji: .fist, skinTones: [.dark]),
+            "✍🏿": EmojiWithSkinTones(baseEmoji: .writingHand, skinTones: [.dark]),
+            "⛹🏿": EmojiWithSkinTones(baseEmoji: .personWithBall, skinTones: [.dark])
+        ]
+        return (lookup[rawValue] ?? EmojiWithSkinTones(unsupportedValue: rawValue))
+    }
+    
+    private static func emojiFrom1472(_ rawValue: String) -> EmojiWithSkinTones {
+        let lookup: [String: EmojiWithSkinTones] = [
+            "🐈‍⬛": EmojiWithSkinTones(baseEmoji: .blackCat, skinTones: nil),
+            "🐦‍⬛": EmojiWithSkinTones(baseEmoji: .blackBird, skinTones: nil)
+        ]
+        return (lookup[rawValue] ?? EmojiWithSkinTones(unsupportedValue: rawValue))
+    }
+    
+    private static func emojiFrom1580(_ rawValue: String) -> EmojiWithSkinTones {
+        let lookup: [String: EmojiWithSkinTones] = [
+            "⛹️‍♂️": EmojiWithSkinTones(baseEmoji: .manBouncingBall, skinTones: nil),
+            "⛹️‍♀️": EmojiWithSkinTones(baseEmoji: .womanBouncingBall, skinTones: nil)
+        ]
+        return (lookup[rawValue] ?? EmojiWithSkinTones(unsupportedValue: rawValue))
+    }
+    
+    private static func emojiFrom1923(_ rawValue: String) -> EmojiWithSkinTones {
+        let lookup: [String: EmojiWithSkinTones] = [
+            "🅰️": EmojiWithSkinTones(baseEmoji: .a, skinTones: nil),
+            "🅱️": EmojiWithSkinTones(baseEmoji: .b, skinTones: nil),
+            "🅾️": EmojiWithSkinTones(baseEmoji: .o2, skinTones: nil),
+            "🅿️": EmojiWithSkinTones(baseEmoji: .parking, skinTones: nil)
+        ]
+        return (lookup[rawValue] ?? EmojiWithSkinTones(unsupportedValue: rawValue))
+    }
+    
+    private static func emojiFrom1925(_ rawValue: String) -> EmojiWithSkinTones {
+        let lookup: [String: EmojiWithSkinTones] = [
+            "🈂️": EmojiWithSkinTones(baseEmoji: .sa, skinTones: nil),
+            "🈷️": EmojiWithSkinTones(baseEmoji: .u6708, skinTones: nil)
+        ]
+        return (lookup[rawValue] ?? EmojiWithSkinTones(unsupportedValue: rawValue))
+    }
+    
+    private static func emojiFrom1928(_ rawValue: String) -> EmojiWithSkinTones {
+        let lookup: [String: EmojiWithSkinTones] = [
+            "🌶️": EmojiWithSkinTones(baseEmoji: .hotPepper, skinTones: nil),
+            "🌡️": EmojiWithSkinTones(baseEmoji: .thermometer, skinTones: nil),
+            "🌤️": EmojiWithSkinTones(baseEmoji: .mostlySunny, skinTones: nil),
+            "🌥️": EmojiWithSkinTones(baseEmoji: .barelySunny, skinTones: nil),
+            "🌦️": EmojiWithSkinTones(baseEmoji: .partlySunnyRain, skinTones: nil),
+            "🌧️": EmojiWithSkinTones(baseEmoji: .rainCloud, skinTones: nil),
+            "🌨️": EmojiWithSkinTones(baseEmoji: .snowCloud, skinTones: nil),
+            "🌩️": EmojiWithSkinTones(baseEmoji: .lightning, skinTones: nil),
+            "🌪️": EmojiWithSkinTones(baseEmoji: .tornado, skinTones: nil),
+            "🌫️": EmojiWithSkinTones(baseEmoji: .fog, skinTones: nil),
+            "🌬️": EmojiWithSkinTones(baseEmoji: .windBlowingFace, skinTones: nil)
+        ]
+        return (lookup[rawValue] ?? EmojiWithSkinTones(unsupportedValue: rawValue))
+    }
+    
+    private static func emojiFrom1929(_ rawValue: String) -> EmojiWithSkinTones {
+        let lookup: [String: EmojiWithSkinTones] = [
+            "🏌️": EmojiWithSkinTones(baseEmoji: .golfer, skinTones: nil),
+            "🏋️": EmojiWithSkinTones(baseEmoji: .weightLifter, skinTones: nil),
+            "🍽️": EmojiWithSkinTones(baseEmoji: .knifeForkPlate, skinTones: nil),
+            "🏔️": EmojiWithSkinTones(baseEmoji: .snowCappedMountain, skinTones: nil),
+            "🏕️": EmojiWithSkinTones(baseEmoji: .camping, skinTones: nil),
+            "🏖️": EmojiWithSkinTones(baseEmoji: .beachWithUmbrella, skinTones: nil),
+            "🏗️": EmojiWithSkinTones(baseEmoji: .buildingConstruction, skinTones: nil),
+            "🏘️": EmojiWithSkinTones(baseEmoji: .houseBuildings, skinTones: nil),
+            "🏎️": EmojiWithSkinTones(baseEmoji: .racingCar, skinTones: nil),
+            "🏍️": EmojiWithSkinTones(baseEmoji: .racingMotorcycle, skinTones: nil),
+            "🎗️": EmojiWithSkinTones(baseEmoji: .reminderRibbon, skinTones: nil),
+            "🎟️": EmojiWithSkinTones(baseEmoji: .admissionTickets, skinTones: nil),
+            "🎖️": EmojiWithSkinTones(baseEmoji: .medal, skinTones: nil),
+            "🎙️": EmojiWithSkinTones(baseEmoji: .studioMicrophone, skinTones: nil),
+            "🎚️": EmojiWithSkinTones(baseEmoji: .levelSlider, skinTones: nil),
+            "🎛️": EmojiWithSkinTones(baseEmoji: .controlKnobs, skinTones: nil),
+            "🎞️": EmojiWithSkinTones(baseEmoji: .filmFrames, skinTones: nil)
+        ]
+        return (lookup[rawValue] ?? EmojiWithSkinTones(unsupportedValue: rawValue))
+    }
+    
+    private static func emojiFrom1930(_ rawValue: String) -> EmojiWithSkinTones {
+        let lookup: [String: EmojiWithSkinTones] = [
+            "🏵️": EmojiWithSkinTones(baseEmoji: .rosette, skinTones: nil),
+            "🏜️": EmojiWithSkinTones(baseEmoji: .desert, skinTones: nil),
+            "🏝️": EmojiWithSkinTones(baseEmoji: .desertIsland, skinTones: nil),
+            "🏞️": EmojiWithSkinTones(baseEmoji: .nationalPark, skinTones: nil),
+            "🏟️": EmojiWithSkinTones(baseEmoji: .stadium, skinTones: nil),
+            "🏛️": EmojiWithSkinTones(baseEmoji: .classicalBuilding, skinTones: nil),
+            "🏚️": EmojiWithSkinTones(baseEmoji: .derelictHouseBuilding, skinTones: nil),
+            "🏙️": EmojiWithSkinTones(baseEmoji: .cityscape, skinTones: nil),
+            "🏷️": EmojiWithSkinTones(baseEmoji: .label, skinTones: nil),
+            "🏳️": EmojiWithSkinTones(baseEmoji: .wavingWhiteFlag, skinTones: nil)
+        ]
+        return (lookup[rawValue] ?? EmojiWithSkinTones(unsupportedValue: rawValue))
+    }
+    
+    private static func emojiFrom1931(_ rawValue: String) -> EmojiWithSkinTones {
+        let lookup: [String: EmojiWithSkinTones] = [
+            "👁️": EmojiWithSkinTones(baseEmoji: .eye, skinTones: nil),
+            "🐿️": EmojiWithSkinTones(baseEmoji: .chipmunk, skinTones: nil)
+        ]
+        return (lookup[rawValue] ?? EmojiWithSkinTones(unsupportedValue: rawValue))
+    }
+    
+    private static func emojiFrom1932(_ rawValue: String) -> EmojiWithSkinTones {
+        let lookup: [String: EmojiWithSkinTones] = [
+            "📽️": EmojiWithSkinTones(baseEmoji: .filmProjector, skinTones: nil)
+        ]
+        return (lookup[rawValue] ?? EmojiWithSkinTones(unsupportedValue: rawValue))
+    }
+    
+    private static func emojiFrom1933(_ rawValue: String) -> EmojiWithSkinTones {
+        let lookup: [String: EmojiWithSkinTones] = [
+            "🕊️": EmojiWithSkinTones(baseEmoji: .doveOfPeace, skinTones: nil),
+            "🕉️": EmojiWithSkinTones(baseEmoji: .omSymbol, skinTones: nil)
+        ]
+        return (lookup[rawValue] ?? EmojiWithSkinTones(unsupportedValue: rawValue))
+    }
+    
+    private static func emojiFrom1934(_ rawValue: String) -> EmojiWithSkinTones {
+        let lookup: [String: EmojiWithSkinTones] = [
+            "🕳️": EmojiWithSkinTones(baseEmoji: .hole, skinTones: nil),
+            "🖐️": EmojiWithSkinTones(baseEmoji: .raisedHandWithFingersSplayed, skinTones: nil),
+            "🕵️": EmojiWithSkinTones(baseEmoji: .sleuthOrSpy, skinTones: nil),
+            "🕴️": EmojiWithSkinTones(baseEmoji: .manInBusinessSuitLevitating, skinTones: nil),
+            "🕷️": EmojiWithSkinTones(baseEmoji: .spider, skinTones: nil),
+            "🕸️": EmojiWithSkinTones(baseEmoji: .spiderWeb, skinTones: nil),
+            "🕰️": EmojiWithSkinTones(baseEmoji: .mantelpieceClock, skinTones: nil),
+            "🕹️": EmojiWithSkinTones(baseEmoji: .joystick, skinTones: nil),
+            "🖼️": EmojiWithSkinTones(baseEmoji: .frameWithPicture, skinTones: nil),
+            "🕶️": EmojiWithSkinTones(baseEmoji: .darkSunglasses, skinTones: nil),
+            "🖥️": EmojiWithSkinTones(baseEmoji: .desktopComputer, skinTones: nil),
+            "🖨️": EmojiWithSkinTones(baseEmoji: .printer, skinTones: nil),
+            "🖱️": EmojiWithSkinTones(baseEmoji: .threeButtonMouse, skinTones: nil),
+            "🖲️": EmojiWithSkinTones(baseEmoji: .trackball, skinTones: nil),
+            "🕯️": EmojiWithSkinTones(baseEmoji: .candle, skinTones: nil),
+            "🖋️": EmojiWithSkinTones(baseEmoji: .lowerLeftFountainPen, skinTones: nil),
+            "🖊️": EmojiWithSkinTones(baseEmoji: .lowerLeftBallpointPen, skinTones: nil),
+            "🖌️": EmojiWithSkinTones(baseEmoji: .lowerLeftPaintbrush, skinTones: nil),
+            "🖍️": EmojiWithSkinTones(baseEmoji: .lowerLeftCrayon, skinTones: nil),
+            "🗂️": EmojiWithSkinTones(baseEmoji: .cardIndexDividers, skinTones: nil),
+            "🖇️": EmojiWithSkinTones(baseEmoji: .linkedPaperclips, skinTones: nil),
+            "🗃️": EmojiWithSkinTones(baseEmoji: .cardFileBox, skinTones: nil),
+            "🗄️": EmojiWithSkinTones(baseEmoji: .fileCabinet, skinTones: nil)
+        ]
+        return (lookup[rawValue] ?? EmojiWithSkinTones(unsupportedValue: rawValue))
+    }
+    
+    private static func emojiFrom1935(_ rawValue: String) -> EmojiWithSkinTones {
+        let lookup: [String: EmojiWithSkinTones] = [
+            "🗨️": EmojiWithSkinTones(baseEmoji: .leftSpeechBubble, skinTones: nil),
+            "🗯️": EmojiWithSkinTones(baseEmoji: .rightAngerBubble, skinTones: nil),
+            "🗣️": EmojiWithSkinTones(baseEmoji: .speakingHeadInSilhouette, skinTones: nil),
+            "🗺️": EmojiWithSkinTones(baseEmoji: .worldMap, skinTones: nil),
+            "🗞️": EmojiWithSkinTones(baseEmoji: .rolledUpNewspaper, skinTones: nil),
+            "🗳️": EmojiWithSkinTones(baseEmoji: .ballotBoxWithBallot, skinTones: nil),
+            "🗒️": EmojiWithSkinTones(baseEmoji: .spiralNotePad, skinTones: nil),
+            "🗓️": EmojiWithSkinTones(baseEmoji: .spiralCalendarPad, skinTones: nil),
+            "🗑️": EmojiWithSkinTones(baseEmoji: .wastebasket, skinTones: nil),
+            "🗝️": EmojiWithSkinTones(baseEmoji: .oldKey, skinTones: nil),
+            "🗡️": EmojiWithSkinTones(baseEmoji: .daggerKnife, skinTones: nil),
+            "🗜️": EmojiWithSkinTones(baseEmoji: .compression, skinTones: nil)
+        ]
+        return (lookup[rawValue] ?? EmojiWithSkinTones(unsupportedValue: rawValue))
+    }
+    
+    private static func emojiFrom1937(_ rawValue: String) -> EmojiWithSkinTones {
+        let lookup: [String: EmojiWithSkinTones] = [
+            "🛣️": EmojiWithSkinTones(baseEmoji: .motorway, skinTones: nil),
+            "🛤️": EmojiWithSkinTones(baseEmoji: .railwayTrack, skinTones: nil),
+            "🛢️": EmojiWithSkinTones(baseEmoji: .oilDrum, skinTones: nil),
+            "🛳️": EmojiWithSkinTones(baseEmoji: .passengerShip, skinTones: nil),
+            "🛥️": EmojiWithSkinTones(baseEmoji: .motorBoat, skinTones: nil),
+            "🛩️": EmojiWithSkinTones(baseEmoji: .smallAirplane, skinTones: nil),
+            "🛰️": EmojiWithSkinTones(baseEmoji: .satellite, skinTones: nil),
+            "🛎️": EmojiWithSkinTones(baseEmoji: .bellhopBell, skinTones: nil),
+            "🛍️": EmojiWithSkinTones(baseEmoji: .shoppingBags, skinTones: nil),
+            "🛠️": EmojiWithSkinTones(baseEmoji: .hammerAndWrench, skinTones: nil),
+            "🛡️": EmojiWithSkinTones(baseEmoji: .shield, skinTones: nil),
+            "🛏️": EmojiWithSkinTones(baseEmoji: .bed, skinTones: nil),
+            "🛋️": EmojiWithSkinTones(baseEmoji: .couchAndLamp, skinTones: nil)
+        ]
+        return (lookup[rawValue] ?? EmojiWithSkinTones(unsupportedValue: rawValue))
+    }
+    
+    private static func emojiFrom2109(_ rawValue: String) -> EmojiWithSkinTones {
+        let lookup: [String: EmojiWithSkinTones] = [
+            "🏃‍♂️": EmojiWithSkinTones(baseEmoji: .manRunning, skinTones: nil),
+            "🏃‍♀️": EmojiWithSkinTones(baseEmoji: .womanRunning, skinTones: nil),
+            "🏄‍♂️": EmojiWithSkinTones(baseEmoji: .manSurfing, skinTones: nil),
+            "🏄‍♀️": EmojiWithSkinTones(baseEmoji: .womanSurfing, skinTones: nil),
+            "🏊‍♂️": EmojiWithSkinTones(baseEmoji: .manSwimming, skinTones: nil),
+            "🏊‍♀️": EmojiWithSkinTones(baseEmoji: .womanSwimming, skinTones: nil),
+            "🏴‍☠️": EmojiWithSkinTones(baseEmoji: .pirateFlag, skinTones: nil)
+        ]
+        return (lookup[rawValue] ?? EmojiWithSkinTones(unsupportedValue: rawValue))
+    }
+    
+    private static func emojiFrom2111(_ rawValue: String) -> EmojiWithSkinTones {
+        let lookup: [String: EmojiWithSkinTones] = [
+            "👱‍♀️": EmojiWithSkinTones(baseEmoji: .blondHairedWoman, skinTones: nil),
+            "👱‍♂️": EmojiWithSkinTones(baseEmoji: .blondHairedMan, skinTones: nil),
+            "💁‍♂️": EmojiWithSkinTones(baseEmoji: .manTippingHand, skinTones: nil),
+            "💁‍♀️": EmojiWithSkinTones(baseEmoji: .womanTippingHand, skinTones: nil),
+            "👮‍♂️": EmojiWithSkinTones(baseEmoji: .malePoliceOfficer, skinTones: nil),
+            "👮‍♀️": EmojiWithSkinTones(baseEmoji: .femalePoliceOfficer, skinTones: nil),
+            "💂‍♂️": EmojiWithSkinTones(baseEmoji: .maleGuard, skinTones: nil),
+            "💂‍♀️": EmojiWithSkinTones(baseEmoji: .femaleGuard, skinTones: nil),
+            "👷‍♂️": EmojiWithSkinTones(baseEmoji: .maleConstructionWorker, skinTones: nil),
+            "👷‍♀️": EmojiWithSkinTones(baseEmoji: .femaleConstructionWorker, skinTones: nil),
+            "👳‍♂️": EmojiWithSkinTones(baseEmoji: .manWearingTurban, skinTones: nil),
+            "👳‍♀️": EmojiWithSkinTones(baseEmoji: .womanWearingTurban, skinTones: nil),
+            "👰‍♂️": EmojiWithSkinTones(baseEmoji: .manWithVeil, skinTones: nil),
+            "👰‍♀️": EmojiWithSkinTones(baseEmoji: .womanWithVeil, skinTones: nil),
+            "💆‍♂️": EmojiWithSkinTones(baseEmoji: .manGettingMassage, skinTones: nil),
+            "💆‍♀️": EmojiWithSkinTones(baseEmoji: .womanGettingMassage, skinTones: nil),
+            "💇‍♂️": EmojiWithSkinTones(baseEmoji: .manGettingHaircut, skinTones: nil),
+            "💇‍♀️": EmojiWithSkinTones(baseEmoji: .womanGettingHaircut, skinTones: nil),
+            "👯‍♂️": EmojiWithSkinTones(baseEmoji: .menWithBunnyEarsPartying, skinTones: nil),
+            "👯‍♀️": EmojiWithSkinTones(baseEmoji: .womenWithBunnyEarsPartying, skinTones: nil)
+        ]
+        return (lookup[rawValue] ?? EmojiWithSkinTones(unsupportedValue: rawValue))
+    }
+    
+    private static func emojiFrom2112(_ rawValue: String) -> EmojiWithSkinTones {
+        let lookup: [String: EmojiWithSkinTones] = [
+            "👨‍⚕️": EmojiWithSkinTones(baseEmoji: .maleDoctor, skinTones: nil),
+            "👩‍⚕️": EmojiWithSkinTones(baseEmoji: .femaleDoctor, skinTones: nil),
+            "👨‍⚖️": EmojiWithSkinTones(baseEmoji: .maleJudge, skinTones: nil),
+            "👩‍⚖️": EmojiWithSkinTones(baseEmoji: .femaleJudge, skinTones: nil)
+        ]
+        return (lookup[rawValue] ?? EmojiWithSkinTones(unsupportedValue: rawValue))
+    }
+    
+    private static func emojiFrom2113(_ rawValue: String) -> EmojiWithSkinTones {
+        let lookup: [String: EmojiWithSkinTones] = [
+            "👨‍✈️": EmojiWithSkinTones(baseEmoji: .malePilot, skinTones: nil),
+            "👩‍✈️": EmojiWithSkinTones(baseEmoji: .femalePilot, skinTones: nil),
+            "🐻‍❄️": EmojiWithSkinTones(baseEmoji: .polarBear, skinTones: nil)
+        ]
+        return (lookup[rawValue] ?? EmojiWithSkinTones(unsupportedValue: rawValue))
+    }
+    
+    private static func emojiFrom2116(_ rawValue: String) -> EmojiWithSkinTones {
+        let lookup: [String: EmojiWithSkinTones] = [
+            "❤️‍🔥": EmojiWithSkinTones(baseEmoji: .heartOnFire, skinTones: nil),
+            "🙍‍♂️": EmojiWithSkinTones(baseEmoji: .manFrowning, skinTones: nil),
+            "🙍‍♀️": EmojiWithSkinTones(baseEmoji: .womanFrowning, skinTones: nil),
+            "🙎‍♂️": EmojiWithSkinTones(baseEmoji: .manPouting, skinTones: nil),
+            "🙎‍♀️": EmojiWithSkinTones(baseEmoji: .womanPouting, skinTones: nil),
+            "🙅‍♂️": EmojiWithSkinTones(baseEmoji: .manGesturingNo, skinTones: nil),
+            "🙅‍♀️": EmojiWithSkinTones(baseEmoji: .womanGesturingNo, skinTones: nil),
+            "🙆‍♂️": EmojiWithSkinTones(baseEmoji: .manGesturingOk, skinTones: nil),
+            "🙆‍♀️": EmojiWithSkinTones(baseEmoji: .womanGesturingOk, skinTones: nil),
+            "🙋‍♂️": EmojiWithSkinTones(baseEmoji: .manRaisingHand, skinTones: nil),
+            "🙋‍♀️": EmojiWithSkinTones(baseEmoji: .womanRaisingHand, skinTones: nil),
+            "🙇‍♂️": EmojiWithSkinTones(baseEmoji: .manBowing, skinTones: nil),
+            "🙇‍♀️": EmojiWithSkinTones(baseEmoji: .womanBowing, skinTones: nil)
+        ]
+        return (lookup[rawValue] ?? EmojiWithSkinTones(unsupportedValue: rawValue))
+    }
+    
+    private static func emojiFrom2117(_ rawValue: String) -> EmojiWithSkinTones {
+        let lookup: [String: EmojiWithSkinTones] = [
+            "🚶‍♂️": EmojiWithSkinTones(baseEmoji: .manWalking, skinTones: nil),
+            "🚶‍♀️": EmojiWithSkinTones(baseEmoji: .womanWalking, skinTones: nil),
+            "🚣‍♂️": EmojiWithSkinTones(baseEmoji: .manRowingBoat, skinTones: nil),
+            "🚣‍♀️": EmojiWithSkinTones(baseEmoji: .womanRowingBoat, skinTones: nil),
+            "🚴‍♂️": EmojiWithSkinTones(baseEmoji: .manBiking, skinTones: nil),
+            "🚴‍♀️": EmojiWithSkinTones(baseEmoji: .womanBiking, skinTones: nil),
+            "🚵‍♂️": EmojiWithSkinTones(baseEmoji: .manMountainBiking, skinTones: nil),
+            "🚵‍♀️": EmojiWithSkinTones(baseEmoji: .womanMountainBiking, skinTones: nil)
+        ]
+        return (lookup[rawValue] ?? EmojiWithSkinTones(unsupportedValue: rawValue))
+    }
+    
+    private static func emojiFrom2123(_ rawValue: String) -> EmojiWithSkinTones {
+        let lookup: [String: EmojiWithSkinTones] = [
+            "🤦‍♂️": EmojiWithSkinTones(baseEmoji: .manFacepalming, skinTones: nil),
+            "🤦‍♀️": EmojiWithSkinTones(baseEmoji: .womanFacepalming, skinTones: nil),
+            "🤷‍♂️": EmojiWithSkinTones(baseEmoji: .manShrugging, skinTones: nil),
+            "🤷‍♀️": EmojiWithSkinTones(baseEmoji: .womanShrugging, skinTones: nil),
+            "🤵‍♂️": EmojiWithSkinTones(baseEmoji: .manInTuxedo, skinTones: nil),
+            "🤵‍♀️": EmojiWithSkinTones(baseEmoji: .womanInTuxedo, skinTones: nil),
+            "🤸‍♂️": EmojiWithSkinTones(baseEmoji: .manCartwheeling, skinTones: nil),
+            "🤸‍♀️": EmojiWithSkinTones(baseEmoji: .womanCartwheeling, skinTones: nil),
+            "🤼‍♂️": EmojiWithSkinTones(baseEmoji: .manWrestling, skinTones: nil),
+            "🤼‍♀️": EmojiWithSkinTones(baseEmoji: .womanWrestling, skinTones: nil),
+            "🤽‍♂️": EmojiWithSkinTones(baseEmoji: .manPlayingWaterPolo, skinTones: nil),
+            "🤽‍♀️": EmojiWithSkinTones(baseEmoji: .womanPlayingWaterPolo, skinTones: nil),
+            "🤾‍♂️": EmojiWithSkinTones(baseEmoji: .manPlayingHandball, skinTones: nil),
+            "🤾‍♀️": EmojiWithSkinTones(baseEmoji: .womanPlayingHandball, skinTones: nil),
+            "🤹‍♂️": EmojiWithSkinTones(baseEmoji: .manJuggling, skinTones: nil),
+            "🤹‍♀️": EmojiWithSkinTones(baseEmoji: .womanJuggling, skinTones: nil)
+        ]
+        return (lookup[rawValue] ?? EmojiWithSkinTones(unsupportedValue: rawValue))
+    }
+    
+    private static func emojiFrom2125(_ rawValue: String) -> EmojiWithSkinTones {
+        let lookup: [String: EmojiWithSkinTones] = [
+            "🧔‍♂️": EmojiWithSkinTones(baseEmoji: .manWithBeard, skinTones: nil),
+            "🧔‍♀️": EmojiWithSkinTones(baseEmoji: .womanWithBeard, skinTones: nil),
+            "🧏‍♂️": EmojiWithSkinTones(baseEmoji: .deafMan, skinTones: nil),
+            "🧏‍♀️": EmojiWithSkinTones(baseEmoji: .deafWoman, skinTones: nil),
+            "🦸‍♂️": EmojiWithSkinTones(baseEmoji: .maleSuperhero, skinTones: nil),
+            "🦸‍♀️": EmojiWithSkinTones(baseEmoji: .femaleSuperhero, skinTones: nil),
+            "🦹‍♂️": EmojiWithSkinTones(baseEmoji: .maleSupervillain, skinTones: nil),
+            "🦹‍♀️": EmojiWithSkinTones(baseEmoji: .femaleSupervillain, skinTones: nil),
+            "🧙‍♂️": EmojiWithSkinTones(baseEmoji: .maleMage, skinTones: nil),
+            "🧙‍♀️": EmojiWithSkinTones(baseEmoji: .femaleMage, skinTones: nil),
+            "🧚‍♂️": EmojiWithSkinTones(baseEmoji: .maleFairy, skinTones: nil),
+            "🧚‍♀️": EmojiWithSkinTones(baseEmoji: .femaleFairy, skinTones: nil),
+            "🧛‍♂️": EmojiWithSkinTones(baseEmoji: .maleVampire, skinTones: nil),
+            "🧛‍♀️": EmojiWithSkinTones(baseEmoji: .femaleVampire, skinTones: nil),
+            "🧜‍♂️": EmojiWithSkinTones(baseEmoji: .merman, skinTones: nil),
+            "🧜‍♀️": EmojiWithSkinTones(baseEmoji: .mermaid, skinTones: nil),
+            "🧝‍♂️": EmojiWithSkinTones(baseEmoji: .maleElf, skinTones: nil),
+            "🧝‍♀️": EmojiWithSkinTones(baseEmoji: .femaleElf, skinTones: nil),
+            "🧞‍♂️": EmojiWithSkinTones(baseEmoji: .maleGenie, skinTones: nil),
+            "🧞‍♀️": EmojiWithSkinTones(baseEmoji: .femaleGenie, skinTones: nil),
+            "🧟‍♂️": EmojiWithSkinTones(baseEmoji: .maleZombie, skinTones: nil),
+            "🧟‍♀️": EmojiWithSkinTones(baseEmoji: .femaleZombie, skinTones: nil),
+            "🧍‍♂️": EmojiWithSkinTones(baseEmoji: .manStanding, skinTones: nil),
+            "🧍‍♀️": EmojiWithSkinTones(baseEmoji: .womanStanding, skinTones: nil),
+            "🧎‍♂️": EmojiWithSkinTones(baseEmoji: .manKneeling, skinTones: nil),
+            "🧎‍♀️": EmojiWithSkinTones(baseEmoji: .womanKneeling, skinTones: nil),
+            "🧖‍♂️": EmojiWithSkinTones(baseEmoji: .manInSteamyRoom, skinTones: nil),
+            "🧖‍♀️": EmojiWithSkinTones(baseEmoji: .womanInSteamyRoom, skinTones: nil),
+            "🧗‍♂️": EmojiWithSkinTones(baseEmoji: .manClimbing, skinTones: nil),
+            "🧗‍♀️": EmojiWithSkinTones(baseEmoji: .womanClimbing, skinTones: nil),
+            "🧘‍♂️": EmojiWithSkinTones(baseEmoji: .manInLotusPosition, skinTones: nil),
+            "🧘‍♀️": EmojiWithSkinTones(baseEmoji: .womanInLotusPosition, skinTones: nil)
+        ]
+        return (lookup[rawValue] ?? EmojiWithSkinTones(unsupportedValue: rawValue))
+    }
+    
+    private static func emojiFrom2126(_ rawValue: String) -> EmojiWithSkinTones {
+        let lookup: [String: EmojiWithSkinTones] = [
+            "🧑‍⚕️": EmojiWithSkinTones(baseEmoji: .healthWorker, skinTones: nil),
+            "🧑‍⚖️": EmojiWithSkinTones(baseEmoji: .judge, skinTones: nil)
+        ]
+        return (lookup[rawValue] ?? EmojiWithSkinTones(unsupportedValue: rawValue))
+    }
+    
+    private static func emojiFrom2127(_ rawValue: String) -> EmojiWithSkinTones {
+        let lookup: [String: EmojiWithSkinTones] = [
+            "🧑‍✈️": EmojiWithSkinTones(baseEmoji: .pilot, skinTones: nil)
+        ]
+        return (lookup[rawValue] ?? EmojiWithSkinTones(unsupportedValue: rawValue))
+    }
+    
+    private static func emojiFrom2129(_ rawValue: String) -> EmojiWithSkinTones {
+        let lookup: [String: EmojiWithSkinTones] = [
+            "❤️‍🩹": EmojiWithSkinTones(baseEmoji: .mendingHeart, skinTones: nil)
+        ]
+        return (lookup[rawValue] ?? EmojiWithSkinTones(unsupportedValue: rawValue))
+    }
+    
+    private static func emojiFrom2210(_ rawValue: String) -> EmojiWithSkinTones {
+        let lookup: [String: EmojiWithSkinTones] = [
+            "⛹🏻‍♂️": EmojiWithSkinTones(baseEmoji: .manBouncingBall, skinTones: [.light]),
+            "⛹🏻‍♀️": EmojiWithSkinTones(baseEmoji: .womanBouncingBall, skinTones: [.light]),
+            "⛹🏼‍♂️": EmojiWithSkinTones(baseEmoji: .manBouncingBall, skinTones: [.mediumLight]),
+            "⛹🏼‍♀️": EmojiWithSkinTones(baseEmoji: .womanBouncingBall, skinTones: [.mediumLight]),
+            "⛹🏽‍♂️": EmojiWithSkinTones(baseEmoji: .manBouncingBall, skinTones: [.medium]),
+            "⛹🏽‍♀️": EmojiWithSkinTones(baseEmoji: .womanBouncingBall, skinTones: [.medium]),
+            "⛹🏾‍♂️": EmojiWithSkinTones(baseEmoji: .manBouncingBall, skinTones: [.mediumDark]),
+            "⛹🏾‍♀️": EmojiWithSkinTones(baseEmoji: .womanBouncingBall, skinTones: [.mediumDark]),
+            "⛹🏿‍♂️": EmojiWithSkinTones(baseEmoji: .manBouncingBall, skinTones: [.dark]),
+            "⛹🏿‍♀️": EmojiWithSkinTones(baseEmoji: .womanBouncingBall, skinTones: [.dark])
+        ]
+        return (lookup[rawValue] ?? EmojiWithSkinTones(unsupportedValue: rawValue))
+    }
+    
+    private static func emojiFrom2549(_ rawValue: String) -> EmojiWithSkinTones {
+        let lookup: [String: EmojiWithSkinTones] = [
+            "🇦🇨": EmojiWithSkinTones(baseEmoji: .flagAc, skinTones: nil),
+            "🇦🇩": EmojiWithSkinTones(baseEmoji: .flagAd, skinTones: nil),
+            "🇦🇪": EmojiWithSkinTones(baseEmoji: .flagAe, skinTones: nil),
+            "🇦🇫": EmojiWithSkinTones(baseEmoji: .flagAf, skinTones: nil),
+            "🇦🇬": EmojiWithSkinTones(baseEmoji: .flagAg, skinTones: nil),
+            "🇦🇮": EmojiWithSkinTones(baseEmoji: .flagAi, skinTones: nil),
+            "🇦🇱": EmojiWithSkinTones(baseEmoji: .flagAl, skinTones: nil),
+            "🇦🇲": EmojiWithSkinTones(baseEmoji: .flagAm, skinTones: nil),
+            "🇦🇴": EmojiWithSkinTones(baseEmoji: .flagAo, skinTones: nil),
+            "🇦🇶": EmojiWithSkinTones(baseEmoji: .flagAq, skinTones: nil),
+            "🇦🇷": EmojiWithSkinTones(baseEmoji: .flagAr, skinTones: nil),
+            "🇦🇸": EmojiWithSkinTones(baseEmoji: .flagAs, skinTones: nil),
+            "🇦🇹": EmojiWithSkinTones(baseEmoji: .flagAt, skinTones: nil),
+            "🇦🇺": EmojiWithSkinTones(baseEmoji: .flagAu, skinTones: nil),
+            "🇦🇼": EmojiWithSkinTones(baseEmoji: .flagAw, skinTones: nil),
+            "🇦🇽": EmojiWithSkinTones(baseEmoji: .flagAx, skinTones: nil),
+            "🇦🇿": EmojiWithSkinTones(baseEmoji: .flagAz, skinTones: nil),
+            "🇧🇦": EmojiWithSkinTones(baseEmoji: .flagBa, skinTones: nil),
+            "🇧🇧": EmojiWithSkinTones(baseEmoji: .flagBb, skinTones: nil),
+            "🇧🇩": EmojiWithSkinTones(baseEmoji: .flagBd, skinTones: nil),
+            "🇧🇪": EmojiWithSkinTones(baseEmoji: .flagBe, skinTones: nil),
+            "🇧🇫": EmojiWithSkinTones(baseEmoji: .flagBf, skinTones: nil),
+            "🇧🇬": EmojiWithSkinTones(baseEmoji: .flagBg, skinTones: nil),
+            "🇧🇭": EmojiWithSkinTones(baseEmoji: .flagBh, skinTones: nil),
+            "🇧🇮": EmojiWithSkinTones(baseEmoji: .flagBi, skinTones: nil),
+            "🇧🇯": EmojiWithSkinTones(baseEmoji: .flagBj, skinTones: nil),
+            "🇧🇱": EmojiWithSkinTones(baseEmoji: .flagBl, skinTones: nil),
+            "🇧🇲": EmojiWithSkinTones(baseEmoji: .flagBm, skinTones: nil),
+            "🇧🇳": EmojiWithSkinTones(baseEmoji: .flagBn, skinTones: nil),
+            "🇧🇴": EmojiWithSkinTones(baseEmoji: .flagBo, skinTones: nil),
+            "🇧🇶": EmojiWithSkinTones(baseEmoji: .flagBq, skinTones: nil),
+            "🇧🇷": EmojiWithSkinTones(baseEmoji: .flagBr, skinTones: nil),
+            "🇧🇸": EmojiWithSkinTones(baseEmoji: .flagBs, skinTones: nil),
+            "🇧🇹": EmojiWithSkinTones(baseEmoji: .flagBt, skinTones: nil),
+            "🇧🇻": EmojiWithSkinTones(baseEmoji: .flagBv, skinTones: nil),
+            "🇧🇼": EmojiWithSkinTones(baseEmoji: .flagBw, skinTones: nil),
+            "🇧🇾": EmojiWithSkinTones(baseEmoji: .flagBy, skinTones: nil),
+            "🇧🇿": EmojiWithSkinTones(baseEmoji: .flagBz, skinTones: nil),
+            "🇨🇦": EmojiWithSkinTones(baseEmoji: .flagCa, skinTones: nil),
+            "🇨🇨": EmojiWithSkinTones(baseEmoji: .flagCc, skinTones: nil),
+            "🇨🇩": EmojiWithSkinTones(baseEmoji: .flagCd, skinTones: nil),
+            "🇨🇫": EmojiWithSkinTones(baseEmoji: .flagCf, skinTones: nil),
+            "🇨🇬": EmojiWithSkinTones(baseEmoji: .flagCg, skinTones: nil),
+            "🇨🇭": EmojiWithSkinTones(baseEmoji: .flagCh, skinTones: nil),
+            "🇨🇮": EmojiWithSkinTones(baseEmoji: .flagCi, skinTones: nil),
+            "🇨🇰": EmojiWithSkinTones(baseEmoji: .flagCk, skinTones: nil),
+            "🇨🇱": EmojiWithSkinTones(baseEmoji: .flagCl, skinTones: nil),
+            "🇨🇲": EmojiWithSkinTones(baseEmoji: .flagCm, skinTones: nil),
+            "🇨🇳": EmojiWithSkinTones(baseEmoji: .cn, skinTones: nil),
+            "🇨🇴": EmojiWithSkinTones(baseEmoji: .flagCo, skinTones: nil),
+            "🇨🇵": EmojiWithSkinTones(baseEmoji: .flagCp, skinTones: nil),
+            "🇨🇷": EmojiWithSkinTones(baseEmoji: .flagCr, skinTones: nil),
+            "🇨🇺": EmojiWithSkinTones(baseEmoji: .flagCu, skinTones: nil),
+            "🇨🇻": EmojiWithSkinTones(baseEmoji: .flagCv, skinTones: nil),
+            "🇨🇼": EmojiWithSkinTones(baseEmoji: .flagCw, skinTones: nil),
+            "🇨🇽": EmojiWithSkinTones(baseEmoji: .flagCx, skinTones: nil),
+            "🇨🇾": EmojiWithSkinTones(baseEmoji: .flagCy, skinTones: nil),
+            "🇨🇿": EmojiWithSkinTones(baseEmoji: .flagCz, skinTones: nil),
+            "🇩🇪": EmojiWithSkinTones(baseEmoji: .de, skinTones: nil),
+            "🇩🇬": EmojiWithSkinTones(baseEmoji: .flagDg, skinTones: nil),
+            "🇩🇯": EmojiWithSkinTones(baseEmoji: .flagDj, skinTones: nil),
+            "🇩🇰": EmojiWithSkinTones(baseEmoji: .flagDk, skinTones: nil),
+            "🇩🇲": EmojiWithSkinTones(baseEmoji: .flagDm, skinTones: nil),
+            "🇩🇴": EmojiWithSkinTones(baseEmoji: .flagDo, skinTones: nil),
+            "🇩🇿": EmojiWithSkinTones(baseEmoji: .flagDz, skinTones: nil),
+            "🇪🇦": EmojiWithSkinTones(baseEmoji: .flagEa, skinTones: nil),
+            "🇪🇨": EmojiWithSkinTones(baseEmoji: .flagEc, skinTones: nil),
+            "🇪🇪": EmojiWithSkinTones(baseEmoji: .flagEe, skinTones: nil),
+            "🇪🇬": EmojiWithSkinTones(baseEmoji: .flagEg, skinTones: nil),
+            "🇪🇭": EmojiWithSkinTones(baseEmoji: .flagEh, skinTones: nil),
+            "🇪🇷": EmojiWithSkinTones(baseEmoji: .flagEr, skinTones: nil),
+            "🇪🇸": EmojiWithSkinTones(baseEmoji: .es, skinTones: nil),
+            "🇪🇹": EmojiWithSkinTones(baseEmoji: .flagEt, skinTones: nil),
+            "🇪🇺": EmojiWithSkinTones(baseEmoji: .flagEu, skinTones: nil),
+            "🇫🇮": EmojiWithSkinTones(baseEmoji: .flagFi, skinTones: nil),
+            "🇫🇯": EmojiWithSkinTones(baseEmoji: .flagFj, skinTones: nil),
+            "🇫🇰": EmojiWithSkinTones(baseEmoji: .flagFk, skinTones: nil),
+            "🇫🇲": EmojiWithSkinTones(baseEmoji: .flagFm, skinTones: nil),
+            "🇫🇴": EmojiWithSkinTones(baseEmoji: .flagFo, skinTones: nil),
+            "🇫🇷": EmojiWithSkinTones(baseEmoji: .fr, skinTones: nil),
+            "🇬🇦": EmojiWithSkinTones(baseEmoji: .flagGa, skinTones: nil),
+            "🇬🇧": EmojiWithSkinTones(baseEmoji: .gb, skinTones: nil),
+            "🇬🇩": EmojiWithSkinTones(baseEmoji: .flagGd, skinTones: nil),
+            "🇬🇪": EmojiWithSkinTones(baseEmoji: .flagGe, skinTones: nil),
+            "🇬🇫": EmojiWithSkinTones(baseEmoji: .flagGf, skinTones: nil),
+            "🇬🇬": EmojiWithSkinTones(baseEmoji: .flagGg, skinTones: nil),
+            "🇬🇭": EmojiWithSkinTones(baseEmoji: .flagGh, skinTones: nil),
+            "🇬🇮": EmojiWithSkinTones(baseEmoji: .flagGi, skinTones: nil),
+            "🇬🇱": EmojiWithSkinTones(baseEmoji: .flagGl, skinTones: nil),
+            "🇬🇲": EmojiWithSkinTones(baseEmoji: .flagGm, skinTones: nil),
+            "🇬🇳": EmojiWithSkinTones(baseEmoji: .flagGn, skinTones: nil),
+            "🇬🇵": EmojiWithSkinTones(baseEmoji: .flagGp, skinTones: nil),
+            "🇬🇶": EmojiWithSkinTones(baseEmoji: .flagGq, skinTones: nil),
+            "🇬🇷": EmojiWithSkinTones(baseEmoji: .flagGr, skinTones: nil),
+            "🇬🇸": EmojiWithSkinTones(baseEmoji: .flagGs, skinTones: nil),
+            "🇬🇹": EmojiWithSkinTones(baseEmoji: .flagGt, skinTones: nil),
+            "🇬🇺": EmojiWithSkinTones(baseEmoji: .flagGu, skinTones: nil),
+            "🇬🇼": EmojiWithSkinTones(baseEmoji: .flagGw, skinTones: nil),
+            "🇬🇾": EmojiWithSkinTones(baseEmoji: .flagGy, skinTones: nil),
+            "🇭🇰": EmojiWithSkinTones(baseEmoji: .flagHk, skinTones: nil),
+            "🇭🇲": EmojiWithSkinTones(baseEmoji: .flagHm, skinTones: nil),
+            "🇭🇳": EmojiWithSkinTones(baseEmoji: .flagHn, skinTones: nil),
+            "🇭🇷": EmojiWithSkinTones(baseEmoji: .flagHr, skinTones: nil),
+            "🇭🇹": EmojiWithSkinTones(baseEmoji: .flagHt, skinTones: nil),
+            "🇭🇺": EmojiWithSkinTones(baseEmoji: .flagHu, skinTones: nil),
+            "🇮🇨": EmojiWithSkinTones(baseEmoji: .flagIc, skinTones: nil),
+            "🇮🇩": EmojiWithSkinTones(baseEmoji: .flagId, skinTones: nil),
+            "🇮🇪": EmojiWithSkinTones(baseEmoji: .flagIe, skinTones: nil),
+            "🇮🇱": EmojiWithSkinTones(baseEmoji: .flagIl, skinTones: nil),
+            "🇮🇲": EmojiWithSkinTones(baseEmoji: .flagIm, skinTones: nil),
+            "🇮🇳": EmojiWithSkinTones(baseEmoji: .flagIn, skinTones: nil),
+            "🇮🇴": EmojiWithSkinTones(baseEmoji: .flagIo, skinTones: nil),
+            "🇮🇶": EmojiWithSkinTones(baseEmoji: .flagIq, skinTones: nil),
+            "🇮🇷": EmojiWithSkinTones(baseEmoji: .flagIr, skinTones: nil),
+            "🇮🇸": EmojiWithSkinTones(baseEmoji: .flagIs, skinTones: nil),
+            "🇮🇹": EmojiWithSkinTones(baseEmoji: .it, skinTones: nil),
+            "🇯🇪": EmojiWithSkinTones(baseEmoji: .flagJe, skinTones: nil),
+            "🇯🇲": EmojiWithSkinTones(baseEmoji: .flagJm, skinTones: nil),
+            "🇯🇴": EmojiWithSkinTones(baseEmoji: .flagJo, skinTones: nil),
+            "🇯🇵": EmojiWithSkinTones(baseEmoji: .jp, skinTones: nil),
+            "🇰🇪": EmojiWithSkinTones(baseEmoji: .flagKe, skinTones: nil),
+            "🇰🇬": EmojiWithSkinTones(baseEmoji: .flagKg, skinTones: nil),
+            "🇰🇭": EmojiWithSkinTones(baseEmoji: .flagKh, skinTones: nil),
+            "🇰🇮": EmojiWithSkinTones(baseEmoji: .flagKi, skinTones: nil),
+            "🇰🇲": EmojiWithSkinTones(baseEmoji: .flagKm, skinTones: nil),
+            "🇰🇳": EmojiWithSkinTones(baseEmoji: .flagKn, skinTones: nil),
+            "🇰🇵": EmojiWithSkinTones(baseEmoji: .flagKp, skinTones: nil),
+            "🇰🇷": EmojiWithSkinTones(baseEmoji: .kr, skinTones: nil),
+            "🇰🇼": EmojiWithSkinTones(baseEmoji: .flagKw, skinTones: nil),
+            "🇰🇾": EmojiWithSkinTones(baseEmoji: .flagKy, skinTones: nil),
+            "🇰🇿": EmojiWithSkinTones(baseEmoji: .flagKz, skinTones: nil),
+            "🇱🇦": EmojiWithSkinTones(baseEmoji: .flagLa, skinTones: nil),
+            "🇱🇧": EmojiWithSkinTones(baseEmoji: .flagLb, skinTones: nil),
+            "🇱🇨": EmojiWithSkinTones(baseEmoji: .flagLc, skinTones: nil),
+            "🇱🇮": EmojiWithSkinTones(baseEmoji: .flagLi, skinTones: nil),
+            "🇱🇰": EmojiWithSkinTones(baseEmoji: .flagLk, skinTones: nil),
+            "🇱🇷": EmojiWithSkinTones(baseEmoji: .flagLr, skinTones: nil),
+            "🇱🇸": EmojiWithSkinTones(baseEmoji: .flagLs, skinTones: nil),
+            "🇱🇹": EmojiWithSkinTones(baseEmoji: .flagLt, skinTones: nil),
+            "🇱🇺": EmojiWithSkinTones(baseEmoji: .flagLu, skinTones: nil),
+            "🇱🇻": EmojiWithSkinTones(baseEmoji: .flagLv, skinTones: nil),
+            "🇱🇾": EmojiWithSkinTones(baseEmoji: .flagLy, skinTones: nil),
+            "🇲🇦": EmojiWithSkinTones(baseEmoji: .flagMa, skinTones: nil),
+            "🇲🇨": EmojiWithSkinTones(baseEmoji: .flagMc, skinTones: nil),
+            "🇲🇩": EmojiWithSkinTones(baseEmoji: .flagMd, skinTones: nil),
+            "🇲🇪": EmojiWithSkinTones(baseEmoji: .flagMe, skinTones: nil),
+            "🇲🇫": EmojiWithSkinTones(baseEmoji: .flagMf, skinTones: nil),
+            "🇲🇬": EmojiWithSkinTones(baseEmoji: .flagMg, skinTones: nil),
+            "🇲🇭": EmojiWithSkinTones(baseEmoji: .flagMh, skinTones: nil),
+            "🇲🇰": EmojiWithSkinTones(baseEmoji: .flagMk, skinTones: nil),
+            "🇲🇱": EmojiWithSkinTones(baseEmoji: .flagMl, skinTones: nil),
+            "🇲🇲": EmojiWithSkinTones(baseEmoji: .flagMm, skinTones: nil),
+            "🇲🇳": EmojiWithSkinTones(baseEmoji: .flagMn, skinTones: nil),
+            "🇲🇴": EmojiWithSkinTones(baseEmoji: .flagMo, skinTones: nil),
+            "🇲🇵": EmojiWithSkinTones(baseEmoji: .flagMp, skinTones: nil),
+            "🇲🇶": EmojiWithSkinTones(baseEmoji: .flagMq, skinTones: nil),
+            "🇲🇷": EmojiWithSkinTones(baseEmoji: .flagMr, skinTones: nil),
+            "🇲🇸": EmojiWithSkinTones(baseEmoji: .flagMs, skinTones: nil),
+            "🇲🇹": EmojiWithSkinTones(baseEmoji: .flagMt, skinTones: nil),
+            "🇲🇺": EmojiWithSkinTones(baseEmoji: .flagMu, skinTones: nil),
+            "🇲🇻": EmojiWithSkinTones(baseEmoji: .flagMv, skinTones: nil),
+            "🇲🇼": EmojiWithSkinTones(baseEmoji: .flagMw, skinTones: nil),
+            "🇲🇽": EmojiWithSkinTones(baseEmoji: .flagMx, skinTones: nil),
+            "🇲🇾": EmojiWithSkinTones(baseEmoji: .flagMy, skinTones: nil),
+            "🇲🇿": EmojiWithSkinTones(baseEmoji: .flagMz, skinTones: nil),
+            "🇳🇦": EmojiWithSkinTones(baseEmoji: .flagNa, skinTones: nil),
+            "🇳🇨": EmojiWithSkinTones(baseEmoji: .flagNc, skinTones: nil),
+            "🇳🇪": EmojiWithSkinTones(baseEmoji: .flagNe, skinTones: nil),
+            "🇳🇫": EmojiWithSkinTones(baseEmoji: .flagNf, skinTones: nil),
+            "🇳🇬": EmojiWithSkinTones(baseEmoji: .flagNg, skinTones: nil),
+            "🇳🇮": EmojiWithSkinTones(baseEmoji: .flagNi, skinTones: nil),
+            "🇳🇱": EmojiWithSkinTones(baseEmoji: .flagNl, skinTones: nil),
+            "🇳🇴": EmojiWithSkinTones(baseEmoji: .flagNo, skinTones: nil),
+            "🇳🇵": EmojiWithSkinTones(baseEmoji: .flagNp, skinTones: nil),
+            "🇳🇷": EmojiWithSkinTones(baseEmoji: .flagNr, skinTones: nil),
+            "🇳🇺": EmojiWithSkinTones(baseEmoji: .flagNu, skinTones: nil),
+            "🇳🇿": EmojiWithSkinTones(baseEmoji: .flagNz, skinTones: nil),
+            "🇴🇲": EmojiWithSkinTones(baseEmoji: .flagOm, skinTones: nil),
+            "🇵🇦": EmojiWithSkinTones(baseEmoji: .flagPa, skinTones: nil),
+            "🇵🇪": EmojiWithSkinTones(baseEmoji: .flagPe, skinTones: nil),
+            "🇵🇫": EmojiWithSkinTones(baseEmoji: .flagPf, skinTones: nil),
+            "🇵🇬": EmojiWithSkinTones(baseEmoji: .flagPg, skinTones: nil),
+            "🇵🇭": EmojiWithSkinTones(baseEmoji: .flagPh, skinTones: nil),
+            "🇵🇰": EmojiWithSkinTones(baseEmoji: .flagPk, skinTones: nil),
+            "🇵🇱": EmojiWithSkinTones(baseEmoji: .flagPl, skinTones: nil),
+            "🇵🇲": EmojiWithSkinTones(baseEmoji: .flagPm, skinTones: nil),
+            "🇵🇳": EmojiWithSkinTones(baseEmoji: .flagPn, skinTones: nil),
+            "🇵🇷": EmojiWithSkinTones(baseEmoji: .flagPr, skinTones: nil),
+            "🇵🇸": EmojiWithSkinTones(baseEmoji: .flagPs, skinTones: nil),
+            "🇵🇹": EmojiWithSkinTones(baseEmoji: .flagPt, skinTones: nil),
+            "🇵🇼": EmojiWithSkinTones(baseEmoji: .flagPw, skinTones: nil),
+            "🇵🇾": EmojiWithSkinTones(baseEmoji: .flagPy, skinTones: nil),
+            "🇶🇦": EmojiWithSkinTones(baseEmoji: .flagQa, skinTones: nil),
+            "🇷🇪": EmojiWithSkinTones(baseEmoji: .flagRe, skinTones: nil),
+            "🇷🇴": EmojiWithSkinTones(baseEmoji: .flagRo, skinTones: nil),
+            "🇷🇸": EmojiWithSkinTones(baseEmoji: .flagRs, skinTones: nil),
+            "🇷🇺": EmojiWithSkinTones(baseEmoji: .ru, skinTones: nil),
+            "🇷🇼": EmojiWithSkinTones(baseEmoji: .flagRw, skinTones: nil),
+            "🇸🇦": EmojiWithSkinTones(baseEmoji: .flagSa, skinTones: nil),
+            "🇸🇧": EmojiWithSkinTones(baseEmoji: .flagSb, skinTones: nil),
+            "🇸🇨": EmojiWithSkinTones(baseEmoji: .flagSc, skinTones: nil),
+            "🇸🇩": EmojiWithSkinTones(baseEmoji: .flagSd, skinTones: nil),
+            "🇸🇪": EmojiWithSkinTones(baseEmoji: .flagSe, skinTones: nil),
+            "🇸🇬": EmojiWithSkinTones(baseEmoji: .flagSg, skinTones: nil),
+            "🇸🇭": EmojiWithSkinTones(baseEmoji: .flagSh, skinTones: nil),
+            "🇸🇮": EmojiWithSkinTones(baseEmoji: .flagSi, skinTones: nil),
+            "🇸🇯": EmojiWithSkinTones(baseEmoji: .flagSj, skinTones: nil),
+            "🇸🇰": EmojiWithSkinTones(baseEmoji: .flagSk, skinTones: nil),
+            "🇸🇱": EmojiWithSkinTones(baseEmoji: .flagSl, skinTones: nil),
+            "🇸🇲": EmojiWithSkinTones(baseEmoji: .flagSm, skinTones: nil),
+            "🇸🇳": EmojiWithSkinTones(baseEmoji: .flagSn, skinTones: nil),
+            "🇸🇴": EmojiWithSkinTones(baseEmoji: .flagSo, skinTones: nil),
+            "🇸🇷": EmojiWithSkinTones(baseEmoji: .flagSr, skinTones: nil),
+            "🇸🇸": EmojiWithSkinTones(baseEmoji: .flagSs, skinTones: nil),
+            "🇸🇹": EmojiWithSkinTones(baseEmoji: .flagSt, skinTones: nil),
+            "🇸🇻": EmojiWithSkinTones(baseEmoji: .flagSv, skinTones: nil),
+            "🇸🇽": EmojiWithSkinTones(baseEmoji: .flagSx, skinTones: nil),
+            "🇸🇾": EmojiWithSkinTones(baseEmoji: .flagSy, skinTones: nil),
+            "🇸🇿": EmojiWithSkinTones(baseEmoji: .flagSz, skinTones: nil),
+            "🇹🇦": EmojiWithSkinTones(baseEmoji: .flagTa, skinTones: nil),
+            "🇹🇨": EmojiWithSkinTones(baseEmoji: .flagTc, skinTones: nil),
+            "🇹🇩": EmojiWithSkinTones(baseEmoji: .flagTd, skinTones: nil),
+            "🇹🇫": EmojiWithSkinTones(baseEmoji: .flagTf, skinTones: nil),
+            "🇹🇬": EmojiWithSkinTones(baseEmoji: .flagTg, skinTones: nil),
+            "🇹🇭": EmojiWithSkinTones(baseEmoji: .flagTh, skinTones: nil),
+            "🇹🇯": EmojiWithSkinTones(baseEmoji: .flagTj, skinTones: nil),
+            "🇹🇰": EmojiWithSkinTones(baseEmoji: .flagTk, skinTones: nil),
+            "🇹🇱": EmojiWithSkinTones(baseEmoji: .flagTl, skinTones: nil),
+            "🇹🇲": EmojiWithSkinTones(baseEmoji: .flagTm, skinTones: nil),
+            "🇹🇳": EmojiWithSkinTones(baseEmoji: .flagTn, skinTones: nil),
+            "🇹🇴": EmojiWithSkinTones(baseEmoji: .flagTo, skinTones: nil),
+            "🇹🇷": EmojiWithSkinTones(baseEmoji: .flagTr, skinTones: nil),
+            "🇹🇹": EmojiWithSkinTones(baseEmoji: .flagTt, skinTones: nil),
+            "🇹🇻": EmojiWithSkinTones(baseEmoji: .flagTv, skinTones: nil),
+            "🇹🇼": EmojiWithSkinTones(baseEmoji: .flagTw, skinTones: nil),
+            "🇹🇿": EmojiWithSkinTones(baseEmoji: .flagTz, skinTones: nil),
+            "🇺🇦": EmojiWithSkinTones(baseEmoji: .flagUa, skinTones: nil),
+            "🇺🇬": EmojiWithSkinTones(baseEmoji: .flagUg, skinTones: nil),
+            "🇺🇲": EmojiWithSkinTones(baseEmoji: .flagUm, skinTones: nil),
+            "🇺🇳": EmojiWithSkinTones(baseEmoji: .flagUn, skinTones: nil),
+            "🇺🇸": EmojiWithSkinTones(baseEmoji: .us, skinTones: nil),
+            "🇺🇾": EmojiWithSkinTones(baseEmoji: .flagUy, skinTones: nil),
+            "🇺🇿": EmojiWithSkinTones(baseEmoji: .flagUz, skinTones: nil),
+            "🇻🇦": EmojiWithSkinTones(baseEmoji: .flagVa, skinTones: nil),
+            "🇻🇨": EmojiWithSkinTones(baseEmoji: .flagVc, skinTones: nil),
+            "🇻🇪": EmojiWithSkinTones(baseEmoji: .flagVe, skinTones: nil),
+            "🇻🇬": EmojiWithSkinTones(baseEmoji: .flagVg, skinTones: nil),
+            "🇻🇮": EmojiWithSkinTones(baseEmoji: .flagVi, skinTones: nil),
+            "🇻🇳": EmojiWithSkinTones(baseEmoji: .flagVn, skinTones: nil),
+            "🇻🇺": EmojiWithSkinTones(baseEmoji: .flagVu, skinTones: nil),
+            "🇼🇫": EmojiWithSkinTones(baseEmoji: .flagWf, skinTones: nil),
+            "🇼🇸": EmojiWithSkinTones(baseEmoji: .flagWs, skinTones: nil),
+            "🇽🇰": EmojiWithSkinTones(baseEmoji: .flagXk, skinTones: nil),
+            "🇾🇪": EmojiWithSkinTones(baseEmoji: .flagYe, skinTones: nil),
+            "🇾🇹": EmojiWithSkinTones(baseEmoji: .flagYt, skinTones: nil),
+            "🇿🇦": EmojiWithSkinTones(baseEmoji: .flagZa, skinTones: nil),
+            "🇿🇲": EmojiWithSkinTones(baseEmoji: .flagZm, skinTones: nil),
+            "🇿🇼": EmojiWithSkinTones(baseEmoji: .flagZw, skinTones: nil)
+        ]
+        return (lookup[rawValue] ?? EmojiWithSkinTones(unsupportedValue: rawValue))
+    }
+    
+    private static func emojiFrom2558(_ rawValue: String) -> EmojiWithSkinTones {
+        let lookup: [String: EmojiWithSkinTones] = [
+            "🎅🏻": EmojiWithSkinTones(baseEmoji: .santa, skinTones: [.light]),
+            "🎅🏼": EmojiWithSkinTones(baseEmoji: .santa, skinTones: [.mediumLight]),
+            "🎅🏽": EmojiWithSkinTones(baseEmoji: .santa, skinTones: [.medium]),
+            "🎅🏾": EmojiWithSkinTones(baseEmoji: .santa, skinTones: [.mediumDark]),
+            "🎅🏿": EmojiWithSkinTones(baseEmoji: .santa, skinTones: [.dark])
+        ]
+        return (lookup[rawValue] ?? EmojiWithSkinTones(unsupportedValue: rawValue))
+    }
+    
+    private static func emojiFrom2559(_ rawValue: String) -> EmojiWithSkinTones {
+        let lookup: [String: EmojiWithSkinTones] = [
+            "🏃🏻": EmojiWithSkinTones(baseEmoji: .runner, skinTones: [.light]),
+            "🏇🏻": EmojiWithSkinTones(baseEmoji: .horseRacing, skinTones: [.light]),
+            "🏂🏻": EmojiWithSkinTones(baseEmoji: .snowboarder, skinTones: [.light]),
+            "🏌🏻": EmojiWithSkinTones(baseEmoji: .golfer, skinTones: [.light]),
+            "🏄🏻": EmojiWithSkinTones(baseEmoji: .surfer, skinTones: [.light]),
+            "🏊🏻": EmojiWithSkinTones(baseEmoji: .swimmer, skinTones: [.light]),
+            "🏋🏻": EmojiWithSkinTones(baseEmoji: .weightLifter, skinTones: [.light]),
+            "🏃🏼": EmojiWithSkinTones(baseEmoji: .runner, skinTones: [.mediumLight]),
+            "🏇🏼": EmojiWithSkinTones(baseEmoji: .horseRacing, skinTones: [.mediumLight]),
+            "🏂🏼": EmojiWithSkinTones(baseEmoji: .snowboarder, skinTones: [.mediumLight]),
+            "🏌🏼": EmojiWithSkinTones(baseEmoji: .golfer, skinTones: [.mediumLight]),
+            "🏄🏼": EmojiWithSkinTones(baseEmoji: .surfer, skinTones: [.mediumLight]),
+            "🏊🏼": EmojiWithSkinTones(baseEmoji: .swimmer, skinTones: [.mediumLight]),
+            "🏋🏼": EmojiWithSkinTones(baseEmoji: .weightLifter, skinTones: [.mediumLight]),
+            "🏃🏽": EmojiWithSkinTones(baseEmoji: .runner, skinTones: [.medium]),
+            "🏇🏽": EmojiWithSkinTones(baseEmoji: .horseRacing, skinTones: [.medium]),
+            "🏂🏽": EmojiWithSkinTones(baseEmoji: .snowboarder, skinTones: [.medium]),
+            "🏌🏽": EmojiWithSkinTones(baseEmoji: .golfer, skinTones: [.medium]),
+            "🏄🏽": EmojiWithSkinTones(baseEmoji: .surfer, skinTones: [.medium]),
+            "🏊🏽": EmojiWithSkinTones(baseEmoji: .swimmer, skinTones: [.medium]),
+            "🏋🏽": EmojiWithSkinTones(baseEmoji: .weightLifter, skinTones: [.medium]),
+            "🏃🏾": EmojiWithSkinTones(baseEmoji: .runner, skinTones: [.mediumDark]),
+            "🏇🏾": EmojiWithSkinTones(baseEmoji: .horseRacing, skinTones: [.mediumDark]),
+            "🏂🏾": EmojiWithSkinTones(baseEmoji: .snowboarder, skinTones: [.mediumDark]),
+            "🏌🏾": EmojiWithSkinTones(baseEmoji: .golfer, skinTones: [.mediumDark]),
+            "🏄🏾": EmojiWithSkinTones(baseEmoji: .surfer, skinTones: [.mediumDark]),
+            "🏊🏾": EmojiWithSkinTones(baseEmoji: .swimmer, skinTones: [.mediumDark]),
+            "🏋🏾": EmojiWithSkinTones(baseEmoji: .weightLifter, skinTones: [.mediumDark]),
+            "🏃🏿": EmojiWithSkinTones(baseEmoji: .runner, skinTones: [.dark]),
+            "🏇🏿": EmojiWithSkinTones(baseEmoji: .horseRacing, skinTones: [.dark]),
+            "🏂🏿": EmojiWithSkinTones(baseEmoji: .snowboarder, skinTones: [.dark]),
+            "🏌🏿": EmojiWithSkinTones(baseEmoji: .golfer, skinTones: [.dark]),
+            "🏄🏿": EmojiWithSkinTones(baseEmoji: .surfer, skinTones: [.dark]),
+            "🏊🏿": EmojiWithSkinTones(baseEmoji: .swimmer, skinTones: [.dark]),
+            "🏋🏿": EmojiWithSkinTones(baseEmoji: .weightLifter, skinTones: [.dark])
+        ]
+        return (lookup[rawValue] ?? EmojiWithSkinTones(unsupportedValue: rawValue))
+    }
+    
+    private static func emojiFrom2560(_ rawValue: String) -> EmojiWithSkinTones {
+        let lookup: [String: EmojiWithSkinTones] = [
+            "👋🏻": EmojiWithSkinTones(baseEmoji: .wave, skinTones: [.light]),
+            "👌🏻": EmojiWithSkinTones(baseEmoji: .okHand, skinTones: [.light]),
+            "👈🏻": EmojiWithSkinTones(baseEmoji: .pointLeft, skinTones: [.light]),
+            "👉🏻": EmojiWithSkinTones(baseEmoji: .pointRight, skinTones: [.light]),
+            "👆🏻": EmojiWithSkinTones(baseEmoji: .pointUp2, skinTones: [.light]),
+            "👇🏻": EmojiWithSkinTones(baseEmoji: .pointDown, skinTones: [.light]),
+            "👍🏻": EmojiWithSkinTones(baseEmoji: .plusOne, skinTones: [.light]),
+            "👎🏻": EmojiWithSkinTones(baseEmoji: .negativeOne, skinTones: [.light]),
+            "👊🏻": EmojiWithSkinTones(baseEmoji: .facepunch, skinTones: [.light]),
+            "👏🏻": EmojiWithSkinTones(baseEmoji: .clap, skinTones: [.light]),
+            "👐🏻": EmojiWithSkinTones(baseEmoji: .openHands, skinTones: [.light]),
+            "👂🏻": EmojiWithSkinTones(baseEmoji: .ear, skinTones: [.light]),
+            "👃🏻": EmojiWithSkinTones(baseEmoji: .nose, skinTones: [.light]),
+            "👦🏻": EmojiWithSkinTones(baseEmoji: .boy, skinTones: [.light]),
+            "👧🏻": EmojiWithSkinTones(baseEmoji: .girl, skinTones: [.light]),
+            "👨🏻": EmojiWithSkinTones(baseEmoji: .man, skinTones: [.light]),
+            "👋🏼": EmojiWithSkinTones(baseEmoji: .wave, skinTones: [.mediumLight]),
+            "👌🏼": EmojiWithSkinTones(baseEmoji: .okHand, skinTones: [.mediumLight]),
+            "👈🏼": EmojiWithSkinTones(baseEmoji: .pointLeft, skinTones: [.mediumLight]),
+            "👉🏼": EmojiWithSkinTones(baseEmoji: .pointRight, skinTones: [.mediumLight]),
+            "👆🏼": EmojiWithSkinTones(baseEmoji: .pointUp2, skinTones: [.mediumLight]),
+            "👇🏼": EmojiWithSkinTones(baseEmoji: .pointDown, skinTones: [.mediumLight]),
+            "👍🏼": EmojiWithSkinTones(baseEmoji: .plusOne, skinTones: [.mediumLight]),
+            "👎🏼": EmojiWithSkinTones(baseEmoji: .negativeOne, skinTones: [.mediumLight]),
+            "👊🏼": EmojiWithSkinTones(baseEmoji: .facepunch, skinTones: [.mediumLight]),
+            "👏🏼": EmojiWithSkinTones(baseEmoji: .clap, skinTones: [.mediumLight]),
+            "👐🏼": EmojiWithSkinTones(baseEmoji: .openHands, skinTones: [.mediumLight]),
+            "👂🏼": EmojiWithSkinTones(baseEmoji: .ear, skinTones: [.mediumLight]),
+            "👃🏼": EmojiWithSkinTones(baseEmoji: .nose, skinTones: [.mediumLight]),
+            "👦🏼": EmojiWithSkinTones(baseEmoji: .boy, skinTones: [.mediumLight]),
+            "👧🏼": EmojiWithSkinTones(baseEmoji: .girl, skinTones: [.mediumLight]),
+            "👋🏽": EmojiWithSkinTones(baseEmoji: .wave, skinTones: [.medium]),
+            "👌🏽": EmojiWithSkinTones(baseEmoji: .okHand, skinTones: [.medium]),
+            "👈🏽": EmojiWithSkinTones(baseEmoji: .pointLeft, skinTones: [.medium]),
+            "👉🏽": EmojiWithSkinTones(baseEmoji: .pointRight, skinTones: [.medium]),
+            "👆🏽": EmojiWithSkinTones(baseEmoji: .pointUp2, skinTones: [.medium]),
+            "👇🏽": EmojiWithSkinTones(baseEmoji: .pointDown, skinTones: [.medium]),
+            "👍🏽": EmojiWithSkinTones(baseEmoji: .plusOne, skinTones: [.medium]),
+            "👎🏽": EmojiWithSkinTones(baseEmoji: .negativeOne, skinTones: [.medium]),
+            "👊🏽": EmojiWithSkinTones(baseEmoji: .facepunch, skinTones: [.medium]),
+            "👏🏽": EmojiWithSkinTones(baseEmoji: .clap, skinTones: [.medium]),
+            "👐🏽": EmojiWithSkinTones(baseEmoji: .openHands, skinTones: [.medium]),
+            "👂🏽": EmojiWithSkinTones(baseEmoji: .ear, skinTones: [.medium]),
+            "👃🏽": EmojiWithSkinTones(baseEmoji: .nose, skinTones: [.medium]),
+            "👦🏽": EmojiWithSkinTones(baseEmoji: .boy, skinTones: [.medium]),
+            "👋🏾": EmojiWithSkinTones(baseEmoji: .wave, skinTones: [.mediumDark]),
+            "👌🏾": EmojiWithSkinTones(baseEmoji: .okHand, skinTones: [.mediumDark]),
+            "👈🏾": EmojiWithSkinTones(baseEmoji: .pointLeft, skinTones: [.mediumDark]),
+            "👉🏾": EmojiWithSkinTones(baseEmoji: .pointRight, skinTones: [.mediumDark]),
+            "👆🏾": EmojiWithSkinTones(baseEmoji: .pointUp2, skinTones: [.mediumDark]),
+            "👇🏾": EmojiWithSkinTones(baseEmoji: .pointDown, skinTones: [.mediumDark]),
+            "👍🏾": EmojiWithSkinTones(baseEmoji: .plusOne, skinTones: [.mediumDark]),
+            "👎🏾": EmojiWithSkinTones(baseEmoji: .negativeOne, skinTones: [.mediumDark]),
+            "👊🏾": EmojiWithSkinTones(baseEmoji: .facepunch, skinTones: [.mediumDark]),
+            "👏🏾": EmojiWithSkinTones(baseEmoji: .clap, skinTones: [.mediumDark]),
+            "👐🏾": EmojiWithSkinTones(baseEmoji: .openHands, skinTones: [.mediumDark]),
+            "👂🏾": EmojiWithSkinTones(baseEmoji: .ear, skinTones: [.mediumDark]),
+            "👃🏾": EmojiWithSkinTones(baseEmoji: .nose, skinTones: [.mediumDark]),
+            "👋🏿": EmojiWithSkinTones(baseEmoji: .wave, skinTones: [.dark]),
+            "👌🏿": EmojiWithSkinTones(baseEmoji: .okHand, skinTones: [.dark]),
+            "👈🏿": EmojiWithSkinTones(baseEmoji: .pointLeft, skinTones: [.dark]),
+            "👉🏿": EmojiWithSkinTones(baseEmoji: .pointRight, skinTones: [.dark]),
+            "👆🏿": EmojiWithSkinTones(baseEmoji: .pointUp2, skinTones: [.dark]),
+            "👇🏿": EmojiWithSkinTones(baseEmoji: .pointDown, skinTones: [.dark]),
+            "👍🏿": EmojiWithSkinTones(baseEmoji: .plusOne, skinTones: [.dark]),
+            "👎🏿": EmojiWithSkinTones(baseEmoji: .negativeOne, skinTones: [.dark]),
+            "👊🏿": EmojiWithSkinTones(baseEmoji: .facepunch, skinTones: [.dark]),
+            "👏🏿": EmojiWithSkinTones(baseEmoji: .clap, skinTones: [.dark]),
+            "👐🏿": EmojiWithSkinTones(baseEmoji: .openHands, skinTones: [.dark]),
+            "👂🏿": EmojiWithSkinTones(baseEmoji: .ear, skinTones: [.dark]),
+            "👃🏿": EmojiWithSkinTones(baseEmoji: .nose, skinTones: [.dark])
+        ]
+        return (lookup[rawValue] ?? EmojiWithSkinTones(unsupportedValue: rawValue))
+    }
+    
+    private static func emojiFrom2561(_ rawValue: String) -> EmojiWithSkinTones {
+        let lookup: [String: EmojiWithSkinTones] = [
+            "💅🏻": EmojiWithSkinTones(baseEmoji: .nailCare, skinTones: [.light]),
+            "💪🏻": EmojiWithSkinTones(baseEmoji: .muscle, skinTones: [.light]),
+            "👶🏻": EmojiWithSkinTones(baseEmoji: .baby, skinTones: [.light]),
+            "👱🏻": EmojiWithSkinTones(baseEmoji: .personWithBlondHair, skinTones: [.light]),
+            "👩🏻": EmojiWithSkinTones(baseEmoji: .woman, skinTones: [.light]),
+            "👴🏻": EmojiWithSkinTones(baseEmoji: .olderMan, skinTones: [.light]),
+            "👵🏻": EmojiWithSkinTones(baseEmoji: .olderWoman, skinTones: [.light]),
+            "💁🏻": EmojiWithSkinTones(baseEmoji: .informationDeskPerson, skinTones: [.light]),
+            "👮🏻": EmojiWithSkinTones(baseEmoji: .cop, skinTones: [.light]),
+            "💂🏻": EmojiWithSkinTones(baseEmoji: .guardsman, skinTones: [.light]),
+            "👷🏻": EmojiWithSkinTones(baseEmoji: .constructionWorker, skinTones: [.light]),
+            "👸🏻": EmojiWithSkinTones(baseEmoji: .princess, skinTones: [.light]),
+            "👳🏻": EmojiWithSkinTones(baseEmoji: .manWithTurban, skinTones: [.light]),
+            "👲🏻": EmojiWithSkinTones(baseEmoji: .manWithGuaPiMao, skinTones: [.light]),
+            "👰🏻": EmojiWithSkinTones(baseEmoji: .brideWithVeil, skinTones: [.light]),
+            "👼🏻": EmojiWithSkinTones(baseEmoji: .angel, skinTones: [.light]),
+            "💆🏻": EmojiWithSkinTones(baseEmoji: .massage, skinTones: [.light]),
+            "💇🏻": EmojiWithSkinTones(baseEmoji: .haircut, skinTones: [.light]),
+            "💃🏻": EmojiWithSkinTones(baseEmoji: .dancer, skinTones: [.light]),
+            "👭🏻": EmojiWithSkinTones(baseEmoji: .twoWomenHoldingHands, skinTones: [.light]),
+            "👫🏻": EmojiWithSkinTones(baseEmoji: .manAndWomanHoldingHands, skinTones: [.light]),
+            "👬🏻": EmojiWithSkinTones(baseEmoji: .twoMenHoldingHands, skinTones: [.light]),
+            "💏🏻": EmojiWithSkinTones(baseEmoji: .personKissPerson, skinTones: [.light]),
+            "💑🏻": EmojiWithSkinTones(baseEmoji: .personHeartPerson, skinTones: [.light]),
+            "💅🏼": EmojiWithSkinTones(baseEmoji: .nailCare, skinTones: [.mediumLight]),
+            "💪🏼": EmojiWithSkinTones(baseEmoji: .muscle, skinTones: [.mediumLight]),
+            "👶🏼": EmojiWithSkinTones(baseEmoji: .baby, skinTones: [.mediumLight]),
+            "👱🏼": EmojiWithSkinTones(baseEmoji: .personWithBlondHair, skinTones: [.mediumLight]),
+            "👨🏼": EmojiWithSkinTones(baseEmoji: .man, skinTones: [.mediumLight]),
+            "👩🏼": EmojiWithSkinTones(baseEmoji: .woman, skinTones: [.mediumLight]),
+            "👴🏼": EmojiWithSkinTones(baseEmoji: .olderMan, skinTones: [.mediumLight]),
+            "👵🏼": EmojiWithSkinTones(baseEmoji: .olderWoman, skinTones: [.mediumLight]),
+            "💁🏼": EmojiWithSkinTones(baseEmoji: .informationDeskPerson, skinTones: [.mediumLight]),
+            "👮🏼": EmojiWithSkinTones(baseEmoji: .cop, skinTones: [.mediumLight]),
+            "💂🏼": EmojiWithSkinTones(baseEmoji: .guardsman, skinTones: [.mediumLight]),
+            "👷🏼": EmojiWithSkinTones(baseEmoji: .constructionWorker, skinTones: [.mediumLight]),
+            "👸🏼": EmojiWithSkinTones(baseEmoji: .princess, skinTones: [.mediumLight]),
+            "👳🏼": EmojiWithSkinTones(baseEmoji: .manWithTurban, skinTones: [.mediumLight]),
+            "👲🏼": EmojiWithSkinTones(baseEmoji: .manWithGuaPiMao, skinTones: [.mediumLight]),
+            "👰🏼": EmojiWithSkinTones(baseEmoji: .brideWithVeil, skinTones: [.mediumLight]),
+            "👼🏼": EmojiWithSkinTones(baseEmoji: .angel, skinTones: [.mediumLight]),
+            "💆🏼": EmojiWithSkinTones(baseEmoji: .massage, skinTones: [.mediumLight]),
+            "💇🏼": EmojiWithSkinTones(baseEmoji: .haircut, skinTones: [.mediumLight]),
+            "💃🏼": EmojiWithSkinTones(baseEmoji: .dancer, skinTones: [.mediumLight]),
+            "👭🏼": EmojiWithSkinTones(baseEmoji: .twoWomenHoldingHands, skinTones: [.mediumLight]),
+            "👫🏼": EmojiWithSkinTones(baseEmoji: .manAndWomanHoldingHands, skinTones: [.mediumLight]),
+            "👬🏼": EmojiWithSkinTones(baseEmoji: .twoMenHoldingHands, skinTones: [.mediumLight]),
+            "💏🏼": EmojiWithSkinTones(baseEmoji: .personKissPerson, skinTones: [.mediumLight]),
+            "💑🏼": EmojiWithSkinTones(baseEmoji: .personHeartPerson, skinTones: [.mediumLight]),
+            "💅🏽": EmojiWithSkinTones(baseEmoji: .nailCare, skinTones: [.medium]),
+            "💪🏽": EmojiWithSkinTones(baseEmoji: .muscle, skinTones: [.medium]),
+            "👶🏽": EmojiWithSkinTones(baseEmoji: .baby, skinTones: [.medium]),
+            "👧🏽": EmojiWithSkinTones(baseEmoji: .girl, skinTones: [.medium]),
+            "👱🏽": EmojiWithSkinTones(baseEmoji: .personWithBlondHair, skinTones: [.medium]),
+            "👨🏽": EmojiWithSkinTones(baseEmoji: .man, skinTones: [.medium]),
+            "👩🏽": EmojiWithSkinTones(baseEmoji: .woman, skinTones: [.medium]),
+            "👴🏽": EmojiWithSkinTones(baseEmoji: .olderMan, skinTones: [.medium]),
+            "👵🏽": EmojiWithSkinTones(baseEmoji: .olderWoman, skinTones: [.medium]),
+            "💁🏽": EmojiWithSkinTones(baseEmoji: .informationDeskPerson, skinTones: [.medium]),
+            "👮🏽": EmojiWithSkinTones(baseEmoji: .cop, skinTones: [.medium]),
+            "💂🏽": EmojiWithSkinTones(baseEmoji: .guardsman, skinTones: [.medium]),
+            "👷🏽": EmojiWithSkinTones(baseEmoji: .constructionWorker, skinTones: [.medium]),
+            "👸🏽": EmojiWithSkinTones(baseEmoji: .princess, skinTones: [.medium]),
+            "👳🏽": EmojiWithSkinTones(baseEmoji: .manWithTurban, skinTones: [.medium]),
+            "👲🏽": EmojiWithSkinTones(baseEmoji: .manWithGuaPiMao, skinTones: [.medium]),
+            "👰🏽": EmojiWithSkinTones(baseEmoji: .brideWithVeil, skinTones: [.medium]),
+            "👼🏽": EmojiWithSkinTones(baseEmoji: .angel, skinTones: [.medium]),
+            "💆🏽": EmojiWithSkinTones(baseEmoji: .massage, skinTones: [.medium]),
+            "💇🏽": EmojiWithSkinTones(baseEmoji: .haircut, skinTones: [.medium]),
+            "💃🏽": EmojiWithSkinTones(baseEmoji: .dancer, skinTones: [.medium]),
+            "👭🏽": EmojiWithSkinTones(baseEmoji: .twoWomenHoldingHands, skinTones: [.medium]),
+            "👫🏽": EmojiWithSkinTones(baseEmoji: .manAndWomanHoldingHands, skinTones: [.medium]),
+            "👬🏽": EmojiWithSkinTones(baseEmoji: .twoMenHoldingHands, skinTones: [.medium]),
+            "💏🏽": EmojiWithSkinTones(baseEmoji: .personKissPerson, skinTones: [.medium]),
+            "💑🏽": EmojiWithSkinTones(baseEmoji: .personHeartPerson, skinTones: [.medium]),
+            "💅🏾": EmojiWithSkinTones(baseEmoji: .nailCare, skinTones: [.mediumDark]),
+            "💪🏾": EmojiWithSkinTones(baseEmoji: .muscle, skinTones: [.mediumDark]),
+            "👶🏾": EmojiWithSkinTones(baseEmoji: .baby, skinTones: [.mediumDark]),
+            "👦🏾": EmojiWithSkinTones(baseEmoji: .boy, skinTones: [.mediumDark]),
+            "👧🏾": EmojiWithSkinTones(baseEmoji: .girl, skinTones: [.mediumDark]),
+            "👱🏾": EmojiWithSkinTones(baseEmoji: .personWithBlondHair, skinTones: [.mediumDark]),
+            "👨🏾": EmojiWithSkinTones(baseEmoji: .man, skinTones: [.mediumDark]),
+            "👩🏾": EmojiWithSkinTones(baseEmoji: .woman, skinTones: [.mediumDark]),
+            "👴🏾": EmojiWithSkinTones(baseEmoji: .olderMan, skinTones: [.mediumDark]),
+            "👵🏾": EmojiWithSkinTones(baseEmoji: .olderWoman, skinTones: [.mediumDark]),
+            "💁🏾": EmojiWithSkinTones(baseEmoji: .informationDeskPerson, skinTones: [.mediumDark]),
+            "👮🏾": EmojiWithSkinTones(baseEmoji: .cop, skinTones: [.mediumDark]),
+            "💂🏾": EmojiWithSkinTones(baseEmoji: .guardsman, skinTones: [.mediumDark]),
+            "👷🏾": EmojiWithSkinTones(baseEmoji: .constructionWorker, skinTones: [.mediumDark]),
+            "👸🏾": EmojiWithSkinTones(baseEmoji: .princess, skinTones: [.mediumDark]),
+            "👳🏾": EmojiWithSkinTones(baseEmoji: .manWithTurban, skinTones: [.mediumDark]),
+            "👲🏾": EmojiWithSkinTones(baseEmoji: .manWithGuaPiMao, skinTones: [.mediumDark]),
+            "👰🏾": EmojiWithSkinTones(baseEmoji: .brideWithVeil, skinTones: [.mediumDark]),
+            "👼🏾": EmojiWithSkinTones(baseEmoji: .angel, skinTones: [.mediumDark]),
+            "💆🏾": EmojiWithSkinTones(baseEmoji: .massage, skinTones: [.mediumDark]),
+            "💇🏾": EmojiWithSkinTones(baseEmoji: .haircut, skinTones: [.mediumDark]),
+            "💃🏾": EmojiWithSkinTones(baseEmoji: .dancer, skinTones: [.mediumDark]),
+            "👭🏾": EmojiWithSkinTones(baseEmoji: .twoWomenHoldingHands, skinTones: [.mediumDark]),
+            "👫🏾": EmojiWithSkinTones(baseEmoji: .manAndWomanHoldingHands, skinTones: [.mediumDark]),
+            "👬🏾": EmojiWithSkinTones(baseEmoji: .twoMenHoldingHands, skinTones: [.mediumDark]),
+            "💏🏾": EmojiWithSkinTones(baseEmoji: .personKissPerson, skinTones: [.mediumDark]),
+            "💑🏾": EmojiWithSkinTones(baseEmoji: .personHeartPerson, skinTones: [.mediumDark]),
+            "💅🏿": EmojiWithSkinTones(baseEmoji: .nailCare, skinTones: [.dark]),
+            "💪🏿": EmojiWithSkinTones(baseEmoji: .muscle, skinTones: [.dark]),
+            "👶🏿": EmojiWithSkinTones(baseEmoji: .baby, skinTones: [.dark]),
+            "👦🏿": EmojiWithSkinTones(baseEmoji: .boy, skinTones: [.dark]),
+            "👧🏿": EmojiWithSkinTones(baseEmoji: .girl, skinTones: [.dark]),
+            "👱🏿": EmojiWithSkinTones(baseEmoji: .personWithBlondHair, skinTones: [.dark]),
+            "👨🏿": EmojiWithSkinTones(baseEmoji: .man, skinTones: [.dark]),
+            "👩🏿": EmojiWithSkinTones(baseEmoji: .woman, skinTones: [.dark]),
+            "👴🏿": EmojiWithSkinTones(baseEmoji: .olderMan, skinTones: [.dark]),
+            "👵🏿": EmojiWithSkinTones(baseEmoji: .olderWoman, skinTones: [.dark]),
+            "💁🏿": EmojiWithSkinTones(baseEmoji: .informationDeskPerson, skinTones: [.dark]),
+            "👮🏿": EmojiWithSkinTones(baseEmoji: .cop, skinTones: [.dark]),
+            "💂🏿": EmojiWithSkinTones(baseEmoji: .guardsman, skinTones: [.dark]),
+            "👷🏿": EmojiWithSkinTones(baseEmoji: .constructionWorker, skinTones: [.dark]),
+            "👸🏿": EmojiWithSkinTones(baseEmoji: .princess, skinTones: [.dark]),
+            "👳🏿": EmojiWithSkinTones(baseEmoji: .manWithTurban, skinTones: [.dark]),
+            "👲🏿": EmojiWithSkinTones(baseEmoji: .manWithGuaPiMao, skinTones: [.dark]),
+            "👰🏿": EmojiWithSkinTones(baseEmoji: .brideWithVeil, skinTones: [.dark]),
+            "👼🏿": EmojiWithSkinTones(baseEmoji: .angel, skinTones: [.dark]),
+            "💆🏿": EmojiWithSkinTones(baseEmoji: .massage, skinTones: [.dark]),
+            "💇🏿": EmojiWithSkinTones(baseEmoji: .haircut, skinTones: [.dark]),
+            "💃🏿": EmojiWithSkinTones(baseEmoji: .dancer, skinTones: [.dark]),
+            "👭🏿": EmojiWithSkinTones(baseEmoji: .twoWomenHoldingHands, skinTones: [.dark]),
+            "👫🏿": EmojiWithSkinTones(baseEmoji: .manAndWomanHoldingHands, skinTones: [.dark]),
+            "👬🏿": EmojiWithSkinTones(baseEmoji: .twoMenHoldingHands, skinTones: [.dark]),
+            "💏🏿": EmojiWithSkinTones(baseEmoji: .personKissPerson, skinTones: [.dark]),
+            "💑🏿": EmojiWithSkinTones(baseEmoji: .personHeartPerson, skinTones: [.dark])
+        ]
+        return (lookup[rawValue] ?? EmojiWithSkinTones(unsupportedValue: rawValue))
+    }
+    
+    private static func emojiFrom2563(_ rawValue: String) -> EmojiWithSkinTones {
+        let lookup: [String: EmojiWithSkinTones] = [
+            "🖐🏻": EmojiWithSkinTones(baseEmoji: .raisedHandWithFingersSplayed, skinTones: [.light]),
+            "🕵🏻": EmojiWithSkinTones(baseEmoji: .sleuthOrSpy, skinTones: [.light]),
+            "🕺🏻": EmojiWithSkinTones(baseEmoji: .manDancing, skinTones: [.light]),
+            "🕴🏻": EmojiWithSkinTones(baseEmoji: .manInBusinessSuitLevitating, skinTones: [.light]),
+            "🖐🏼": EmojiWithSkinTones(baseEmoji: .raisedHandWithFingersSplayed, skinTones: [.mediumLight]),
+            "🕵🏼": EmojiWithSkinTones(baseEmoji: .sleuthOrSpy, skinTones: [.mediumLight]),
+            "🕺🏼": EmojiWithSkinTones(baseEmoji: .manDancing, skinTones: [.mediumLight]),
+            "🕴🏼": EmojiWithSkinTones(baseEmoji: .manInBusinessSuitLevitating, skinTones: [.mediumLight]),
+            "🖐🏽": EmojiWithSkinTones(baseEmoji: .raisedHandWithFingersSplayed, skinTones: [.medium]),
+            "🕵🏽": EmojiWithSkinTones(baseEmoji: .sleuthOrSpy, skinTones: [.medium]),
+            "🕺🏽": EmojiWithSkinTones(baseEmoji: .manDancing, skinTones: [.medium]),
+            "🕴🏽": EmojiWithSkinTones(baseEmoji: .manInBusinessSuitLevitating, skinTones: [.medium]),
+            "🖐🏾": EmojiWithSkinTones(baseEmoji: .raisedHandWithFingersSplayed, skinTones: [.mediumDark]),
+            "🕵🏾": EmojiWithSkinTones(baseEmoji: .sleuthOrSpy, skinTones: [.mediumDark]),
+            "🕺🏾": EmojiWithSkinTones(baseEmoji: .manDancing, skinTones: [.mediumDark]),
+            "🕴🏾": EmojiWithSkinTones(baseEmoji: .manInBusinessSuitLevitating, skinTones: [.mediumDark]),
+            "🖐🏿": EmojiWithSkinTones(baseEmoji: .raisedHandWithFingersSplayed, skinTones: [.dark]),
+            "🕵🏿": EmojiWithSkinTones(baseEmoji: .sleuthOrSpy, skinTones: [.dark]),
+            "🕺🏿": EmojiWithSkinTones(baseEmoji: .manDancing, skinTones: [.dark]),
+            "🕴🏿": EmojiWithSkinTones(baseEmoji: .manInBusinessSuitLevitating, skinTones: [.dark])
+        ]
+        return (lookup[rawValue] ?? EmojiWithSkinTones(unsupportedValue: rawValue))
+    }
+    
+    private static func emojiFrom2564(_ rawValue: String) -> EmojiWithSkinTones {
+        let lookup: [String: EmojiWithSkinTones] = [
+            "🖖🏻": EmojiWithSkinTones(baseEmoji: .spockHand, skinTones: [.light]),
+            "🖕🏻": EmojiWithSkinTones(baseEmoji: .middleFinger, skinTones: [.light]),
+            "🖖🏼": EmojiWithSkinTones(baseEmoji: .spockHand, skinTones: [.mediumLight]),
+            "🖕🏼": EmojiWithSkinTones(baseEmoji: .middleFinger, skinTones: [.mediumLight]),
+            "🖖🏽": EmojiWithSkinTones(baseEmoji: .spockHand, skinTones: [.medium]),
+            "🖕🏽": EmojiWithSkinTones(baseEmoji: .middleFinger, skinTones: [.medium]),
+            "🖖🏾": EmojiWithSkinTones(baseEmoji: .spockHand, skinTones: [.mediumDark]),
+            "🖕🏾": EmojiWithSkinTones(baseEmoji: .middleFinger, skinTones: [.mediumDark]),
+            "🖖🏿": EmojiWithSkinTones(baseEmoji: .spockHand, skinTones: [.dark]),
+            "🖕🏿": EmojiWithSkinTones(baseEmoji: .middleFinger, skinTones: [.dark])
+        ]
+        return (lookup[rawValue] ?? EmojiWithSkinTones(unsupportedValue: rawValue))
+    }
+    
+    private static func emojiFrom2565(_ rawValue: String) -> EmojiWithSkinTones {
+        let lookup: [String: EmojiWithSkinTones] = [
+            "🙌🏻": EmojiWithSkinTones(baseEmoji: .raisedHands, skinTones: [.light]),
+            "🙏🏻": EmojiWithSkinTones(baseEmoji: .pray, skinTones: [.light]),
+            "🙍🏻": EmojiWithSkinTones(baseEmoji: .personFrowning, skinTones: [.light]),
+            "🙎🏻": EmojiWithSkinTones(baseEmoji: .personWithPoutingFace, skinTones: [.light]),
+            "🙅🏻": EmojiWithSkinTones(baseEmoji: .noGood, skinTones: [.light]),
+            "🙆🏻": EmojiWithSkinTones(baseEmoji: .okWoman, skinTones: [.light]),
+            "🙋🏻": EmojiWithSkinTones(baseEmoji: .raisingHand, skinTones: [.light]),
+            "🙇🏻": EmojiWithSkinTones(baseEmoji: .bow, skinTones: [.light]),
+            "🙌🏼": EmojiWithSkinTones(baseEmoji: .raisedHands, skinTones: [.mediumLight]),
+            "🙏🏼": EmojiWithSkinTones(baseEmoji: .pray, skinTones: [.mediumLight]),
+            "🙍🏼": EmojiWithSkinTones(baseEmoji: .personFrowning, skinTones: [.mediumLight]),
+            "🙎🏼": EmojiWithSkinTones(baseEmoji: .personWithPoutingFace, skinTones: [.mediumLight]),
+            "🙅🏼": EmojiWithSkinTones(baseEmoji: .noGood, skinTones: [.mediumLight]),
+            "🙆🏼": EmojiWithSkinTones(baseEmoji: .okWoman, skinTones: [.mediumLight]),
+            "🙋🏼": EmojiWithSkinTones(baseEmoji: .raisingHand, skinTones: [.mediumLight]),
+            "🙇🏼": EmojiWithSkinTones(baseEmoji: .bow, skinTones: [.mediumLight]),
+            "🙌🏽": EmojiWithSkinTones(baseEmoji: .raisedHands, skinTones: [.medium]),
+            "🙏🏽": EmojiWithSkinTones(baseEmoji: .pray, skinTones: [.medium]),
+            "🙍🏽": EmojiWithSkinTones(baseEmoji: .personFrowning, skinTones: [.medium]),
+            "🙎🏽": EmojiWithSkinTones(baseEmoji: .personWithPoutingFace, skinTones: [.medium]),
+            "🙅🏽": EmojiWithSkinTones(baseEmoji: .noGood, skinTones: [.medium]),
+            "🙆🏽": EmojiWithSkinTones(baseEmoji: .okWoman, skinTones: [.medium]),
+            "🙋🏽": EmojiWithSkinTones(baseEmoji: .raisingHand, skinTones: [.medium]),
+            "🙇🏽": EmojiWithSkinTones(baseEmoji: .bow, skinTones: [.medium]),
+            "🙌🏾": EmojiWithSkinTones(baseEmoji: .raisedHands, skinTones: [.mediumDark]),
+            "🙏🏾": EmojiWithSkinTones(baseEmoji: .pray, skinTones: [.mediumDark]),
+            "🙍🏾": EmojiWithSkinTones(baseEmoji: .personFrowning, skinTones: [.mediumDark]),
+            "🙎🏾": EmojiWithSkinTones(baseEmoji: .personWithPoutingFace, skinTones: [.mediumDark]),
+            "🙅🏾": EmojiWithSkinTones(baseEmoji: .noGood, skinTones: [.mediumDark]),
+            "🙆🏾": EmojiWithSkinTones(baseEmoji: .okWoman, skinTones: [.mediumDark]),
+            "🙋🏾": EmojiWithSkinTones(baseEmoji: .raisingHand, skinTones: [.mediumDark]),
+            "🙇🏾": EmojiWithSkinTones(baseEmoji: .bow, skinTones: [.mediumDark]),
+            "🙌🏿": EmojiWithSkinTones(baseEmoji: .raisedHands, skinTones: [.dark]),
+            "🙏🏿": EmojiWithSkinTones(baseEmoji: .pray, skinTones: [.dark]),
+            "🙍🏿": EmojiWithSkinTones(baseEmoji: .personFrowning, skinTones: [.dark]),
+            "🙎🏿": EmojiWithSkinTones(baseEmoji: .personWithPoutingFace, skinTones: [.dark]),
+            "🙅🏿": EmojiWithSkinTones(baseEmoji: .noGood, skinTones: [.dark]),
+            "🙆🏿": EmojiWithSkinTones(baseEmoji: .okWoman, skinTones: [.dark]),
+            "🙋🏿": EmojiWithSkinTones(baseEmoji: .raisingHand, skinTones: [.dark]),
+            "🙇🏿": EmojiWithSkinTones(baseEmoji: .bow, skinTones: [.dark])
+        ]
+        return (lookup[rawValue] ?? EmojiWithSkinTones(unsupportedValue: rawValue))
+    }
+    
+    private static func emojiFrom2566(_ rawValue: String) -> EmojiWithSkinTones {
+        let lookup: [String: EmojiWithSkinTones] = [
+            "🚶🏻": EmojiWithSkinTones(baseEmoji: .walking, skinTones: [.light]),
+            "🚣🏻": EmojiWithSkinTones(baseEmoji: .rowboat, skinTones: [.light]),
+            "🚴🏻": EmojiWithSkinTones(baseEmoji: .bicyclist, skinTones: [.light]),
+            "🚵🏻": EmojiWithSkinTones(baseEmoji: .mountainBicyclist, skinTones: [.light]),
+            "🛀🏻": EmojiWithSkinTones(baseEmoji: .bath, skinTones: [.light]),
+            "🚶🏼": EmojiWithSkinTones(baseEmoji: .walking, skinTones: [.mediumLight]),
+            "🚣🏼": EmojiWithSkinTones(baseEmoji: .rowboat, skinTones: [.mediumLight]),
+            "🚴🏼": EmojiWithSkinTones(baseEmoji: .bicyclist, skinTones: [.mediumLight]),
+            "🚵🏼": EmojiWithSkinTones(baseEmoji: .mountainBicyclist, skinTones: [.mediumLight]),
+            "🚶🏽": EmojiWithSkinTones(baseEmoji: .walking, skinTones: [.medium]),
+            "🚣🏽": EmojiWithSkinTones(baseEmoji: .rowboat, skinTones: [.medium]),
+            "🚴🏽": EmojiWithSkinTones(baseEmoji: .bicyclist, skinTones: [.medium]),
+            "🚵🏽": EmojiWithSkinTones(baseEmoji: .mountainBicyclist, skinTones: [.medium]),
+            "🚶🏾": EmojiWithSkinTones(baseEmoji: .walking, skinTones: [.mediumDark]),
+            "🚣🏾": EmojiWithSkinTones(baseEmoji: .rowboat, skinTones: [.mediumDark]),
+            "🚴🏾": EmojiWithSkinTones(baseEmoji: .bicyclist, skinTones: [.mediumDark]),
+            "🚵🏾": EmojiWithSkinTones(baseEmoji: .mountainBicyclist, skinTones: [.mediumDark]),
+            "🚶🏿": EmojiWithSkinTones(baseEmoji: .walking, skinTones: [.dark]),
+            "🚣🏿": EmojiWithSkinTones(baseEmoji: .rowboat, skinTones: [.dark]),
+            "🚴🏿": EmojiWithSkinTones(baseEmoji: .bicyclist, skinTones: [.dark]),
+            "🚵🏿": EmojiWithSkinTones(baseEmoji: .mountainBicyclist, skinTones: [.dark])
+        ]
+        return (lookup[rawValue] ?? EmojiWithSkinTones(unsupportedValue: rawValue))
+    }
+    
+    private static func emojiFrom2567(_ rawValue: String) -> EmojiWithSkinTones {
+        let lookup: [String: EmojiWithSkinTones] = [
+            "🛌🏻": EmojiWithSkinTones(baseEmoji: .sleepingAccommodation, skinTones: [.light]),
+            "🛀🏼": EmojiWithSkinTones(baseEmoji: .bath, skinTones: [.mediumLight]),
+            "🛌🏼": EmojiWithSkinTones(baseEmoji: .sleepingAccommodation, skinTones: [.mediumLight]),
+            "🛀🏽": EmojiWithSkinTones(baseEmoji: .bath, skinTones: [.medium]),
+            "🛌🏽": EmojiWithSkinTones(baseEmoji: .sleepingAccommodation, skinTones: [.medium]),
+            "🛀🏾": EmojiWithSkinTones(baseEmoji: .bath, skinTones: [.mediumDark]),
+            "🛌🏾": EmojiWithSkinTones(baseEmoji: .sleepingAccommodation, skinTones: [.mediumDark]),
+            "🛀🏿": EmojiWithSkinTones(baseEmoji: .bath, skinTones: [.dark]),
+            "🛌🏿": EmojiWithSkinTones(baseEmoji: .sleepingAccommodation, skinTones: [.dark])
+        ]
+        return (lookup[rawValue] ?? EmojiWithSkinTones(unsupportedValue: rawValue))
+    }
+    
+    private static func emojiFrom2572(_ rawValue: String) -> EmojiWithSkinTones {
+        let lookup: [String: EmojiWithSkinTones] = [
+            "🤌🏻": EmojiWithSkinTones(baseEmoji: .pinchedFingers, skinTones: [.light]),
+            "🤏🏻": EmojiWithSkinTones(baseEmoji: .pinchingHand, skinTones: [.light]),
+            "🤘🏻": EmojiWithSkinTones(baseEmoji: .theHorns, skinTones: [.light]),
+            "🤌🏼": EmojiWithSkinTones(baseEmoji: .pinchedFingers, skinTones: [.mediumLight]),
+            "🤏🏼": EmojiWithSkinTones(baseEmoji: .pinchingHand, skinTones: [.mediumLight]),
+            "🤌🏽": EmojiWithSkinTones(baseEmoji: .pinchedFingers, skinTones: [.medium]),
+            "🤏🏽": EmojiWithSkinTones(baseEmoji: .pinchingHand, skinTones: [.medium]),
+            "🤌🏾": EmojiWithSkinTones(baseEmoji: .pinchedFingers, skinTones: [.mediumDark]),
+            "🤏🏾": EmojiWithSkinTones(baseEmoji: .pinchingHand, skinTones: [.mediumDark]),
+            "🤌🏿": EmojiWithSkinTones(baseEmoji: .pinchedFingers, skinTones: [.dark]),
+            "🤏🏿": EmojiWithSkinTones(baseEmoji: .pinchingHand, skinTones: [.dark])
+        ]
+        return (lookup[rawValue] ?? EmojiWithSkinTones(unsupportedValue: rawValue))
+    }
+    
+    private static func emojiFrom2573(_ rawValue: String) -> EmojiWithSkinTones {
+        let lookup: [String: EmojiWithSkinTones] = [
+            "🤚🏻": EmojiWithSkinTones(baseEmoji: .raisedBackOfHand, skinTones: [.light]),
+            "🤞🏻": EmojiWithSkinTones(baseEmoji: .crossedFingers, skinTones: [.light]),
+            "🤟🏻": EmojiWithSkinTones(baseEmoji: .iLoveYouHandSign, skinTones: [.light]),
+            "🤙🏻": EmojiWithSkinTones(baseEmoji: .callMeHand, skinTones: [.light]),
+            "🤛🏻": EmojiWithSkinTones(baseEmoji: .leftFacingFist, skinTones: [.light]),
+            "🤜🏻": EmojiWithSkinTones(baseEmoji: .rightFacingFist, skinTones: [.light]),
+            "🤲🏻": EmojiWithSkinTones(baseEmoji: .palmsUpTogether, skinTones: [.light]),
+            "🤝🏻": EmojiWithSkinTones(baseEmoji: .handshake, skinTones: [.light]),
+            "🤳🏻": EmojiWithSkinTones(baseEmoji: .selfie, skinTones: [.light]),
+            "🤦🏻": EmojiWithSkinTones(baseEmoji: .facePalm, skinTones: [.light]),
+            "🤷🏻": EmojiWithSkinTones(baseEmoji: .shrug, skinTones: [.light]),
+            "🥷🏻": EmojiWithSkinTones(baseEmoji: .ninja, skinTones: [.light]),
+            "🤴🏻": EmojiWithSkinTones(baseEmoji: .prince, skinTones: [.light]),
+            "🤵🏻": EmojiWithSkinTones(baseEmoji: .personInTuxedo, skinTones: [.light]),
+            "🤰🏻": EmojiWithSkinTones(baseEmoji: .pregnantWoman, skinTones: [.light]),
+            "🤱🏻": EmojiWithSkinTones(baseEmoji: .breastFeeding, skinTones: [.light]),
+            "🤶🏻": EmojiWithSkinTones(baseEmoji: .mrsClaus, skinTones: [.light]),
+            "🤸🏻": EmojiWithSkinTones(baseEmoji: .personDoingCartwheel, skinTones: [.light]),
+            "🤽🏻": EmojiWithSkinTones(baseEmoji: .waterPolo, skinTones: [.light]),
+            "🤾🏻": EmojiWithSkinTones(baseEmoji: .handball, skinTones: [.light]),
+            "🤹🏻": EmojiWithSkinTones(baseEmoji: .juggling, skinTones: [.light]),
+            "🤚🏼": EmojiWithSkinTones(baseEmoji: .raisedBackOfHand, skinTones: [.mediumLight]),
+            "🤞🏼": EmojiWithSkinTones(baseEmoji: .crossedFingers, skinTones: [.mediumLight]),
+            "🤟🏼": EmojiWithSkinTones(baseEmoji: .iLoveYouHandSign, skinTones: [.mediumLight]),
+            "🤘🏼": EmojiWithSkinTones(baseEmoji: .theHorns, skinTones: [.mediumLight]),
+            "🤙🏼": EmojiWithSkinTones(baseEmoji: .callMeHand, skinTones: [.mediumLight]),
+            "🤛🏼": EmojiWithSkinTones(baseEmoji: .leftFacingFist, skinTones: [.mediumLight]),
+            "🤜🏼": EmojiWithSkinTones(baseEmoji: .rightFacingFist, skinTones: [.mediumLight]),
+            "🤲🏼": EmojiWithSkinTones(baseEmoji: .palmsUpTogether, skinTones: [.mediumLight]),
+            "🤝🏼": EmojiWithSkinTones(baseEmoji: .handshake, skinTones: [.mediumLight]),
+            "🤳🏼": EmojiWithSkinTones(baseEmoji: .selfie, skinTones: [.mediumLight]),
+            "🤦🏼": EmojiWithSkinTones(baseEmoji: .facePalm, skinTones: [.mediumLight]),
+            "🤷🏼": EmojiWithSkinTones(baseEmoji: .shrug, skinTones: [.mediumLight]),
+            "🥷🏼": EmojiWithSkinTones(baseEmoji: .ninja, skinTones: [.mediumLight]),
+            "🤴🏼": EmojiWithSkinTones(baseEmoji: .prince, skinTones: [.mediumLight]),
+            "🤵🏼": EmojiWithSkinTones(baseEmoji: .personInTuxedo, skinTones: [.mediumLight]),
+            "🤰🏼": EmojiWithSkinTones(baseEmoji: .pregnantWoman, skinTones: [.mediumLight]),
+            "🤱🏼": EmojiWithSkinTones(baseEmoji: .breastFeeding, skinTones: [.mediumLight]),
+            "🤶🏼": EmojiWithSkinTones(baseEmoji: .mrsClaus, skinTones: [.mediumLight]),
+            "🤸🏼": EmojiWithSkinTones(baseEmoji: .personDoingCartwheel, skinTones: [.mediumLight]),
+            "🤽🏼": EmojiWithSkinTones(baseEmoji: .waterPolo, skinTones: [.mediumLight]),
+            "🤾🏼": EmojiWithSkinTones(baseEmoji: .handball, skinTones: [.mediumLight]),
+            "🤹🏼": EmojiWithSkinTones(baseEmoji: .juggling, skinTones: [.mediumLight]),
+            "🤚🏽": EmojiWithSkinTones(baseEmoji: .raisedBackOfHand, skinTones: [.medium]),
+            "🤞🏽": EmojiWithSkinTones(baseEmoji: .crossedFingers, skinTones: [.medium]),
+            "🤟🏽": EmojiWithSkinTones(baseEmoji: .iLoveYouHandSign, skinTones: [.medium]),
+            "🤘🏽": EmojiWithSkinTones(baseEmoji: .theHorns, skinTones: [.medium]),
+            "🤙🏽": EmojiWithSkinTones(baseEmoji: .callMeHand, skinTones: [.medium]),
+            "🤛🏽": EmojiWithSkinTones(baseEmoji: .leftFacingFist, skinTones: [.medium]),
+            "🤜🏽": EmojiWithSkinTones(baseEmoji: .rightFacingFist, skinTones: [.medium]),
+            "🤲🏽": EmojiWithSkinTones(baseEmoji: .palmsUpTogether, skinTones: [.medium]),
+            "🤝🏽": EmojiWithSkinTones(baseEmoji: .handshake, skinTones: [.medium]),
+            "🤳🏽": EmojiWithSkinTones(baseEmoji: .selfie, skinTones: [.medium]),
+            "🤦🏽": EmojiWithSkinTones(baseEmoji: .facePalm, skinTones: [.medium]),
+            "🤷🏽": EmojiWithSkinTones(baseEmoji: .shrug, skinTones: [.medium]),
+            "🥷🏽": EmojiWithSkinTones(baseEmoji: .ninja, skinTones: [.medium]),
+            "🤴🏽": EmojiWithSkinTones(baseEmoji: .prince, skinTones: [.medium]),
+            "🤵🏽": EmojiWithSkinTones(baseEmoji: .personInTuxedo, skinTones: [.medium]),
+            "🤰🏽": EmojiWithSkinTones(baseEmoji: .pregnantWoman, skinTones: [.medium]),
+            "🤱🏽": EmojiWithSkinTones(baseEmoji: .breastFeeding, skinTones: [.medium]),
+            "🤶🏽": EmojiWithSkinTones(baseEmoji: .mrsClaus, skinTones: [.medium]),
+            "🤸🏽": EmojiWithSkinTones(baseEmoji: .personDoingCartwheel, skinTones: [.medium]),
+            "🤽🏽": EmojiWithSkinTones(baseEmoji: .waterPolo, skinTones: [.medium]),
+            "🤾🏽": EmojiWithSkinTones(baseEmoji: .handball, skinTones: [.medium]),
+            "🤹🏽": EmojiWithSkinTones(baseEmoji: .juggling, skinTones: [.medium]),
+            "🤚🏾": EmojiWithSkinTones(baseEmoji: .raisedBackOfHand, skinTones: [.mediumDark]),
+            "🤞🏾": EmojiWithSkinTones(baseEmoji: .crossedFingers, skinTones: [.mediumDark]),
+            "🤟🏾": EmojiWithSkinTones(baseEmoji: .iLoveYouHandSign, skinTones: [.mediumDark]),
+            "🤘🏾": EmojiWithSkinTones(baseEmoji: .theHorns, skinTones: [.mediumDark]),
+            "🤙🏾": EmojiWithSkinTones(baseEmoji: .callMeHand, skinTones: [.mediumDark]),
+            "🤛🏾": EmojiWithSkinTones(baseEmoji: .leftFacingFist, skinTones: [.mediumDark]),
+            "🤜🏾": EmojiWithSkinTones(baseEmoji: .rightFacingFist, skinTones: [.mediumDark]),
+            "🤲🏾": EmojiWithSkinTones(baseEmoji: .palmsUpTogether, skinTones: [.mediumDark]),
+            "🤝🏾": EmojiWithSkinTones(baseEmoji: .handshake, skinTones: [.mediumDark]),
+            "🤳🏾": EmojiWithSkinTones(baseEmoji: .selfie, skinTones: [.mediumDark]),
+            "🤦🏾": EmojiWithSkinTones(baseEmoji: .facePalm, skinTones: [.mediumDark]),
+            "🤷🏾": EmojiWithSkinTones(baseEmoji: .shrug, skinTones: [.mediumDark]),
+            "🥷🏾": EmojiWithSkinTones(baseEmoji: .ninja, skinTones: [.mediumDark]),
+            "🤴🏾": EmojiWithSkinTones(baseEmoji: .prince, skinTones: [.mediumDark]),
+            "🤵🏾": EmojiWithSkinTones(baseEmoji: .personInTuxedo, skinTones: [.mediumDark]),
+            "🤰🏾": EmojiWithSkinTones(baseEmoji: .pregnantWoman, skinTones: [.mediumDark]),
+            "🤱🏾": EmojiWithSkinTones(baseEmoji: .breastFeeding, skinTones: [.mediumDark]),
+            "🤶🏾": EmojiWithSkinTones(baseEmoji: .mrsClaus, skinTones: [.mediumDark]),
+            "🤸🏾": EmojiWithSkinTones(baseEmoji: .personDoingCartwheel, skinTones: [.mediumDark]),
+            "🤽🏾": EmojiWithSkinTones(baseEmoji: .waterPolo, skinTones: [.mediumDark]),
+            "🤾🏾": EmojiWithSkinTones(baseEmoji: .handball, skinTones: [.mediumDark]),
+            "🤹🏾": EmojiWithSkinTones(baseEmoji: .juggling, skinTones: [.mediumDark]),
+            "🤚🏿": EmojiWithSkinTones(baseEmoji: .raisedBackOfHand, skinTones: [.dark]),
+            "🤞🏿": EmojiWithSkinTones(baseEmoji: .crossedFingers, skinTones: [.dark]),
+            "🤟🏿": EmojiWithSkinTones(baseEmoji: .iLoveYouHandSign, skinTones: [.dark]),
+            "🤘🏿": EmojiWithSkinTones(baseEmoji: .theHorns, skinTones: [.dark]),
+            "🤙🏿": EmojiWithSkinTones(baseEmoji: .callMeHand, skinTones: [.dark]),
+            "🤛🏿": EmojiWithSkinTones(baseEmoji: .leftFacingFist, skinTones: [.dark]),
+            "🤜🏿": EmojiWithSkinTones(baseEmoji: .rightFacingFist, skinTones: [.dark]),
+            "🤲🏿": EmojiWithSkinTones(baseEmoji: .palmsUpTogether, skinTones: [.dark]),
+            "🤝🏿": EmojiWithSkinTones(baseEmoji: .handshake, skinTones: [.dark]),
+            "🤳🏿": EmojiWithSkinTones(baseEmoji: .selfie, skinTones: [.dark]),
+            "🤦🏿": EmojiWithSkinTones(baseEmoji: .facePalm, skinTones: [.dark]),
+            "🤷🏿": EmojiWithSkinTones(baseEmoji: .shrug, skinTones: [.dark]),
+            "🥷🏿": EmojiWithSkinTones(baseEmoji: .ninja, skinTones: [.dark]),
+            "🤴🏿": EmojiWithSkinTones(baseEmoji: .prince, skinTones: [.dark]),
+            "🤵🏿": EmojiWithSkinTones(baseEmoji: .personInTuxedo, skinTones: [.dark]),
+            "🤰🏿": EmojiWithSkinTones(baseEmoji: .pregnantWoman, skinTones: [.dark]),
+            "🤱🏿": EmojiWithSkinTones(baseEmoji: .breastFeeding, skinTones: [.dark]),
+            "🤶🏿": EmojiWithSkinTones(baseEmoji: .mrsClaus, skinTones: [.dark]),
+            "🤸🏿": EmojiWithSkinTones(baseEmoji: .personDoingCartwheel, skinTones: [.dark]),
+            "🤽🏿": EmojiWithSkinTones(baseEmoji: .waterPolo, skinTones: [.dark]),
+            "🤾🏿": EmojiWithSkinTones(baseEmoji: .handball, skinTones: [.dark]),
+            "🤹🏿": EmojiWithSkinTones(baseEmoji: .juggling, skinTones: [.dark])
+        ]
+        return (lookup[rawValue] ?? EmojiWithSkinTones(unsupportedValue: rawValue))
+    }
+    
+    private static func emojiFrom2574(_ rawValue: String) -> EmojiWithSkinTones {
+        let lookup: [String: EmojiWithSkinTones] = [
+            "🦵🏻": EmojiWithSkinTones(baseEmoji: .leg, skinTones: [.light]),
+            "🦶🏻": EmojiWithSkinTones(baseEmoji: .foot, skinTones: [.light]),
+            "🦻🏻": EmojiWithSkinTones(baseEmoji: .earWithHearingAid, skinTones: [.light]),
+            "🧒🏻": EmojiWithSkinTones(baseEmoji: .child, skinTones: [.light]),
+            "🧑🏻": EmojiWithSkinTones(baseEmoji: .adult, skinTones: [.light]),
+            "🧔🏻": EmojiWithSkinTones(baseEmoji: .beardedPerson, skinTones: [.light]),
+            "🧓🏻": EmojiWithSkinTones(baseEmoji: .olderAdult, skinTones: [.light]),
+            "🧏🏻": EmojiWithSkinTones(baseEmoji: .deafPerson, skinTones: [.light]),
+            "🧕🏻": EmojiWithSkinTones(baseEmoji: .personWithHeadscarf, skinTones: [.light]),
+            "🦸🏻": EmojiWithSkinTones(baseEmoji: .superhero, skinTones: [.light]),
+            "🦹🏻": EmojiWithSkinTones(baseEmoji: .supervillain, skinTones: [.light]),
+            "🧙🏻": EmojiWithSkinTones(baseEmoji: .mage, skinTones: [.light]),
+            "🧚🏻": EmojiWithSkinTones(baseEmoji: .fairy, skinTones: [.light]),
+            "🧛🏻": EmojiWithSkinTones(baseEmoji: .vampire, skinTones: [.light]),
+            "🧜🏻": EmojiWithSkinTones(baseEmoji: .merperson, skinTones: [.light]),
+            "🧝🏻": EmojiWithSkinTones(baseEmoji: .elf, skinTones: [.light]),
+            "🧍🏻": EmojiWithSkinTones(baseEmoji: .standingPerson, skinTones: [.light]),
+            "🧎🏻": EmojiWithSkinTones(baseEmoji: .kneelingPerson, skinTones: [.light]),
+            "🧖🏻": EmojiWithSkinTones(baseEmoji: .personInSteamyRoom, skinTones: [.light]),
+            "🧗🏻": EmojiWithSkinTones(baseEmoji: .personClimbing, skinTones: [.light]),
+            "🧘🏻": EmojiWithSkinTones(baseEmoji: .personInLotusPosition, skinTones: [.light]),
+            "🦵🏼": EmojiWithSkinTones(baseEmoji: .leg, skinTones: [.mediumLight]),
+            "🦶🏼": EmojiWithSkinTones(baseEmoji: .foot, skinTones: [.mediumLight]),
+            "🦻🏼": EmojiWithSkinTones(baseEmoji: .earWithHearingAid, skinTones: [.mediumLight]),
+            "🧒🏼": EmojiWithSkinTones(baseEmoji: .child, skinTones: [.mediumLight]),
+            "🧑🏼": EmojiWithSkinTones(baseEmoji: .adult, skinTones: [.mediumLight]),
+            "🧔🏼": EmojiWithSkinTones(baseEmoji: .beardedPerson, skinTones: [.mediumLight]),
+            "🧓🏼": EmojiWithSkinTones(baseEmoji: .olderAdult, skinTones: [.mediumLight]),
+            "🧏🏼": EmojiWithSkinTones(baseEmoji: .deafPerson, skinTones: [.mediumLight]),
+            "🧕🏼": EmojiWithSkinTones(baseEmoji: .personWithHeadscarf, skinTones: [.mediumLight]),
+            "🦸🏼": EmojiWithSkinTones(baseEmoji: .superhero, skinTones: [.mediumLight]),
+            "🦹🏼": EmojiWithSkinTones(baseEmoji: .supervillain, skinTones: [.mediumLight]),
+            "🧙🏼": EmojiWithSkinTones(baseEmoji: .mage, skinTones: [.mediumLight]),
+            "🧚🏼": EmojiWithSkinTones(baseEmoji: .fairy, skinTones: [.mediumLight]),
+            "🧛🏼": EmojiWithSkinTones(baseEmoji: .vampire, skinTones: [.mediumLight]),
+            "🧜🏼": EmojiWithSkinTones(baseEmoji: .merperson, skinTones: [.mediumLight]),
+            "🧝🏼": EmojiWithSkinTones(baseEmoji: .elf, skinTones: [.mediumLight]),
+            "🧍🏼": EmojiWithSkinTones(baseEmoji: .standingPerson, skinTones: [.mediumLight]),
+            "🧎🏼": EmojiWithSkinTones(baseEmoji: .kneelingPerson, skinTones: [.mediumLight]),
+            "🧖🏼": EmojiWithSkinTones(baseEmoji: .personInSteamyRoom, skinTones: [.mediumLight]),
+            "🧗🏼": EmojiWithSkinTones(baseEmoji: .personClimbing, skinTones: [.mediumLight]),
+            "🧘🏼": EmojiWithSkinTones(baseEmoji: .personInLotusPosition, skinTones: [.mediumLight]),
+            "🦵🏽": EmojiWithSkinTones(baseEmoji: .leg, skinTones: [.medium]),
+            "🦶🏽": EmojiWithSkinTones(baseEmoji: .foot, skinTones: [.medium]),
+            "🦻🏽": EmojiWithSkinTones(baseEmoji: .earWithHearingAid, skinTones: [.medium]),
+            "🧒🏽": EmojiWithSkinTones(baseEmoji: .child, skinTones: [.medium]),
+            "🧑🏽": EmojiWithSkinTones(baseEmoji: .adult, skinTones: [.medium]),
+            "🧔🏽": EmojiWithSkinTones(baseEmoji: .beardedPerson, skinTones: [.medium]),
+            "🧓🏽": EmojiWithSkinTones(baseEmoji: .olderAdult, skinTones: [.medium]),
+            "🧏🏽": EmojiWithSkinTones(baseEmoji: .deafPerson, skinTones: [.medium]),
+            "🧕🏽": EmojiWithSkinTones(baseEmoji: .personWithHeadscarf, skinTones: [.medium]),
+            "🦸🏽": EmojiWithSkinTones(baseEmoji: .superhero, skinTones: [.medium]),
+            "🦹🏽": EmojiWithSkinTones(baseEmoji: .supervillain, skinTones: [.medium]),
+            "🧙🏽": EmojiWithSkinTones(baseEmoji: .mage, skinTones: [.medium]),
+            "🧚🏽": EmojiWithSkinTones(baseEmoji: .fairy, skinTones: [.medium]),
+            "🧛🏽": EmojiWithSkinTones(baseEmoji: .vampire, skinTones: [.medium]),
+            "🧜🏽": EmojiWithSkinTones(baseEmoji: .merperson, skinTones: [.medium]),
+            "🧝🏽": EmojiWithSkinTones(baseEmoji: .elf, skinTones: [.medium]),
+            "🧍🏽": EmojiWithSkinTones(baseEmoji: .standingPerson, skinTones: [.medium]),
+            "🧎🏽": EmojiWithSkinTones(baseEmoji: .kneelingPerson, skinTones: [.medium]),
+            "🧖🏽": EmojiWithSkinTones(baseEmoji: .personInSteamyRoom, skinTones: [.medium]),
+            "🧗🏽": EmojiWithSkinTones(baseEmoji: .personClimbing, skinTones: [.medium]),
+            "🧘🏽": EmojiWithSkinTones(baseEmoji: .personInLotusPosition, skinTones: [.medium]),
+            "🦵🏾": EmojiWithSkinTones(baseEmoji: .leg, skinTones: [.mediumDark]),
+            "🦶🏾": EmojiWithSkinTones(baseEmoji: .foot, skinTones: [.mediumDark]),
+            "🦻🏾": EmojiWithSkinTones(baseEmoji: .earWithHearingAid, skinTones: [.mediumDark]),
+            "🧒🏾": EmojiWithSkinTones(baseEmoji: .child, skinTones: [.mediumDark]),
+            "🧑🏾": EmojiWithSkinTones(baseEmoji: .adult, skinTones: [.mediumDark]),
+            "🧔🏾": EmojiWithSkinTones(baseEmoji: .beardedPerson, skinTones: [.mediumDark]),
+            "🧓🏾": EmojiWithSkinTones(baseEmoji: .olderAdult, skinTones: [.mediumDark]),
+            "🧏🏾": EmojiWithSkinTones(baseEmoji: .deafPerson, skinTones: [.mediumDark]),
+            "🧕🏾": EmojiWithSkinTones(baseEmoji: .personWithHeadscarf, skinTones: [.mediumDark]),
+            "🦸🏾": EmojiWithSkinTones(baseEmoji: .superhero, skinTones: [.mediumDark]),
+            "🦹🏾": EmojiWithSkinTones(baseEmoji: .supervillain, skinTones: [.mediumDark]),
+            "🧙🏾": EmojiWithSkinTones(baseEmoji: .mage, skinTones: [.mediumDark]),
+            "🧚🏾": EmojiWithSkinTones(baseEmoji: .fairy, skinTones: [.mediumDark]),
+            "🧛🏾": EmojiWithSkinTones(baseEmoji: .vampire, skinTones: [.mediumDark]),
+            "🧜🏾": EmojiWithSkinTones(baseEmoji: .merperson, skinTones: [.mediumDark]),
+            "🧝🏾": EmojiWithSkinTones(baseEmoji: .elf, skinTones: [.mediumDark]),
+            "🧍🏾": EmojiWithSkinTones(baseEmoji: .standingPerson, skinTones: [.mediumDark]),
+            "🧎🏾": EmojiWithSkinTones(baseEmoji: .kneelingPerson, skinTones: [.mediumDark]),
+            "🧖🏾": EmojiWithSkinTones(baseEmoji: .personInSteamyRoom, skinTones: [.mediumDark]),
+            "🧗🏾": EmojiWithSkinTones(baseEmoji: .personClimbing, skinTones: [.mediumDark]),
+            "🧘🏾": EmojiWithSkinTones(baseEmoji: .personInLotusPosition, skinTones: [.mediumDark]),
+            "🦵🏿": EmojiWithSkinTones(baseEmoji: .leg, skinTones: [.dark]),
+            "🦶🏿": EmojiWithSkinTones(baseEmoji: .foot, skinTones: [.dark]),
+            "🦻🏿": EmojiWithSkinTones(baseEmoji: .earWithHearingAid, skinTones: [.dark]),
+            "🧒🏿": EmojiWithSkinTones(baseEmoji: .child, skinTones: [.dark]),
+            "🧑🏿": EmojiWithSkinTones(baseEmoji: .adult, skinTones: [.dark]),
+            "🧔🏿": EmojiWithSkinTones(baseEmoji: .beardedPerson, skinTones: [.dark]),
+            "🧓🏿": EmojiWithSkinTones(baseEmoji: .olderAdult, skinTones: [.dark]),
+            "🧏🏿": EmojiWithSkinTones(baseEmoji: .deafPerson, skinTones: [.dark]),
+            "🧕🏿": EmojiWithSkinTones(baseEmoji: .personWithHeadscarf, skinTones: [.dark]),
+            "🦸🏿": EmojiWithSkinTones(baseEmoji: .superhero, skinTones: [.dark]),
+            "🦹🏿": EmojiWithSkinTones(baseEmoji: .supervillain, skinTones: [.dark]),
+            "🧙🏿": EmojiWithSkinTones(baseEmoji: .mage, skinTones: [.dark]),
+            "🧚🏿": EmojiWithSkinTones(baseEmoji: .fairy, skinTones: [.dark]),
+            "🧛🏿": EmojiWithSkinTones(baseEmoji: .vampire, skinTones: [.dark]),
+            "🧜🏿": EmojiWithSkinTones(baseEmoji: .merperson, skinTones: [.dark]),
+            "🧍🏿": EmojiWithSkinTones(baseEmoji: .standingPerson, skinTones: [.dark]),
+            "🧎🏿": EmojiWithSkinTones(baseEmoji: .kneelingPerson, skinTones: [.dark]),
+            "🧖🏿": EmojiWithSkinTones(baseEmoji: .personInSteamyRoom, skinTones: [.dark]),
+            "🧗🏿": EmojiWithSkinTones(baseEmoji: .personClimbing, skinTones: [.dark]),
+            "🧘🏿": EmojiWithSkinTones(baseEmoji: .personInLotusPosition, skinTones: [.dark])
+        ]
+        return (lookup[rawValue] ?? EmojiWithSkinTones(unsupportedValue: rawValue))
+    }
+    
+    private static func emojiFrom2575(_ rawValue: String) -> EmojiWithSkinTones {
+        let lookup: [String: EmojiWithSkinTones] = [
+            "🧝🏿": EmojiWithSkinTones(baseEmoji: .elf, skinTones: [.dark])
+        ]
+        return (lookup[rawValue] ?? EmojiWithSkinTones(unsupportedValue: rawValue))
+    }
+    
+    private static func emojiFrom2577(_ rawValue: String) -> EmojiWithSkinTones {
+        let lookup: [String: EmojiWithSkinTones] = [
+            "🫱🏻": EmojiWithSkinTones(baseEmoji: .rightwardsHand, skinTones: [.light]),
+            "🫲🏻": EmojiWithSkinTones(baseEmoji: .leftwardsHand, skinTones: [.light]),
+            "🫳🏻": EmojiWithSkinTones(baseEmoji: .palmDownHand, skinTones: [.light]),
+            "🫴🏻": EmojiWithSkinTones(baseEmoji: .palmUpHand, skinTones: [.light]),
+            "🫷🏻": EmojiWithSkinTones(baseEmoji: .leftwardsPushingHand, skinTones: [.light]),
+            "🫸🏻": EmojiWithSkinTones(baseEmoji: .rightwardsPushingHand, skinTones: [.light]),
+            "🫰🏻": EmojiWithSkinTones(baseEmoji: .handWithIndexFingerAndThumbCrossed, skinTones: [.light]),
+            "🫵🏻": EmojiWithSkinTones(baseEmoji: .indexPointingAtTheViewer, skinTones: [.light]),
+            "🫶🏻": EmojiWithSkinTones(baseEmoji: .heartHands, skinTones: [.light]),
+            "🫅🏻": EmojiWithSkinTones(baseEmoji: .personWithCrown, skinTones: [.light]),
+            "🫃🏻": EmojiWithSkinTones(baseEmoji: .pregnantMan, skinTones: [.light]),
+            "🫄🏻": EmojiWithSkinTones(baseEmoji: .pregnantPerson, skinTones: [.light]),
+            "🫱🏼": EmojiWithSkinTones(baseEmoji: .rightwardsHand, skinTones: [.mediumLight]),
+            "🫲🏼": EmojiWithSkinTones(baseEmoji: .leftwardsHand, skinTones: [.mediumLight]),
+            "🫳🏼": EmojiWithSkinTones(baseEmoji: .palmDownHand, skinTones: [.mediumLight]),
+            "🫴🏼": EmojiWithSkinTones(baseEmoji: .palmUpHand, skinTones: [.mediumLight]),
+            "🫷🏼": EmojiWithSkinTones(baseEmoji: .leftwardsPushingHand, skinTones: [.mediumLight]),
+            "🫸🏼": EmojiWithSkinTones(baseEmoji: .rightwardsPushingHand, skinTones: [.mediumLight]),
+            "🫰🏼": EmojiWithSkinTones(baseEmoji: .handWithIndexFingerAndThumbCrossed, skinTones: [.mediumLight]),
+            "🫵🏼": EmojiWithSkinTones(baseEmoji: .indexPointingAtTheViewer, skinTones: [.mediumLight]),
+            "🫶🏼": EmojiWithSkinTones(baseEmoji: .heartHands, skinTones: [.mediumLight]),
+            "🫅🏼": EmojiWithSkinTones(baseEmoji: .personWithCrown, skinTones: [.mediumLight]),
+            "🫃🏼": EmojiWithSkinTones(baseEmoji: .pregnantMan, skinTones: [.mediumLight]),
+            "🫄🏼": EmojiWithSkinTones(baseEmoji: .pregnantPerson, skinTones: [.mediumLight]),
+            "🫱🏽": EmojiWithSkinTones(baseEmoji: .rightwardsHand, skinTones: [.medium]),
+            "🫲🏽": EmojiWithSkinTones(baseEmoji: .leftwardsHand, skinTones: [.medium]),
+            "🫳🏽": EmojiWithSkinTones(baseEmoji: .palmDownHand, skinTones: [.medium]),
+            "🫴🏽": EmojiWithSkinTones(baseEmoji: .palmUpHand, skinTones: [.medium]),
+            "🫷🏽": EmojiWithSkinTones(baseEmoji: .leftwardsPushingHand, skinTones: [.medium]),
+            "🫸🏽": EmojiWithSkinTones(baseEmoji: .rightwardsPushingHand, skinTones: [.medium]),
+            "🫰🏽": EmojiWithSkinTones(baseEmoji: .handWithIndexFingerAndThumbCrossed, skinTones: [.medium]),
+            "🫵🏽": EmojiWithSkinTones(baseEmoji: .indexPointingAtTheViewer, skinTones: [.medium]),
+            "🫶🏽": EmojiWithSkinTones(baseEmoji: .heartHands, skinTones: [.medium]),
+            "🫅🏽": EmojiWithSkinTones(baseEmoji: .personWithCrown, skinTones: [.medium]),
+            "🫃🏽": EmojiWithSkinTones(baseEmoji: .pregnantMan, skinTones: [.medium]),
+            "🫄🏽": EmojiWithSkinTones(baseEmoji: .pregnantPerson, skinTones: [.medium]),
+            "🫱🏾": EmojiWithSkinTones(baseEmoji: .rightwardsHand, skinTones: [.mediumDark]),
+            "🫲🏾": EmojiWithSkinTones(baseEmoji: .leftwardsHand, skinTones: [.mediumDark]),
+            "🫳🏾": EmojiWithSkinTones(baseEmoji: .palmDownHand, skinTones: [.mediumDark]),
+            "🫴🏾": EmojiWithSkinTones(baseEmoji: .palmUpHand, skinTones: [.mediumDark]),
+            "🫷🏾": EmojiWithSkinTones(baseEmoji: .leftwardsPushingHand, skinTones: [.mediumDark]),
+            "🫸🏾": EmojiWithSkinTones(baseEmoji: .rightwardsPushingHand, skinTones: [.mediumDark]),
+            "🫰🏾": EmojiWithSkinTones(baseEmoji: .handWithIndexFingerAndThumbCrossed, skinTones: [.mediumDark]),
+            "🫵🏾": EmojiWithSkinTones(baseEmoji: .indexPointingAtTheViewer, skinTones: [.mediumDark]),
+            "🫶🏾": EmojiWithSkinTones(baseEmoji: .heartHands, skinTones: [.mediumDark]),
+            "🫅🏾": EmojiWithSkinTones(baseEmoji: .personWithCrown, skinTones: [.mediumDark]),
+            "🫃🏾": EmojiWithSkinTones(baseEmoji: .pregnantMan, skinTones: [.mediumDark]),
+            "🫄🏾": EmojiWithSkinTones(baseEmoji: .pregnantPerson, skinTones: [.mediumDark]),
+            "🫱🏿": EmojiWithSkinTones(baseEmoji: .rightwardsHand, skinTones: [.dark]),
+            "🫲🏿": EmojiWithSkinTones(baseEmoji: .leftwardsHand, skinTones: [.dark]),
+            "🫳🏿": EmojiWithSkinTones(baseEmoji: .palmDownHand, skinTones: [.dark]),
+            "🫴🏿": EmojiWithSkinTones(baseEmoji: .palmUpHand, skinTones: [.dark]),
+            "🫷🏿": EmojiWithSkinTones(baseEmoji: .leftwardsPushingHand, skinTones: [.dark]),
+            "🫸🏿": EmojiWithSkinTones(baseEmoji: .rightwardsPushingHand, skinTones: [.dark]),
+            "🫰🏿": EmojiWithSkinTones(baseEmoji: .handWithIndexFingerAndThumbCrossed, skinTones: [.dark]),
+            "🫵🏿": EmojiWithSkinTones(baseEmoji: .indexPointingAtTheViewer, skinTones: [.dark]),
+            "🫶🏿": EmojiWithSkinTones(baseEmoji: .heartHands, skinTones: [.dark]),
+            "🫅🏿": EmojiWithSkinTones(baseEmoji: .personWithCrown, skinTones: [.dark]),
+            "🫃🏿": EmojiWithSkinTones(baseEmoji: .pregnantMan, skinTones: [.dark]),
+            "🫄🏿": EmojiWithSkinTones(baseEmoji: .pregnantPerson, skinTones: [.dark])
+        ]
+        return (lookup[rawValue] ?? EmojiWithSkinTones(unsupportedValue: rawValue))
+    }
+    
+    private static func emojiFrom2641(_ rawValue: String) -> EmojiWithSkinTones {
+        let lookup: [String: EmojiWithSkinTones] = [
+            "👨‍🌾": EmojiWithSkinTones(baseEmoji: .maleFarmer, skinTones: nil),
+            "👩‍🌾": EmojiWithSkinTones(baseEmoji: .femaleFarmer, skinTones: nil),
+            "👨‍🍳": EmojiWithSkinTones(baseEmoji: .maleCook, skinTones: nil),
+            "👩‍🍳": EmojiWithSkinTones(baseEmoji: .femaleCook, skinTones: nil),
+            "👩‍🍼": EmojiWithSkinTones(baseEmoji: .womanFeedingBaby, skinTones: nil),
+            "👨‍🍼": EmojiWithSkinTones(baseEmoji: .manFeedingBaby, skinTones: nil)
+        ]
+        return (lookup[rawValue] ?? EmojiWithSkinTones(unsupportedValue: rawValue))
+    }
+    
+    private static func emojiFrom2642(_ rawValue: String) -> EmojiWithSkinTones {
+        let lookup: [String: EmojiWithSkinTones] = [
+            "👨‍🎓": EmojiWithSkinTones(baseEmoji: .maleStudent, skinTones: nil),
+            "👩‍🎓": EmojiWithSkinTones(baseEmoji: .femaleStudent, skinTones: nil),
+            "👨‍🏫": EmojiWithSkinTones(baseEmoji: .maleTeacher, skinTones: nil),
+            "👩‍🏫": EmojiWithSkinTones(baseEmoji: .femaleTeacher, skinTones: nil),
+            "👨‍🏭": EmojiWithSkinTones(baseEmoji: .maleFactoryWorker, skinTones: nil),
+            "👩‍🏭": EmojiWithSkinTones(baseEmoji: .femaleFactoryWorker, skinTones: nil),
+            "👨‍🎤": EmojiWithSkinTones(baseEmoji: .maleSinger, skinTones: nil),
+            "👩‍🎤": EmojiWithSkinTones(baseEmoji: .femaleSinger, skinTones: nil),
+            "👨‍🎨": EmojiWithSkinTones(baseEmoji: .maleArtist, skinTones: nil),
+            "👩‍🎨": EmojiWithSkinTones(baseEmoji: .femaleArtist, skinTones: nil)
+        ]
+        return (lookup[rawValue] ?? EmojiWithSkinTones(unsupportedValue: rawValue))
+    }
+    
+    private static func emojiFrom2644(_ rawValue: String) -> EmojiWithSkinTones {
+        let lookup: [String: EmojiWithSkinTones] = [
+            "👨‍💼": EmojiWithSkinTones(baseEmoji: .maleOfficeWorker, skinTones: nil),
+            "👩‍💼": EmojiWithSkinTones(baseEmoji: .femaleOfficeWorker, skinTones: nil),
+            "👨‍💻": EmojiWithSkinTones(baseEmoji: .maleTechnologist, skinTones: nil),
+            "👩‍💻": EmojiWithSkinTones(baseEmoji: .femaleTechnologist, skinTones: nil),
+            "👨‍👦": EmojiWithSkinTones(baseEmoji: .manBoy, skinTones: nil),
+            "👨‍👧": EmojiWithSkinTones(baseEmoji: .manGirl, skinTones: nil),
+            "👩‍👦": EmojiWithSkinTones(baseEmoji: .womanBoy, skinTones: nil),
+            "👩‍👧": EmojiWithSkinTones(baseEmoji: .womanGirl, skinTones: nil)
+        ]
+        return (lookup[rawValue] ?? EmojiWithSkinTones(unsupportedValue: rawValue))
+    }
+    
+    private static func emojiFrom2646(_ rawValue: String) -> EmojiWithSkinTones {
+        let lookup: [String: EmojiWithSkinTones] = [
+            "👨‍🔧": EmojiWithSkinTones(baseEmoji: .maleMechanic, skinTones: nil),
+            "👩‍🔧": EmojiWithSkinTones(baseEmoji: .femaleMechanic, skinTones: nil),
+            "👨‍🔬": EmojiWithSkinTones(baseEmoji: .maleScientist, skinTones: nil),
+            "👩‍🔬": EmojiWithSkinTones(baseEmoji: .femaleScientist, skinTones: nil)
+        ]
+        return (lookup[rawValue] ?? EmojiWithSkinTones(unsupportedValue: rawValue))
+    }
+    
+    private static func emojiFrom2649(_ rawValue: String) -> EmojiWithSkinTones {
+        let lookup: [String: EmojiWithSkinTones] = [
+            "😮‍💨": EmojiWithSkinTones(baseEmoji: .faceExhaling, skinTones: nil),
+            "😵‍💫": EmojiWithSkinTones(baseEmoji: .faceWithSpiralEyes, skinTones: nil),
+            "👨‍🚀": EmojiWithSkinTones(baseEmoji: .maleAstronaut, skinTones: nil),
+            "👩‍🚀": EmojiWithSkinTones(baseEmoji: .femaleAstronaut, skinTones: nil),
+            "👨‍🚒": EmojiWithSkinTones(baseEmoji: .maleFirefighter, skinTones: nil),
+            "👩‍🚒": EmojiWithSkinTones(baseEmoji: .femaleFirefighter, skinTones: nil)
+        ]
+        return (lookup[rawValue] ?? EmojiWithSkinTones(unsupportedValue: rawValue))
+    }
+    
+    private static func emojiFrom2655(_ rawValue: String) -> EmojiWithSkinTones {
+        let lookup: [String: EmojiWithSkinTones] = [
+            "🧑‍🎓": EmojiWithSkinTones(baseEmoji: .student, skinTones: nil),
+            "🧑‍🌾": EmojiWithSkinTones(baseEmoji: .farmer, skinTones: nil),
+            "🧑‍🍳": EmojiWithSkinTones(baseEmoji: .cook, skinTones: nil),
+            "🧑‍🍼": EmojiWithSkinTones(baseEmoji: .personFeedingBaby, skinTones: nil),
+            "🧑‍🎄": EmojiWithSkinTones(baseEmoji: .mxClaus, skinTones: nil)
+        ]
+        return (lookup[rawValue] ?? EmojiWithSkinTones(unsupportedValue: rawValue))
+    }
+    
+    private static func emojiFrom2656(_ rawValue: String) -> EmojiWithSkinTones {
+        let lookup: [String: EmojiWithSkinTones] = [
+            "🧑‍🏫": EmojiWithSkinTones(baseEmoji: .teacher, skinTones: nil),
+            "🧑‍🏭": EmojiWithSkinTones(baseEmoji: .factoryWorker, skinTones: nil),
+            "🧑‍🎤": EmojiWithSkinTones(baseEmoji: .singer, skinTones: nil),
+            "🧑‍🎨": EmojiWithSkinTones(baseEmoji: .artist, skinTones: nil),
+            "🐕‍🦺": EmojiWithSkinTones(baseEmoji: .serviceDog, skinTones: nil)
+        ]
+        return (lookup[rawValue] ?? EmojiWithSkinTones(unsupportedValue: rawValue))
+    }
+    
+    private static func emojiFrom2657(_ rawValue: String) -> EmojiWithSkinTones {
+        let lookup: [String: EmojiWithSkinTones] = [
+            "👨‍🦰": EmojiWithSkinTones(baseEmoji: .redHairedMan, skinTones: nil),
+            "👨‍🦱": EmojiWithSkinTones(baseEmoji: .curlyHairedMan, skinTones: nil),
+            "👨‍🦳": EmojiWithSkinTones(baseEmoji: .whiteHairedMan, skinTones: nil),
+            "👨‍🦲": EmojiWithSkinTones(baseEmoji: .baldMan, skinTones: nil),
+            "👩‍🦰": EmojiWithSkinTones(baseEmoji: .redHairedWoman, skinTones: nil),
+            "👩‍🦱": EmojiWithSkinTones(baseEmoji: .curlyHairedWoman, skinTones: nil),
+            "👩‍🦳": EmojiWithSkinTones(baseEmoji: .whiteHairedWoman, skinTones: nil),
+            "👩‍🦲": EmojiWithSkinTones(baseEmoji: .baldWoman, skinTones: nil),
+            "👨‍🦯": EmojiWithSkinTones(baseEmoji: .manWithProbingCane, skinTones: nil),
+            "👩‍🦯": EmojiWithSkinTones(baseEmoji: .womanWithProbingCane, skinTones: nil),
+            "👨‍🦼": EmojiWithSkinTones(baseEmoji: .manInMotorizedWheelchair, skinTones: nil),
+            "👩‍🦼": EmojiWithSkinTones(baseEmoji: .womanInMotorizedWheelchair, skinTones: nil),
+            "👨‍🦽": EmojiWithSkinTones(baseEmoji: .manInManualWheelchair, skinTones: nil),
+            "👩‍🦽": EmojiWithSkinTones(baseEmoji: .womanInManualWheelchair, skinTones: nil)
+        ]
+        return (lookup[rawValue] ?? EmojiWithSkinTones(unsupportedValue: rawValue))
+    }
+    
+    private static func emojiFrom2658(_ rawValue: String) -> EmojiWithSkinTones {
+        let lookup: [String: EmojiWithSkinTones] = [
+            "🧑‍💼": EmojiWithSkinTones(baseEmoji: .officeWorker, skinTones: nil),
+            "🧑‍💻": EmojiWithSkinTones(baseEmoji: .technologist, skinTones: nil)
+        ]
+        return (lookup[rawValue] ?? EmojiWithSkinTones(unsupportedValue: rawValue))
+    }
+    
+    private static func emojiFrom2659(_ rawValue: String) -> EmojiWithSkinTones {
+        let lookup: [String: EmojiWithSkinTones] = [
+            "🧑‍🔧": EmojiWithSkinTones(baseEmoji: .mechanic, skinTones: nil),
+            "🧑‍🔬": EmojiWithSkinTones(baseEmoji: .scientist, skinTones: nil)
+        ]
+        return (lookup[rawValue] ?? EmojiWithSkinTones(unsupportedValue: rawValue))
+    }
+    
+    private static func emojiFrom2663(_ rawValue: String) -> EmojiWithSkinTones {
+        let lookup: [String: EmojiWithSkinTones] = [
+            "🧑‍🚀": EmojiWithSkinTones(baseEmoji: .astronaut, skinTones: nil),
+            "🧑‍🚒": EmojiWithSkinTones(baseEmoji: .firefighter, skinTones: nil)
+        ]
+        return (lookup[rawValue] ?? EmojiWithSkinTones(unsupportedValue: rawValue))
+    }
+    
+    private static func emojiFrom2671(_ rawValue: String) -> EmojiWithSkinTones {
+        let lookup: [String: EmojiWithSkinTones] = [
+            "🧑‍🦰": EmojiWithSkinTones(baseEmoji: .redHairedPerson, skinTones: nil),
+            "🧑‍🦱": EmojiWithSkinTones(baseEmoji: .curlyHairedPerson, skinTones: nil),
+            "🧑‍🦳": EmojiWithSkinTones(baseEmoji: .whiteHairedPerson, skinTones: nil),
+            "🧑‍🦲": EmojiWithSkinTones(baseEmoji: .baldPerson, skinTones: nil),
+            "🧑‍🦯": EmojiWithSkinTones(baseEmoji: .personWithProbingCane, skinTones: nil),
+            "🧑‍🦼": EmojiWithSkinTones(baseEmoji: .personInMotorizedWheelchair, skinTones: nil),
+            "🧑‍🦽": EmojiWithSkinTones(baseEmoji: .personInManualWheelchair, skinTones: nil)
+        ]
+        return (lookup[rawValue] ?? EmojiWithSkinTones(unsupportedValue: rawValue))
+    }
+    
+    private static func emojiFrom2760(_ rawValue: String) -> EmojiWithSkinTones {
+        let lookup: [String: EmojiWithSkinTones] = [
+            "🏌️‍♂️": EmojiWithSkinTones(baseEmoji: .manGolfing, skinTones: nil),
+            "🏌️‍♀️": EmojiWithSkinTones(baseEmoji: .womanGolfing, skinTones: nil),
+            "🏋️‍♂️": EmojiWithSkinTones(baseEmoji: .manLiftingWeights, skinTones: nil),
+            "🏋️‍♀️": EmojiWithSkinTones(baseEmoji: .womanLiftingWeights, skinTones: nil)
+        ]
+        return (lookup[rawValue] ?? EmojiWithSkinTones(unsupportedValue: rawValue))
+    }
+    
+    private static func emojiFrom2761(_ rawValue: String) -> EmojiWithSkinTones {
+        let lookup: [String: EmojiWithSkinTones] = [
+            "🏳️‍⚧️": EmojiWithSkinTones(baseEmoji: .transgenderFlag, skinTones: nil)
+        ]
+        return (lookup[rawValue] ?? EmojiWithSkinTones(unsupportedValue: rawValue))
+    }
+    
+    private static func emojiFrom2764(_ rawValue: String) -> EmojiWithSkinTones {
+        let lookup: [String: EmojiWithSkinTones] = [
+            "🕵️‍♂️": EmojiWithSkinTones(baseEmoji: .maleDetective, skinTones: nil),
+            "🕵️‍♀️": EmojiWithSkinTones(baseEmoji: .femaleDetective, skinTones: nil)
+        ]
+        return (lookup[rawValue] ?? EmojiWithSkinTones(unsupportedValue: rawValue))
+    }
+    
+    private static func emojiFrom3289(_ rawValue: String) -> EmojiWithSkinTones {
+        let lookup: [String: EmojiWithSkinTones] = [
+            "🏳️‍🌈": EmojiWithSkinTones(baseEmoji: .rainbowFlag, skinTones: nil)
+        ]
+        return (lookup[rawValue] ?? EmojiWithSkinTones(unsupportedValue: rawValue))
+    }
+    
+    private static func emojiFrom3295(_ rawValue: String) -> EmojiWithSkinTones {
+        let lookup: [String: EmojiWithSkinTones] = [
+            "😶‍🌫️": EmojiWithSkinTones(baseEmoji: .faceInClouds, skinTones: nil)
+        ]
+        return (lookup[rawValue] ?? EmojiWithSkinTones(unsupportedValue: rawValue))
+    }
+    
+    private static func emojiFrom3389(_ rawValue: String) -> EmojiWithSkinTones {
+        let lookup: [String: EmojiWithSkinTones] = [
+            "🏃🏻‍♂️": EmojiWithSkinTones(baseEmoji: .manRunning, skinTones: [.light]),
+            "🏃🏻‍♀️": EmojiWithSkinTones(baseEmoji: .womanRunning, skinTones: [.light]),
+            "🏌🏻‍♂️": EmojiWithSkinTones(baseEmoji: .manGolfing, skinTones: [.light]),
+            "🏌🏻‍♀️": EmojiWithSkinTones(baseEmoji: .womanGolfing, skinTones: [.light]),
+            "🏄🏻‍♂️": EmojiWithSkinTones(baseEmoji: .manSurfing, skinTones: [.light]),
+            "🏄🏻‍♀️": EmojiWithSkinTones(baseEmoji: .womanSurfing, skinTones: [.light]),
+            "🏊🏻‍♂️": EmojiWithSkinTones(baseEmoji: .manSwimming, skinTones: [.light]),
+            "🏊🏻‍♀️": EmojiWithSkinTones(baseEmoji: .womanSwimming, skinTones: [.light]),
+            "🏋🏻‍♂️": EmojiWithSkinTones(baseEmoji: .manLiftingWeights, skinTones: [.light]),
+            "🏋🏻‍♀️": EmojiWithSkinTones(baseEmoji: .womanLiftingWeights, skinTones: [.light]),
+            "🏃🏼‍♂️": EmojiWithSkinTones(baseEmoji: .manRunning, skinTones: [.mediumLight]),
+            "🏃🏼‍♀️": EmojiWithSkinTones(baseEmoji: .womanRunning, skinTones: [.mediumLight]),
+            "🏌🏼‍♂️": EmojiWithSkinTones(baseEmoji: .manGolfing, skinTones: [.mediumLight]),
+            "🏌🏼‍♀️": EmojiWithSkinTones(baseEmoji: .womanGolfing, skinTones: [.mediumLight]),
+            "🏄🏼‍♂️": EmojiWithSkinTones(baseEmoji: .manSurfing, skinTones: [.mediumLight]),
+            "🏄🏼‍♀️": EmojiWithSkinTones(baseEmoji: .womanSurfing, skinTones: [.mediumLight]),
+            "🏊🏼‍♂️": EmojiWithSkinTones(baseEmoji: .manSwimming, skinTones: [.mediumLight]),
+            "🏊🏼‍♀️": EmojiWithSkinTones(baseEmoji: .womanSwimming, skinTones: [.mediumLight]),
+            "🏋🏼‍♂️": EmojiWithSkinTones(baseEmoji: .manLiftingWeights, skinTones: [.mediumLight]),
+            "🏋🏼‍♀️": EmojiWithSkinTones(baseEmoji: .womanLiftingWeights, skinTones: [.mediumLight]),
+            "🏃🏽‍♂️": EmojiWithSkinTones(baseEmoji: .manRunning, skinTones: [.medium]),
+            "🏃🏽‍♀️": EmojiWithSkinTones(baseEmoji: .womanRunning, skinTones: [.medium]),
+            "🏌🏽‍♂️": EmojiWithSkinTones(baseEmoji: .manGolfing, skinTones: [.medium]),
+            "🏌🏽‍♀️": EmojiWithSkinTones(baseEmoji: .womanGolfing, skinTones: [.medium]),
+            "🏄🏽‍♂️": EmojiWithSkinTones(baseEmoji: .manSurfing, skinTones: [.medium]),
+            "🏄🏽‍♀️": EmojiWithSkinTones(baseEmoji: .womanSurfing, skinTones: [.medium]),
+            "🏊🏽‍♂️": EmojiWithSkinTones(baseEmoji: .manSwimming, skinTones: [.medium]),
+            "🏊🏽‍♀️": EmojiWithSkinTones(baseEmoji: .womanSwimming, skinTones: [.medium]),
+            "🏋🏽‍♂️": EmojiWithSkinTones(baseEmoji: .manLiftingWeights, skinTones: [.medium]),
+            "🏋🏽‍♀️": EmojiWithSkinTones(baseEmoji: .womanLiftingWeights, skinTones: [.medium]),
+            "🏃🏾‍♂️": EmojiWithSkinTones(baseEmoji: .manRunning, skinTones: [.mediumDark]),
+            "🏃🏾‍♀️": EmojiWithSkinTones(baseEmoji: .womanRunning, skinTones: [.mediumDark]),
+            "🏌🏾‍♂️": EmojiWithSkinTones(baseEmoji: .manGolfing, skinTones: [.mediumDark]),
+            "🏌🏾‍♀️": EmojiWithSkinTones(baseEmoji: .womanGolfing, skinTones: [.mediumDark]),
+            "🏄🏾‍♂️": EmojiWithSkinTones(baseEmoji: .manSurfing, skinTones: [.mediumDark]),
+            "🏄🏾‍♀️": EmojiWithSkinTones(baseEmoji: .womanSurfing, skinTones: [.mediumDark]),
+            "🏊🏾‍♂️": EmojiWithSkinTones(baseEmoji: .manSwimming, skinTones: [.mediumDark]),
+            "🏊🏾‍♀️": EmojiWithSkinTones(baseEmoji: .womanSwimming, skinTones: [.mediumDark]),
+            "🏋🏾‍♂️": EmojiWithSkinTones(baseEmoji: .manLiftingWeights, skinTones: [.mediumDark]),
+            "🏋🏾‍♀️": EmojiWithSkinTones(baseEmoji: .womanLiftingWeights, skinTones: [.mediumDark]),
+            "🏃🏿‍♂️": EmojiWithSkinTones(baseEmoji: .manRunning, skinTones: [.dark]),
+            "🏃🏿‍♀️": EmojiWithSkinTones(baseEmoji: .womanRunning, skinTones: [.dark]),
+            "🏌🏿‍♂️": EmojiWithSkinTones(baseEmoji: .manGolfing, skinTones: [.dark]),
+            "🏌🏿‍♀️": EmojiWithSkinTones(baseEmoji: .womanGolfing, skinTones: [.dark]),
+            "🏄🏿‍♂️": EmojiWithSkinTones(baseEmoji: .manSurfing, skinTones: [.dark]),
+            "🏄🏿‍♀️": EmojiWithSkinTones(baseEmoji: .womanSurfing, skinTones: [.dark]),
+            "🏊🏿‍♂️": EmojiWithSkinTones(baseEmoji: .manSwimming, skinTones: [.dark]),
+            "🏊🏿‍♀️": EmojiWithSkinTones(baseEmoji: .womanSwimming, skinTones: [.dark]),
+            "🏋🏿‍♂️": EmojiWithSkinTones(baseEmoji: .manLiftingWeights, skinTones: [.dark]),
+            "🏋🏿‍♀️": EmojiWithSkinTones(baseEmoji: .womanLiftingWeights, skinTones: [.dark])
+        ]
+        return (lookup[rawValue] ?? EmojiWithSkinTones(unsupportedValue: rawValue))
+    }
+    
+    private static func emojiFrom3391(_ rawValue: String) -> EmojiWithSkinTones {
+        let lookup: [String: EmojiWithSkinTones] = [
+            "👱🏻‍♀️": EmojiWithSkinTones(baseEmoji: .blondHairedWoman, skinTones: [.light]),
+            "👱🏻‍♂️": EmojiWithSkinTones(baseEmoji: .blondHairedMan, skinTones: [.light]),
+            "💁🏻‍♂️": EmojiWithSkinTones(baseEmoji: .manTippingHand, skinTones: [.light]),
+            "💁🏻‍♀️": EmojiWithSkinTones(baseEmoji: .womanTippingHand, skinTones: [.light]),
+            "👮🏻‍♂️": EmojiWithSkinTones(baseEmoji: .malePoliceOfficer, skinTones: [.light]),
+            "👮🏻‍♀️": EmojiWithSkinTones(baseEmoji: .femalePoliceOfficer, skinTones: [.light]),
+            "💂🏻‍♂️": EmojiWithSkinTones(baseEmoji: .maleGuard, skinTones: [.light]),
+            "💂🏻‍♀️": EmojiWithSkinTones(baseEmoji: .femaleGuard, skinTones: [.light]),
+            "👷🏻‍♂️": EmojiWithSkinTones(baseEmoji: .maleConstructionWorker, skinTones: [.light]),
+            "👷🏻‍♀️": EmojiWithSkinTones(baseEmoji: .femaleConstructionWorker, skinTones: [.light]),
+            "👳🏻‍♂️": EmojiWithSkinTones(baseEmoji: .manWearingTurban, skinTones: [.light]),
+            "👳🏻‍♀️": EmojiWithSkinTones(baseEmoji: .womanWearingTurban, skinTones: [.light]),
+            "👰🏻‍♂️": EmojiWithSkinTones(baseEmoji: .manWithVeil, skinTones: [.light]),
+            "👰🏻‍♀️": EmojiWithSkinTones(baseEmoji: .womanWithVeil, skinTones: [.light]),
+            "💆🏻‍♂️": EmojiWithSkinTones(baseEmoji: .manGettingMassage, skinTones: [.light]),
+            "💆🏻‍♀️": EmojiWithSkinTones(baseEmoji: .womanGettingMassage, skinTones: [.light]),
+            "💇🏻‍♂️": EmojiWithSkinTones(baseEmoji: .manGettingHaircut, skinTones: [.light]),
+            "💇🏻‍♀️": EmojiWithSkinTones(baseEmoji: .womanGettingHaircut, skinTones: [.light]),
+            "👱🏼‍♀️": EmojiWithSkinTones(baseEmoji: .blondHairedWoman, skinTones: [.mediumLight]),
+            "👱🏼‍♂️": EmojiWithSkinTones(baseEmoji: .blondHairedMan, skinTones: [.mediumLight]),
+            "💁🏼‍♂️": EmojiWithSkinTones(baseEmoji: .manTippingHand, skinTones: [.mediumLight]),
+            "💁🏼‍♀️": EmojiWithSkinTones(baseEmoji: .womanTippingHand, skinTones: [.mediumLight]),
+            "👮🏼‍♂️": EmojiWithSkinTones(baseEmoji: .malePoliceOfficer, skinTones: [.mediumLight]),
+            "👮🏼‍♀️": EmojiWithSkinTones(baseEmoji: .femalePoliceOfficer, skinTones: [.mediumLight]),
+            "💂🏼‍♂️": EmojiWithSkinTones(baseEmoji: .maleGuard, skinTones: [.mediumLight]),
+            "💂🏼‍♀️": EmojiWithSkinTones(baseEmoji: .femaleGuard, skinTones: [.mediumLight]),
+            "👷🏼‍♂️": EmojiWithSkinTones(baseEmoji: .maleConstructionWorker, skinTones: [.mediumLight]),
+            "👷🏼‍♀️": EmojiWithSkinTones(baseEmoji: .femaleConstructionWorker, skinTones: [.mediumLight]),
+            "👳🏼‍♂️": EmojiWithSkinTones(baseEmoji: .manWearingTurban, skinTones: [.mediumLight]),
+            "👳🏼‍♀️": EmojiWithSkinTones(baseEmoji: .womanWearingTurban, skinTones: [.mediumLight]),
+            "👰🏼‍♂️": EmojiWithSkinTones(baseEmoji: .manWithVeil, skinTones: [.mediumLight]),
+            "👰🏼‍♀️": EmojiWithSkinTones(baseEmoji: .womanWithVeil, skinTones: [.mediumLight]),
+            "💆🏼‍♂️": EmojiWithSkinTones(baseEmoji: .manGettingMassage, skinTones: [.mediumLight]),
+            "💆🏼‍♀️": EmojiWithSkinTones(baseEmoji: .womanGettingMassage, skinTones: [.mediumLight]),
+            "💇🏼‍♂️": EmojiWithSkinTones(baseEmoji: .manGettingHaircut, skinTones: [.mediumLight]),
+            "💇🏼‍♀️": EmojiWithSkinTones(baseEmoji: .womanGettingHaircut, skinTones: [.mediumLight]),
+            "👱🏽‍♀️": EmojiWithSkinTones(baseEmoji: .blondHairedWoman, skinTones: [.medium]),
+            "👱🏽‍♂️": EmojiWithSkinTones(baseEmoji: .blondHairedMan, skinTones: [.medium]),
+            "💁🏽‍♂️": EmojiWithSkinTones(baseEmoji: .manTippingHand, skinTones: [.medium]),
+            "💁🏽‍♀️": EmojiWithSkinTones(baseEmoji: .womanTippingHand, skinTones: [.medium]),
+            "👮🏽‍♂️": EmojiWithSkinTones(baseEmoji: .malePoliceOfficer, skinTones: [.medium]),
+            "👮🏽‍♀️": EmojiWithSkinTones(baseEmoji: .femalePoliceOfficer, skinTones: [.medium]),
+            "💂🏽‍♂️": EmojiWithSkinTones(baseEmoji: .maleGuard, skinTones: [.medium]),
+            "💂🏽‍♀️": EmojiWithSkinTones(baseEmoji: .femaleGuard, skinTones: [.medium]),
+            "👷🏽‍♂️": EmojiWithSkinTones(baseEmoji: .maleConstructionWorker, skinTones: [.medium]),
+            "👷🏽‍♀️": EmojiWithSkinTones(baseEmoji: .femaleConstructionWorker, skinTones: [.medium]),
+            "👳🏽‍♂️": EmojiWithSkinTones(baseEmoji: .manWearingTurban, skinTones: [.medium]),
+            "👳🏽‍♀️": EmojiWithSkinTones(baseEmoji: .womanWearingTurban, skinTones: [.medium]),
+            "👰🏽‍♂️": EmojiWithSkinTones(baseEmoji: .manWithVeil, skinTones: [.medium]),
+            "👰🏽‍♀️": EmojiWithSkinTones(baseEmoji: .womanWithVeil, skinTones: [.medium]),
+            "💆🏽‍♂️": EmojiWithSkinTones(baseEmoji: .manGettingMassage, skinTones: [.medium]),
+            "💆🏽‍♀️": EmojiWithSkinTones(baseEmoji: .womanGettingMassage, skinTones: [.medium]),
+            "💇🏽‍♂️": EmojiWithSkinTones(baseEmoji: .manGettingHaircut, skinTones: [.medium]),
+            "💇🏽‍♀️": EmojiWithSkinTones(baseEmoji: .womanGettingHaircut, skinTones: [.medium]),
+            "👱🏾‍♀️": EmojiWithSkinTones(baseEmoji: .blondHairedWoman, skinTones: [.mediumDark]),
+            "👱🏾‍♂️": EmojiWithSkinTones(baseEmoji: .blondHairedMan, skinTones: [.mediumDark]),
+            "💁🏾‍♂️": EmojiWithSkinTones(baseEmoji: .manTippingHand, skinTones: [.mediumDark]),
+            "💁🏾‍♀️": EmojiWithSkinTones(baseEmoji: .womanTippingHand, skinTones: [.mediumDark]),
+            "👮🏾‍♂️": EmojiWithSkinTones(baseEmoji: .malePoliceOfficer, skinTones: [.mediumDark]),
+            "👮🏾‍♀️": EmojiWithSkinTones(baseEmoji: .femalePoliceOfficer, skinTones: [.mediumDark]),
+            "💂🏾‍♂️": EmojiWithSkinTones(baseEmoji: .maleGuard, skinTones: [.mediumDark]),
+            "💂🏾‍♀️": EmojiWithSkinTones(baseEmoji: .femaleGuard, skinTones: [.mediumDark]),
+            "👷🏾‍♂️": EmojiWithSkinTones(baseEmoji: .maleConstructionWorker, skinTones: [.mediumDark]),
+            "👷🏾‍♀️": EmojiWithSkinTones(baseEmoji: .femaleConstructionWorker, skinTones: [.mediumDark]),
+            "👳🏾‍♂️": EmojiWithSkinTones(baseEmoji: .manWearingTurban, skinTones: [.mediumDark]),
+            "👳🏾‍♀️": EmojiWithSkinTones(baseEmoji: .womanWearingTurban, skinTones: [.mediumDark]),
+            "👰🏾‍♂️": EmojiWithSkinTones(baseEmoji: .manWithVeil, skinTones: [.mediumDark]),
+            "👰🏾‍♀️": EmojiWithSkinTones(baseEmoji: .womanWithVeil, skinTones: [.mediumDark]),
+            "💆🏾‍♂️": EmojiWithSkinTones(baseEmoji: .manGettingMassage, skinTones: [.mediumDark]),
+            "💆🏾‍♀️": EmojiWithSkinTones(baseEmoji: .womanGettingMassage, skinTones: [.mediumDark]),
+            "💇🏾‍♂️": EmojiWithSkinTones(baseEmoji: .manGettingHaircut, skinTones: [.mediumDark]),
+            "💇🏾‍♀️": EmojiWithSkinTones(baseEmoji: .womanGettingHaircut, skinTones: [.mediumDark]),
+            "👱🏿‍♀️": EmojiWithSkinTones(baseEmoji: .blondHairedWoman, skinTones: [.dark]),
+            "👱🏿‍♂️": EmojiWithSkinTones(baseEmoji: .blondHairedMan, skinTones: [.dark]),
+            "💁🏿‍♂️": EmojiWithSkinTones(baseEmoji: .manTippingHand, skinTones: [.dark]),
+            "💁🏿‍♀️": EmojiWithSkinTones(baseEmoji: .womanTippingHand, skinTones: [.dark]),
+            "👮🏿‍♂️": EmojiWithSkinTones(baseEmoji: .malePoliceOfficer, skinTones: [.dark]),
+            "👮🏿‍♀️": EmojiWithSkinTones(baseEmoji: .femalePoliceOfficer, skinTones: [.dark]),
+            "💂🏿‍♂️": EmojiWithSkinTones(baseEmoji: .maleGuard, skinTones: [.dark]),
+            "💂🏿‍♀️": EmojiWithSkinTones(baseEmoji: .femaleGuard, skinTones: [.dark]),
+            "👷🏿‍♂️": EmojiWithSkinTones(baseEmoji: .maleConstructionWorker, skinTones: [.dark]),
+            "👷🏿‍♀️": EmojiWithSkinTones(baseEmoji: .femaleConstructionWorker, skinTones: [.dark]),
+            "👳🏿‍♂️": EmojiWithSkinTones(baseEmoji: .manWearingTurban, skinTones: [.dark]),
+            "👳🏿‍♀️": EmojiWithSkinTones(baseEmoji: .womanWearingTurban, skinTones: [.dark]),
+            "👰🏿‍♂️": EmojiWithSkinTones(baseEmoji: .manWithVeil, skinTones: [.dark]),
+            "👰🏿‍♀️": EmojiWithSkinTones(baseEmoji: .womanWithVeil, skinTones: [.dark]),
+            "💆🏿‍♂️": EmojiWithSkinTones(baseEmoji: .manGettingMassage, skinTones: [.dark]),
+            "💆🏿‍♀️": EmojiWithSkinTones(baseEmoji: .womanGettingMassage, skinTones: [.dark]),
+            "💇🏿‍♂️": EmojiWithSkinTones(baseEmoji: .manGettingHaircut, skinTones: [.dark]),
+            "💇🏿‍♀️": EmojiWithSkinTones(baseEmoji: .womanGettingHaircut, skinTones: [.dark])
+        ]
+        return (lookup[rawValue] ?? EmojiWithSkinTones(unsupportedValue: rawValue))
+    }
+    
+    private static func emojiFrom3392(_ rawValue: String) -> EmojiWithSkinTones {
+        let lookup: [String: EmojiWithSkinTones] = [
+            "👨🏻‍⚕️": EmojiWithSkinTones(baseEmoji: .maleDoctor, skinTones: [.light]),
+            "👩🏻‍⚕️": EmojiWithSkinTones(baseEmoji: .femaleDoctor, skinTones: [.light]),
+            "👨🏻‍⚖️": EmojiWithSkinTones(baseEmoji: .maleJudge, skinTones: [.light]),
+            "👩🏻‍⚖️": EmojiWithSkinTones(baseEmoji: .femaleJudge, skinTones: [.light]),
+            "👨🏼‍⚕️": EmojiWithSkinTones(baseEmoji: .maleDoctor, skinTones: [.mediumLight]),
+            "👩🏼‍⚕️": EmojiWithSkinTones(baseEmoji: .femaleDoctor, skinTones: [.mediumLight]),
+            "👨🏼‍⚖️": EmojiWithSkinTones(baseEmoji: .maleJudge, skinTones: [.mediumLight]),
+            "👩🏼‍⚖️": EmojiWithSkinTones(baseEmoji: .femaleJudge, skinTones: [.mediumLight]),
+            "👨🏽‍⚕️": EmojiWithSkinTones(baseEmoji: .maleDoctor, skinTones: [.medium]),
+            "👩🏽‍⚕️": EmojiWithSkinTones(baseEmoji: .femaleDoctor, skinTones: [.medium]),
+            "👨🏽‍⚖️": EmojiWithSkinTones(baseEmoji: .maleJudge, skinTones: [.medium]),
+            "👩🏽‍⚖️": EmojiWithSkinTones(baseEmoji: .femaleJudge, skinTones: [.medium]),
+            "👨🏾‍⚕️": EmojiWithSkinTones(baseEmoji: .maleDoctor, skinTones: [.mediumDark]),
+            "👩🏾‍⚕️": EmojiWithSkinTones(baseEmoji: .femaleDoctor, skinTones: [.mediumDark]),
+            "👨🏾‍⚖️": EmojiWithSkinTones(baseEmoji: .maleJudge, skinTones: [.mediumDark]),
+            "👩🏾‍⚖️": EmojiWithSkinTones(baseEmoji: .femaleJudge, skinTones: [.mediumDark]),
+            "👨🏿‍⚕️": EmojiWithSkinTones(baseEmoji: .maleDoctor, skinTones: [.dark]),
+            "👩🏿‍⚕️": EmojiWithSkinTones(baseEmoji: .femaleDoctor, skinTones: [.dark]),
+            "👨🏿‍⚖️": EmojiWithSkinTones(baseEmoji: .maleJudge, skinTones: [.dark]),
+            "👩🏿‍⚖️": EmojiWithSkinTones(baseEmoji: .femaleJudge, skinTones: [.dark])
+        ]
+        return (lookup[rawValue] ?? EmojiWithSkinTones(unsupportedValue: rawValue))
+    }
+    
+    private static func emojiFrom3393(_ rawValue: String) -> EmojiWithSkinTones {
+        let lookup: [String: EmojiWithSkinTones] = [
+            "👨🏻‍✈️": EmojiWithSkinTones(baseEmoji: .malePilot, skinTones: [.light]),
+            "👩🏻‍✈️": EmojiWithSkinTones(baseEmoji: .femalePilot, skinTones: [.light]),
+            "👨🏼‍✈️": EmojiWithSkinTones(baseEmoji: .malePilot, skinTones: [.mediumLight]),
+            "👩🏼‍✈️": EmojiWithSkinTones(baseEmoji: .femalePilot, skinTones: [.mediumLight]),
+            "👨🏽‍✈️": EmojiWithSkinTones(baseEmoji: .malePilot, skinTones: [.medium]),
+            "👩🏽‍✈️": EmojiWithSkinTones(baseEmoji: .femalePilot, skinTones: [.medium]),
+            "👨🏾‍✈️": EmojiWithSkinTones(baseEmoji: .malePilot, skinTones: [.mediumDark]),
+            "👩🏾‍✈️": EmojiWithSkinTones(baseEmoji: .femalePilot, skinTones: [.mediumDark]),
+            "👨🏿‍✈️": EmojiWithSkinTones(baseEmoji: .malePilot, skinTones: [.dark]),
+            "👩🏿‍✈️": EmojiWithSkinTones(baseEmoji: .femalePilot, skinTones: [.dark])
+        ]
+        return (lookup[rawValue] ?? EmojiWithSkinTones(unsupportedValue: rawValue))
+    }
+    
+    private static func emojiFrom3394(_ rawValue: String) -> EmojiWithSkinTones {
+        let lookup: [String: EmojiWithSkinTones] = [
+            "🕵🏻‍♂️": EmojiWithSkinTones(baseEmoji: .maleDetective, skinTones: [.light]),
+            "🕵🏻‍♀️": EmojiWithSkinTones(baseEmoji: .femaleDetective, skinTones: [.light]),
+            "🕵🏼‍♂️": EmojiWithSkinTones(baseEmoji: .maleDetective, skinTones: [.mediumLight]),
+            "🕵🏼‍♀️": EmojiWithSkinTones(baseEmoji: .femaleDetective, skinTones: [.mediumLight]),
+            "🕵🏽‍♂️": EmojiWithSkinTones(baseEmoji: .maleDetective, skinTones: [.medium]),
+            "🕵🏽‍♀️": EmojiWithSkinTones(baseEmoji: .femaleDetective, skinTones: [.medium]),
+            "🕵🏾‍♂️": EmojiWithSkinTones(baseEmoji: .maleDetective, skinTones: [.mediumDark]),
+            "🕵🏾‍♀️": EmojiWithSkinTones(baseEmoji: .femaleDetective, skinTones: [.mediumDark]),
+            "🕵🏿‍♂️": EmojiWithSkinTones(baseEmoji: .maleDetective, skinTones: [.dark]),
+            "🕵🏿‍♀️": EmojiWithSkinTones(baseEmoji: .femaleDetective, skinTones: [.dark])
+        ]
+        return (lookup[rawValue] ?? EmojiWithSkinTones(unsupportedValue: rawValue))
+    }
+    
+    private static func emojiFrom3396(_ rawValue: String) -> EmojiWithSkinTones {
+        let lookup: [String: EmojiWithSkinTones] = [
+            "🙍🏻‍♂️": EmojiWithSkinTones(baseEmoji: .manFrowning, skinTones: [.light]),
+            "🙍🏻‍♀️": EmojiWithSkinTones(baseEmoji: .womanFrowning, skinTones: [.light]),
+            "🙎🏻‍♂️": EmojiWithSkinTones(baseEmoji: .manPouting, skinTones: [.light]),
+            "🙎🏻‍♀️": EmojiWithSkinTones(baseEmoji: .womanPouting, skinTones: [.light]),
+            "🙅🏻‍♂️": EmojiWithSkinTones(baseEmoji: .manGesturingNo, skinTones: [.light]),
+            "🙅🏻‍♀️": EmojiWithSkinTones(baseEmoji: .womanGesturingNo, skinTones: [.light]),
+            "🙆🏻‍♂️": EmojiWithSkinTones(baseEmoji: .manGesturingOk, skinTones: [.light]),
+            "🙆🏻‍♀️": EmojiWithSkinTones(baseEmoji: .womanGesturingOk, skinTones: [.light]),
+            "🙋🏻‍♂️": EmojiWithSkinTones(baseEmoji: .manRaisingHand, skinTones: [.light]),
+            "🙋🏻‍♀️": EmojiWithSkinTones(baseEmoji: .womanRaisingHand, skinTones: [.light]),
+            "🙇🏻‍♂️": EmojiWithSkinTones(baseEmoji: .manBowing, skinTones: [.light]),
+            "🙇🏻‍♀️": EmojiWithSkinTones(baseEmoji: .womanBowing, skinTones: [.light]),
+            "🙍🏼‍♂️": EmojiWithSkinTones(baseEmoji: .manFrowning, skinTones: [.mediumLight]),
+            "🙍🏼‍♀️": EmojiWithSkinTones(baseEmoji: .womanFrowning, skinTones: [.mediumLight]),
+            "🙎🏼‍♂️": EmojiWithSkinTones(baseEmoji: .manPouting, skinTones: [.mediumLight]),
+            "🙎🏼‍♀️": EmojiWithSkinTones(baseEmoji: .womanPouting, skinTones: [.mediumLight]),
+            "🙅🏼‍♂️": EmojiWithSkinTones(baseEmoji: .manGesturingNo, skinTones: [.mediumLight]),
+            "🙅🏼‍♀️": EmojiWithSkinTones(baseEmoji: .womanGesturingNo, skinTones: [.mediumLight]),
+            "🙆🏼‍♂️": EmojiWithSkinTones(baseEmoji: .manGesturingOk, skinTones: [.mediumLight]),
+            "🙆🏼‍♀️": EmojiWithSkinTones(baseEmoji: .womanGesturingOk, skinTones: [.mediumLight]),
+            "🙋🏼‍♂️": EmojiWithSkinTones(baseEmoji: .manRaisingHand, skinTones: [.mediumLight]),
+            "🙋🏼‍♀️": EmojiWithSkinTones(baseEmoji: .womanRaisingHand, skinTones: [.mediumLight]),
+            "🙇🏼‍♂️": EmojiWithSkinTones(baseEmoji: .manBowing, skinTones: [.mediumLight]),
+            "🙇🏼‍♀️": EmojiWithSkinTones(baseEmoji: .womanBowing, skinTones: [.mediumLight]),
+            "🙍🏽‍♂️": EmojiWithSkinTones(baseEmoji: .manFrowning, skinTones: [.medium]),
+            "🙍🏽‍♀️": EmojiWithSkinTones(baseEmoji: .womanFrowning, skinTones: [.medium]),
+            "🙎🏽‍♂️": EmojiWithSkinTones(baseEmoji: .manPouting, skinTones: [.medium]),
+            "🙎🏽‍♀️": EmojiWithSkinTones(baseEmoji: .womanPouting, skinTones: [.medium]),
+            "🙅🏽‍♂️": EmojiWithSkinTones(baseEmoji: .manGesturingNo, skinTones: [.medium]),
+            "🙅🏽‍♀️": EmojiWithSkinTones(baseEmoji: .womanGesturingNo, skinTones: [.medium]),
+            "🙆🏽‍♂️": EmojiWithSkinTones(baseEmoji: .manGesturingOk, skinTones: [.medium]),
+            "🙆🏽‍♀️": EmojiWithSkinTones(baseEmoji: .womanGesturingOk, skinTones: [.medium]),
+            "🙋🏽‍♂️": EmojiWithSkinTones(baseEmoji: .manRaisingHand, skinTones: [.medium]),
+            "🙋🏽‍♀️": EmojiWithSkinTones(baseEmoji: .womanRaisingHand, skinTones: [.medium]),
+            "🙇🏽‍♂️": EmojiWithSkinTones(baseEmoji: .manBowing, skinTones: [.medium]),
+            "🙇🏽‍♀️": EmojiWithSkinTones(baseEmoji: .womanBowing, skinTones: [.medium]),
+            "🙍🏾‍♂️": EmojiWithSkinTones(baseEmoji: .manFrowning, skinTones: [.mediumDark]),
+            "🙍🏾‍♀️": EmojiWithSkinTones(baseEmoji: .womanFrowning, skinTones: [.mediumDark]),
+            "🙎🏾‍♂️": EmojiWithSkinTones(baseEmoji: .manPouting, skinTones: [.mediumDark]),
+            "🙎🏾‍♀️": EmojiWithSkinTones(baseEmoji: .womanPouting, skinTones: [.mediumDark]),
+            "🙅🏾‍♂️": EmojiWithSkinTones(baseEmoji: .manGesturingNo, skinTones: [.mediumDark]),
+            "🙅🏾‍♀️": EmojiWithSkinTones(baseEmoji: .womanGesturingNo, skinTones: [.mediumDark]),
+            "🙆🏾‍♂️": EmojiWithSkinTones(baseEmoji: .manGesturingOk, skinTones: [.mediumDark]),
+            "🙆🏾‍♀️": EmojiWithSkinTones(baseEmoji: .womanGesturingOk, skinTones: [.mediumDark]),
+            "🙋🏾‍♂️": EmojiWithSkinTones(baseEmoji: .manRaisingHand, skinTones: [.mediumDark]),
+            "🙋🏾‍♀️": EmojiWithSkinTones(baseEmoji: .womanRaisingHand, skinTones: [.mediumDark]),
+            "🙇🏾‍♂️": EmojiWithSkinTones(baseEmoji: .manBowing, skinTones: [.mediumDark]),
+            "🙇🏾‍♀️": EmojiWithSkinTones(baseEmoji: .womanBowing, skinTones: [.mediumDark]),
+            "🙍🏿‍♂️": EmojiWithSkinTones(baseEmoji: .manFrowning, skinTones: [.dark]),
+            "🙍🏿‍♀️": EmojiWithSkinTones(baseEmoji: .womanFrowning, skinTones: [.dark]),
+            "🙎🏿‍♂️": EmojiWithSkinTones(baseEmoji: .manPouting, skinTones: [.dark]),
+            "🙎🏿‍♀️": EmojiWithSkinTones(baseEmoji: .womanPouting, skinTones: [.dark]),
+            "🙅🏿‍♂️": EmojiWithSkinTones(baseEmoji: .manGesturingNo, skinTones: [.dark]),
+            "🙅🏿‍♀️": EmojiWithSkinTones(baseEmoji: .womanGesturingNo, skinTones: [.dark]),
+            "🙆🏿‍♂️": EmojiWithSkinTones(baseEmoji: .manGesturingOk, skinTones: [.dark]),
+            "🙆🏿‍♀️": EmojiWithSkinTones(baseEmoji: .womanGesturingOk, skinTones: [.dark]),
+            "🙋🏿‍♂️": EmojiWithSkinTones(baseEmoji: .manRaisingHand, skinTones: [.dark]),
+            "🙋🏿‍♀️": EmojiWithSkinTones(baseEmoji: .womanRaisingHand, skinTones: [.dark]),
+            "🙇🏿‍♂️": EmojiWithSkinTones(baseEmoji: .manBowing, skinTones: [.dark]),
+            "🙇🏿‍♀️": EmojiWithSkinTones(baseEmoji: .womanBowing, skinTones: [.dark])
+        ]
+        return (lookup[rawValue] ?? EmojiWithSkinTones(unsupportedValue: rawValue))
+    }
+    
+    private static func emojiFrom3397(_ rawValue: String) -> EmojiWithSkinTones {
+        let lookup: [String: EmojiWithSkinTones] = [
+            "🚶🏻‍♂️": EmojiWithSkinTones(baseEmoji: .manWalking, skinTones: [.light]),
+            "🚶🏻‍♀️": EmojiWithSkinTones(baseEmoji: .womanWalking, skinTones: [.light]),
+            "🚣🏻‍♂️": EmojiWithSkinTones(baseEmoji: .manRowingBoat, skinTones: [.light]),
+            "🚣🏻‍♀️": EmojiWithSkinTones(baseEmoji: .womanRowingBoat, skinTones: [.light]),
+            "🚴🏻‍♂️": EmojiWithSkinTones(baseEmoji: .manBiking, skinTones: [.light]),
+            "🚴🏻‍♀️": EmojiWithSkinTones(baseEmoji: .womanBiking, skinTones: [.light]),
+            "🚵🏻‍♂️": EmojiWithSkinTones(baseEmoji: .manMountainBiking, skinTones: [.light]),
+            "🚵🏻‍♀️": EmojiWithSkinTones(baseEmoji: .womanMountainBiking, skinTones: [.light]),
+            "🚶🏼‍♂️": EmojiWithSkinTones(baseEmoji: .manWalking, skinTones: [.mediumLight]),
+            "🚶🏼‍♀️": EmojiWithSkinTones(baseEmoji: .womanWalking, skinTones: [.mediumLight]),
+            "🚣🏼‍♂️": EmojiWithSkinTones(baseEmoji: .manRowingBoat, skinTones: [.mediumLight]),
+            "🚣🏼‍♀️": EmojiWithSkinTones(baseEmoji: .womanRowingBoat, skinTones: [.mediumLight]),
+            "🚴🏼‍♂️": EmojiWithSkinTones(baseEmoji: .manBiking, skinTones: [.mediumLight]),
+            "🚴🏼‍♀️": EmojiWithSkinTones(baseEmoji: .womanBiking, skinTones: [.mediumLight]),
+            "🚵🏼‍♂️": EmojiWithSkinTones(baseEmoji: .manMountainBiking, skinTones: [.mediumLight]),
+            "🚵🏼‍♀️": EmojiWithSkinTones(baseEmoji: .womanMountainBiking, skinTones: [.mediumLight]),
+            "🚶🏽‍♂️": EmojiWithSkinTones(baseEmoji: .manWalking, skinTones: [.medium]),
+            "🚶🏽‍♀️": EmojiWithSkinTones(baseEmoji: .womanWalking, skinTones: [.medium]),
+            "🚣🏽‍♂️": EmojiWithSkinTones(baseEmoji: .manRowingBoat, skinTones: [.medium]),
+            "🚣🏽‍♀️": EmojiWithSkinTones(baseEmoji: .womanRowingBoat, skinTones: [.medium]),
+            "🚴🏽‍♂️": EmojiWithSkinTones(baseEmoji: .manBiking, skinTones: [.medium]),
+            "🚴🏽‍♀️": EmojiWithSkinTones(baseEmoji: .womanBiking, skinTones: [.medium]),
+            "🚵🏽‍♂️": EmojiWithSkinTones(baseEmoji: .manMountainBiking, skinTones: [.medium]),
+            "🚵🏽‍♀️": EmojiWithSkinTones(baseEmoji: .womanMountainBiking, skinTones: [.medium]),
+            "🚶🏾‍♂️": EmojiWithSkinTones(baseEmoji: .manWalking, skinTones: [.mediumDark]),
+            "🚶🏾‍♀️": EmojiWithSkinTones(baseEmoji: .womanWalking, skinTones: [.mediumDark]),
+            "🚣🏾‍♂️": EmojiWithSkinTones(baseEmoji: .manRowingBoat, skinTones: [.mediumDark]),
+            "🚣🏾‍♀️": EmojiWithSkinTones(baseEmoji: .womanRowingBoat, skinTones: [.mediumDark]),
+            "🚴🏾‍♂️": EmojiWithSkinTones(baseEmoji: .manBiking, skinTones: [.mediumDark]),
+            "🚴🏾‍♀️": EmojiWithSkinTones(baseEmoji: .womanBiking, skinTones: [.mediumDark]),
+            "🚵🏾‍♂️": EmojiWithSkinTones(baseEmoji: .manMountainBiking, skinTones: [.mediumDark]),
+            "🚵🏾‍♀️": EmojiWithSkinTones(baseEmoji: .womanMountainBiking, skinTones: [.mediumDark]),
+            "🚶🏿‍♂️": EmojiWithSkinTones(baseEmoji: .manWalking, skinTones: [.dark]),
+            "🚶🏿‍♀️": EmojiWithSkinTones(baseEmoji: .womanWalking, skinTones: [.dark]),
+            "🚣🏿‍♂️": EmojiWithSkinTones(baseEmoji: .manRowingBoat, skinTones: [.dark]),
+            "🚣🏿‍♀️": EmojiWithSkinTones(baseEmoji: .womanRowingBoat, skinTones: [.dark]),
+            "🚴🏿‍♂️": EmojiWithSkinTones(baseEmoji: .manBiking, skinTones: [.dark]),
+            "🚴🏿‍♀️": EmojiWithSkinTones(baseEmoji: .womanBiking, skinTones: [.dark]),
+            "🚵🏿‍♂️": EmojiWithSkinTones(baseEmoji: .manMountainBiking, skinTones: [.dark]),
+            "🚵🏿‍♀️": EmojiWithSkinTones(baseEmoji: .womanMountainBiking, skinTones: [.dark])
+        ]
+        return (lookup[rawValue] ?? EmojiWithSkinTones(unsupportedValue: rawValue))
+    }
+    
+    private static func emojiFrom3403(_ rawValue: String) -> EmojiWithSkinTones {
+        let lookup: [String: EmojiWithSkinTones] = [
+            "🤦🏻‍♂️": EmojiWithSkinTones(baseEmoji: .manFacepalming, skinTones: [.light]),
+            "🤦🏻‍♀️": EmojiWithSkinTones(baseEmoji: .womanFacepalming, skinTones: [.light]),
+            "🤷🏻‍♂️": EmojiWithSkinTones(baseEmoji: .manShrugging, skinTones: [.light]),
+            "🤷🏻‍♀️": EmojiWithSkinTones(baseEmoji: .womanShrugging, skinTones: [.light]),
+            "🤵🏻‍♂️": EmojiWithSkinTones(baseEmoji: .manInTuxedo, skinTones: [.light]),
+            "🤵🏻‍♀️": EmojiWithSkinTones(baseEmoji: .womanInTuxedo, skinTones: [.light]),
+            "🤸🏻‍♂️": EmojiWithSkinTones(baseEmoji: .manCartwheeling, skinTones: [.light]),
+            "🤸🏻‍♀️": EmojiWithSkinTones(baseEmoji: .womanCartwheeling, skinTones: [.light]),
+            "🤽🏻‍♂️": EmojiWithSkinTones(baseEmoji: .manPlayingWaterPolo, skinTones: [.light]),
+            "🤽🏻‍♀️": EmojiWithSkinTones(baseEmoji: .womanPlayingWaterPolo, skinTones: [.light]),
+            "🤾🏻‍♂️": EmojiWithSkinTones(baseEmoji: .manPlayingHandball, skinTones: [.light]),
+            "🤾🏻‍♀️": EmojiWithSkinTones(baseEmoji: .womanPlayingHandball, skinTones: [.light]),
+            "🤹🏻‍♂️": EmojiWithSkinTones(baseEmoji: .manJuggling, skinTones: [.light]),
+            "🤹🏻‍♀️": EmojiWithSkinTones(baseEmoji: .womanJuggling, skinTones: [.light]),
+            "🤦🏼‍♂️": EmojiWithSkinTones(baseEmoji: .manFacepalming, skinTones: [.mediumLight]),
+            "🤦🏼‍♀️": EmojiWithSkinTones(baseEmoji: .womanFacepalming, skinTones: [.mediumLight]),
+            "🤷🏼‍♂️": EmojiWithSkinTones(baseEmoji: .manShrugging, skinTones: [.mediumLight]),
+            "🤷🏼‍♀️": EmojiWithSkinTones(baseEmoji: .womanShrugging, skinTones: [.mediumLight]),
+            "🤵🏼‍♂️": EmojiWithSkinTones(baseEmoji: .manInTuxedo, skinTones: [.mediumLight]),
+            "🤵🏼‍♀️": EmojiWithSkinTones(baseEmoji: .womanInTuxedo, skinTones: [.mediumLight]),
+            "🤸🏼‍♂️": EmojiWithSkinTones(baseEmoji: .manCartwheeling, skinTones: [.mediumLight]),
+            "🤸🏼‍♀️": EmojiWithSkinTones(baseEmoji: .womanCartwheeling, skinTones: [.mediumLight]),
+            "🤽🏼‍♂️": EmojiWithSkinTones(baseEmoji: .manPlayingWaterPolo, skinTones: [.mediumLight]),
+            "🤽🏼‍♀️": EmojiWithSkinTones(baseEmoji: .womanPlayingWaterPolo, skinTones: [.mediumLight]),
+            "🤾🏼‍♂️": EmojiWithSkinTones(baseEmoji: .manPlayingHandball, skinTones: [.mediumLight]),
+            "🤾🏼‍♀️": EmojiWithSkinTones(baseEmoji: .womanPlayingHandball, skinTones: [.mediumLight]),
+            "🤹🏼‍♂️": EmojiWithSkinTones(baseEmoji: .manJuggling, skinTones: [.mediumLight]),
+            "🤹🏼‍♀️": EmojiWithSkinTones(baseEmoji: .womanJuggling, skinTones: [.mediumLight]),
+            "🤦🏽‍♂️": EmojiWithSkinTones(baseEmoji: .manFacepalming, skinTones: [.medium]),
+            "🤦🏽‍♀️": EmojiWithSkinTones(baseEmoji: .womanFacepalming, skinTones: [.medium]),
+            "🤷🏽‍♂️": EmojiWithSkinTones(baseEmoji: .manShrugging, skinTones: [.medium]),
+            "🤷🏽‍♀️": EmojiWithSkinTones(baseEmoji: .womanShrugging, skinTones: [.medium]),
+            "🤵🏽‍♂️": EmojiWithSkinTones(baseEmoji: .manInTuxedo, skinTones: [.medium]),
+            "🤵🏽‍♀️": EmojiWithSkinTones(baseEmoji: .womanInTuxedo, skinTones: [.medium]),
+            "🤸🏽‍♂️": EmojiWithSkinTones(baseEmoji: .manCartwheeling, skinTones: [.medium]),
+            "🤸🏽‍♀️": EmojiWithSkinTones(baseEmoji: .womanCartwheeling, skinTones: [.medium]),
+            "🤽🏽‍♂️": EmojiWithSkinTones(baseEmoji: .manPlayingWaterPolo, skinTones: [.medium]),
+            "🤽🏽‍♀️": EmojiWithSkinTones(baseEmoji: .womanPlayingWaterPolo, skinTones: [.medium]),
+            "🤾🏽‍♂️": EmojiWithSkinTones(baseEmoji: .manPlayingHandball, skinTones: [.medium]),
+            "🤾🏽‍♀️": EmojiWithSkinTones(baseEmoji: .womanPlayingHandball, skinTones: [.medium]),
+            "🤹🏽‍♂️": EmojiWithSkinTones(baseEmoji: .manJuggling, skinTones: [.medium]),
+            "🤹🏽‍♀️": EmojiWithSkinTones(baseEmoji: .womanJuggling, skinTones: [.medium]),
+            "🤦🏾‍♂️": EmojiWithSkinTones(baseEmoji: .manFacepalming, skinTones: [.mediumDark]),
+            "🤦🏾‍♀️": EmojiWithSkinTones(baseEmoji: .womanFacepalming, skinTones: [.mediumDark]),
+            "🤷🏾‍♂️": EmojiWithSkinTones(baseEmoji: .manShrugging, skinTones: [.mediumDark]),
+            "🤷🏾‍♀️": EmojiWithSkinTones(baseEmoji: .womanShrugging, skinTones: [.mediumDark]),
+            "🤵🏾‍♂️": EmojiWithSkinTones(baseEmoji: .manInTuxedo, skinTones: [.mediumDark]),
+            "🤵🏾‍♀️": EmojiWithSkinTones(baseEmoji: .womanInTuxedo, skinTones: [.mediumDark]),
+            "🤸🏾‍♂️": EmojiWithSkinTones(baseEmoji: .manCartwheeling, skinTones: [.mediumDark]),
+            "🤸🏾‍♀️": EmojiWithSkinTones(baseEmoji: .womanCartwheeling, skinTones: [.mediumDark]),
+            "🤽🏾‍♂️": EmojiWithSkinTones(baseEmoji: .manPlayingWaterPolo, skinTones: [.mediumDark]),
+            "🤽🏾‍♀️": EmojiWithSkinTones(baseEmoji: .womanPlayingWaterPolo, skinTones: [.mediumDark]),
+            "🤾🏾‍♂️": EmojiWithSkinTones(baseEmoji: .manPlayingHandball, skinTones: [.mediumDark]),
+            "🤾🏾‍♀️": EmojiWithSkinTones(baseEmoji: .womanPlayingHandball, skinTones: [.mediumDark]),
+            "🤹🏾‍♂️": EmojiWithSkinTones(baseEmoji: .manJuggling, skinTones: [.mediumDark]),
+            "🤹🏾‍♀️": EmojiWithSkinTones(baseEmoji: .womanJuggling, skinTones: [.mediumDark]),
+            "🤦🏿‍♂️": EmojiWithSkinTones(baseEmoji: .manFacepalming, skinTones: [.dark]),
+            "🤦🏿‍♀️": EmojiWithSkinTones(baseEmoji: .womanFacepalming, skinTones: [.dark]),
+            "🤷🏿‍♂️": EmojiWithSkinTones(baseEmoji: .manShrugging, skinTones: [.dark]),
+            "🤷🏿‍♀️": EmojiWithSkinTones(baseEmoji: .womanShrugging, skinTones: [.dark]),
+            "🤵🏿‍♂️": EmojiWithSkinTones(baseEmoji: .manInTuxedo, skinTones: [.dark]),
+            "🤵🏿‍♀️": EmojiWithSkinTones(baseEmoji: .womanInTuxedo, skinTones: [.dark]),
+            "🤸🏿‍♂️": EmojiWithSkinTones(baseEmoji: .manCartwheeling, skinTones: [.dark]),
+            "🤸🏿‍♀️": EmojiWithSkinTones(baseEmoji: .womanCartwheeling, skinTones: [.dark]),
+            "🤽🏿‍♂️": EmojiWithSkinTones(baseEmoji: .manPlayingWaterPolo, skinTones: [.dark]),
+            "🤽🏿‍♀️": EmojiWithSkinTones(baseEmoji: .womanPlayingWaterPolo, skinTones: [.dark]),
+            "🤾🏿‍♂️": EmojiWithSkinTones(baseEmoji: .manPlayingHandball, skinTones: [.dark]),
+            "🤾🏿‍♀️": EmojiWithSkinTones(baseEmoji: .womanPlayingHandball, skinTones: [.dark]),
+            "🤹🏿‍♂️": EmojiWithSkinTones(baseEmoji: .manJuggling, skinTones: [.dark]),
+            "🤹🏿‍♀️": EmojiWithSkinTones(baseEmoji: .womanJuggling, skinTones: [.dark])
+        ]
+        return (lookup[rawValue] ?? EmojiWithSkinTones(unsupportedValue: rawValue))
+    }
+    
+    private static func emojiFrom3404(_ rawValue: String) -> EmojiWithSkinTones {
+        let lookup: [String: EmojiWithSkinTones] = [
+            "🦸🏻‍♂️": EmojiWithSkinTones(baseEmoji: .maleSuperhero, skinTones: [.light]),
+            "🦸🏻‍♀️": EmojiWithSkinTones(baseEmoji: .femaleSuperhero, skinTones: [.light]),
+            "🦹🏻‍♂️": EmojiWithSkinTones(baseEmoji: .maleSupervillain, skinTones: [.light]),
+            "🦹🏻‍♀️": EmojiWithSkinTones(baseEmoji: .femaleSupervillain, skinTones: [.light]),
+            "🦸🏼‍♂️": EmojiWithSkinTones(baseEmoji: .maleSuperhero, skinTones: [.mediumLight]),
+            "🦸🏼‍♀️": EmojiWithSkinTones(baseEmoji: .femaleSuperhero, skinTones: [.mediumLight]),
+            "🦹🏼‍♂️": EmojiWithSkinTones(baseEmoji: .maleSupervillain, skinTones: [.mediumLight]),
+            "🦹🏼‍♀️": EmojiWithSkinTones(baseEmoji: .femaleSupervillain, skinTones: [.mediumLight]),
+            "🦸🏽‍♂️": EmojiWithSkinTones(baseEmoji: .maleSuperhero, skinTones: [.medium]),
+            "🦸🏽‍♀️": EmojiWithSkinTones(baseEmoji: .femaleSuperhero, skinTones: [.medium]),
+            "🦹🏽‍♀️": EmojiWithSkinTones(baseEmoji: .femaleSupervillain, skinTones: [.medium]),
+            "🦸🏾‍♀️": EmojiWithSkinTones(baseEmoji: .femaleSuperhero, skinTones: [.mediumDark]),
+            "🦹🏾‍♀️": EmojiWithSkinTones(baseEmoji: .femaleSupervillain, skinTones: [.mediumDark]),
+            "🦸🏿‍♀️": EmojiWithSkinTones(baseEmoji: .femaleSuperhero, skinTones: [.dark])
+        ]
+        return (lookup[rawValue] ?? EmojiWithSkinTones(unsupportedValue: rawValue))
+    }
+    
+    private static func emojiFrom3405(_ rawValue: String) -> EmojiWithSkinTones {
+        let lookup: [String: EmojiWithSkinTones] = [
+            "🧔🏻‍♂️": EmojiWithSkinTones(baseEmoji: .manWithBeard, skinTones: [.light]),
+            "🧔🏻‍♀️": EmojiWithSkinTones(baseEmoji: .womanWithBeard, skinTones: [.light]),
+            "🧏🏻‍♂️": EmojiWithSkinTones(baseEmoji: .deafMan, skinTones: [.light]),
+            "🧏🏻‍♀️": EmojiWithSkinTones(baseEmoji: .deafWoman, skinTones: [.light]),
+            "🧙🏻‍♂️": EmojiWithSkinTones(baseEmoji: .maleMage, skinTones: [.light]),
+            "🧙🏻‍♀️": EmojiWithSkinTones(baseEmoji: .femaleMage, skinTones: [.light]),
+            "🧚🏻‍♂️": EmojiWithSkinTones(baseEmoji: .maleFairy, skinTones: [.light]),
+            "🧚🏻‍♀️": EmojiWithSkinTones(baseEmoji: .femaleFairy, skinTones: [.light]),
+            "🧛🏻‍♂️": EmojiWithSkinTones(baseEmoji: .maleVampire, skinTones: [.light]),
+            "🧛🏻‍♀️": EmojiWithSkinTones(baseEmoji: .femaleVampire, skinTones: [.light]),
+            "🧜🏻‍♂️": EmojiWithSkinTones(baseEmoji: .merman, skinTones: [.light]),
+            "🧜🏻‍♀️": EmojiWithSkinTones(baseEmoji: .mermaid, skinTones: [.light]),
+            "🧝🏻‍♂️": EmojiWithSkinTones(baseEmoji: .maleElf, skinTones: [.light]),
+            "🧝🏻‍♀️": EmojiWithSkinTones(baseEmoji: .femaleElf, skinTones: [.light]),
+            "🧍🏻‍♂️": EmojiWithSkinTones(baseEmoji: .manStanding, skinTones: [.light]),
+            "🧍🏻‍♀️": EmojiWithSkinTones(baseEmoji: .womanStanding, skinTones: [.light]),
+            "🧎🏻‍♂️": EmojiWithSkinTones(baseEmoji: .manKneeling, skinTones: [.light]),
+            "🧎🏻‍♀️": EmojiWithSkinTones(baseEmoji: .womanKneeling, skinTones: [.light]),
+            "🧖🏻‍♂️": EmojiWithSkinTones(baseEmoji: .manInSteamyRoom, skinTones: [.light]),
+            "🧖🏻‍♀️": EmojiWithSkinTones(baseEmoji: .womanInSteamyRoom, skinTones: [.light]),
+            "🧗🏻‍♂️": EmojiWithSkinTones(baseEmoji: .manClimbing, skinTones: [.light]),
+            "🧗🏻‍♀️": EmojiWithSkinTones(baseEmoji: .womanClimbing, skinTones: [.light]),
+            "🧘🏻‍♂️": EmojiWithSkinTones(baseEmoji: .manInLotusPosition, skinTones: [.light]),
+            "🧘🏻‍♀️": EmojiWithSkinTones(baseEmoji: .womanInLotusPosition, skinTones: [.light]),
+            "🧔🏼‍♂️": EmojiWithSkinTones(baseEmoji: .manWithBeard, skinTones: [.mediumLight]),
+            "🧔🏼‍♀️": EmojiWithSkinTones(baseEmoji: .womanWithBeard, skinTones: [.mediumLight]),
+            "🧏🏼‍♂️": EmojiWithSkinTones(baseEmoji: .deafMan, skinTones: [.mediumLight]),
+            "🧏🏼‍♀️": EmojiWithSkinTones(baseEmoji: .deafWoman, skinTones: [.mediumLight]),
+            "🧙🏼‍♂️": EmojiWithSkinTones(baseEmoji: .maleMage, skinTones: [.mediumLight]),
+            "🧙🏼‍♀️": EmojiWithSkinTones(baseEmoji: .femaleMage, skinTones: [.mediumLight]),
+            "🧚🏼‍♂️": EmojiWithSkinTones(baseEmoji: .maleFairy, skinTones: [.mediumLight]),
+            "🧚🏼‍♀️": EmojiWithSkinTones(baseEmoji: .femaleFairy, skinTones: [.mediumLight]),
+            "🧛🏼‍♂️": EmojiWithSkinTones(baseEmoji: .maleVampire, skinTones: [.mediumLight]),
+            "🧛🏼‍♀️": EmojiWithSkinTones(baseEmoji: .femaleVampire, skinTones: [.mediumLight]),
+            "🧜🏼‍♂️": EmojiWithSkinTones(baseEmoji: .merman, skinTones: [.mediumLight]),
+            "🧜🏼‍♀️": EmojiWithSkinTones(baseEmoji: .mermaid, skinTones: [.mediumLight]),
+            "🧝🏼‍♂️": EmojiWithSkinTones(baseEmoji: .maleElf, skinTones: [.mediumLight]),
+            "🧝🏼‍♀️": EmojiWithSkinTones(baseEmoji: .femaleElf, skinTones: [.mediumLight]),
+            "🧍🏼‍♂️": EmojiWithSkinTones(baseEmoji: .manStanding, skinTones: [.mediumLight]),
+            "🧍🏼‍♀️": EmojiWithSkinTones(baseEmoji: .womanStanding, skinTones: [.mediumLight]),
+            "🧎🏼‍♂️": EmojiWithSkinTones(baseEmoji: .manKneeling, skinTones: [.mediumLight]),
+            "🧎🏼‍♀️": EmojiWithSkinTones(baseEmoji: .womanKneeling, skinTones: [.mediumLight]),
+            "🧖🏼‍♂️": EmojiWithSkinTones(baseEmoji: .manInSteamyRoom, skinTones: [.mediumLight]),
+            "🧖🏼‍♀️": EmojiWithSkinTones(baseEmoji: .womanInSteamyRoom, skinTones: [.mediumLight]),
+            "🧗🏼‍♂️": EmojiWithSkinTones(baseEmoji: .manClimbing, skinTones: [.mediumLight]),
+            "🧗🏼‍♀️": EmojiWithSkinTones(baseEmoji: .womanClimbing, skinTones: [.mediumLight]),
+            "🧘🏼‍♂️": EmojiWithSkinTones(baseEmoji: .manInLotusPosition, skinTones: [.mediumLight]),
+            "🧘🏼‍♀️": EmojiWithSkinTones(baseEmoji: .womanInLotusPosition, skinTones: [.mediumLight]),
+            "🧔🏽‍♂️": EmojiWithSkinTones(baseEmoji: .manWithBeard, skinTones: [.medium]),
+            "🧔🏽‍♀️": EmojiWithSkinTones(baseEmoji: .womanWithBeard, skinTones: [.medium]),
+            "🧏🏽‍♂️": EmojiWithSkinTones(baseEmoji: .deafMan, skinTones: [.medium]),
+            "🧏🏽‍♀️": EmojiWithSkinTones(baseEmoji: .deafWoman, skinTones: [.medium]),
+            "🦹🏽‍♂️": EmojiWithSkinTones(baseEmoji: .maleSupervillain, skinTones: [.medium]),
+            "🧙🏽‍♂️": EmojiWithSkinTones(baseEmoji: .maleMage, skinTones: [.medium]),
+            "🧙🏽‍♀️": EmojiWithSkinTones(baseEmoji: .femaleMage, skinTones: [.medium]),
+            "🧚🏽‍♂️": EmojiWithSkinTones(baseEmoji: .maleFairy, skinTones: [.medium]),
+            "🧚🏽‍♀️": EmojiWithSkinTones(baseEmoji: .femaleFairy, skinTones: [.medium]),
+            "🧛🏽‍♂️": EmojiWithSkinTones(baseEmoji: .maleVampire, skinTones: [.medium]),
+            "🧛🏽‍♀️": EmojiWithSkinTones(baseEmoji: .femaleVampire, skinTones: [.medium]),
+            "🧜🏽‍♂️": EmojiWithSkinTones(baseEmoji: .merman, skinTones: [.medium]),
+            "🧜🏽‍♀️": EmojiWithSkinTones(baseEmoji: .mermaid, skinTones: [.medium]),
+            "🧝🏽‍♂️": EmojiWithSkinTones(baseEmoji: .maleElf, skinTones: [.medium]),
+            "🧝🏽‍♀️": EmojiWithSkinTones(baseEmoji: .femaleElf, skinTones: [.medium]),
+            "🧍🏽‍♂️": EmojiWithSkinTones(baseEmoji: .manStanding, skinTones: [.medium]),
+            "🧍🏽‍♀️": EmojiWithSkinTones(baseEmoji: .womanStanding, skinTones: [.medium]),
+            "🧎🏽‍♂️": EmojiWithSkinTones(baseEmoji: .manKneeling, skinTones: [.medium]),
+            "🧎🏽‍♀️": EmojiWithSkinTones(baseEmoji: .womanKneeling, skinTones: [.medium]),
+            "🧖🏽‍♂️": EmojiWithSkinTones(baseEmoji: .manInSteamyRoom, skinTones: [.medium]),
+            "🧖🏽‍♀️": EmojiWithSkinTones(baseEmoji: .womanInSteamyRoom, skinTones: [.medium]),
+            "🧗🏽‍♂️": EmojiWithSkinTones(baseEmoji: .manClimbing, skinTones: [.medium]),
+            "🧗🏽‍♀️": EmojiWithSkinTones(baseEmoji: .womanClimbing, skinTones: [.medium]),
+            "🧘🏽‍♂️": EmojiWithSkinTones(baseEmoji: .manInLotusPosition, skinTones: [.medium]),
+            "🧘🏽‍♀️": EmojiWithSkinTones(baseEmoji: .womanInLotusPosition, skinTones: [.medium]),
+            "🧔🏾‍♂️": EmojiWithSkinTones(baseEmoji: .manWithBeard, skinTones: [.mediumDark]),
+            "🧔🏾‍♀️": EmojiWithSkinTones(baseEmoji: .womanWithBeard, skinTones: [.mediumDark]),
+            "🧏🏾‍♂️": EmojiWithSkinTones(baseEmoji: .deafMan, skinTones: [.mediumDark]),
+            "🧏🏾‍♀️": EmojiWithSkinTones(baseEmoji: .deafWoman, skinTones: [.mediumDark]),
+            "🦸🏾‍♂️": EmojiWithSkinTones(baseEmoji: .maleSuperhero, skinTones: [.mediumDark]),
+            "🦹🏾‍♂️": EmojiWithSkinTones(baseEmoji: .maleSupervillain, skinTones: [.mediumDark]),
+            "🧙🏾‍♂️": EmojiWithSkinTones(baseEmoji: .maleMage, skinTones: [.mediumDark]),
+            "🧙🏾‍♀️": EmojiWithSkinTones(baseEmoji: .femaleMage, skinTones: [.mediumDark]),
+            "🧚🏾‍♂️": EmojiWithSkinTones(baseEmoji: .maleFairy, skinTones: [.mediumDark]),
+            "🧚🏾‍♀️": EmojiWithSkinTones(baseEmoji: .femaleFairy, skinTones: [.mediumDark]),
+            "🧛🏾‍♂️": EmojiWithSkinTones(baseEmoji: .maleVampire, skinTones: [.mediumDark]),
+            "🧛🏾‍♀️": EmojiWithSkinTones(baseEmoji: .femaleVampire, skinTones: [.mediumDark]),
+            "🧜🏾‍♂️": EmojiWithSkinTones(baseEmoji: .merman, skinTones: [.mediumDark]),
+            "🧜🏾‍♀️": EmojiWithSkinTones(baseEmoji: .mermaid, skinTones: [.mediumDark]),
+            "🧝🏾‍♂️": EmojiWithSkinTones(baseEmoji: .maleElf, skinTones: [.mediumDark]),
+            "🧝🏾‍♀️": EmojiWithSkinTones(baseEmoji: .femaleElf, skinTones: [.mediumDark]),
+            "🧍🏾‍♂️": EmojiWithSkinTones(baseEmoji: .manStanding, skinTones: [.mediumDark]),
+            "🧍🏾‍♀️": EmojiWithSkinTones(baseEmoji: .womanStanding, skinTones: [.mediumDark]),
+            "🧎🏾‍♂️": EmojiWithSkinTones(baseEmoji: .manKneeling, skinTones: [.mediumDark]),
+            "🧎🏾‍♀️": EmojiWithSkinTones(baseEmoji: .womanKneeling, skinTones: [.mediumDark]),
+            "🧖🏾‍♂️": EmojiWithSkinTones(baseEmoji: .manInSteamyRoom, skinTones: [.mediumDark]),
+            "🧖🏾‍♀️": EmojiWithSkinTones(baseEmoji: .womanInSteamyRoom, skinTones: [.mediumDark]),
+            "🧗🏾‍♂️": EmojiWithSkinTones(baseEmoji: .manClimbing, skinTones: [.mediumDark]),
+            "🧗🏾‍♀️": EmojiWithSkinTones(baseEmoji: .womanClimbing, skinTones: [.mediumDark]),
+            "🧘🏾‍♂️": EmojiWithSkinTones(baseEmoji: .manInLotusPosition, skinTones: [.mediumDark]),
+            "🧘🏾‍♀️": EmojiWithSkinTones(baseEmoji: .womanInLotusPosition, skinTones: [.mediumDark]),
+            "🧔🏿‍♂️": EmojiWithSkinTones(baseEmoji: .manWithBeard, skinTones: [.dark]),
+            "🧔🏿‍♀️": EmojiWithSkinTones(baseEmoji: .womanWithBeard, skinTones: [.dark]),
+            "🧏🏿‍♂️": EmojiWithSkinTones(baseEmoji: .deafMan, skinTones: [.dark]),
+            "🧏🏿‍♀️": EmojiWithSkinTones(baseEmoji: .deafWoman, skinTones: [.dark]),
+            "🦸🏿‍♂️": EmojiWithSkinTones(baseEmoji: .maleSuperhero, skinTones: [.dark]),
+            "🦹🏿‍♂️": EmojiWithSkinTones(baseEmoji: .maleSupervillain, skinTones: [.dark]),
+            "🦹🏿‍♀️": EmojiWithSkinTones(baseEmoji: .femaleSupervillain, skinTones: [.dark]),
+            "🧙🏿‍♂️": EmojiWithSkinTones(baseEmoji: .maleMage, skinTones: [.dark]),
+            "🧙🏿‍♀️": EmojiWithSkinTones(baseEmoji: .femaleMage, skinTones: [.dark]),
+            "🧚🏿‍♂️": EmojiWithSkinTones(baseEmoji: .maleFairy, skinTones: [.dark]),
+            "🧚🏿‍♀️": EmojiWithSkinTones(baseEmoji: .femaleFairy, skinTones: [.dark]),
+            "🧛🏿‍♂️": EmojiWithSkinTones(baseEmoji: .maleVampire, skinTones: [.dark]),
+            "🧛🏿‍♀️": EmojiWithSkinTones(baseEmoji: .femaleVampire, skinTones: [.dark]),
+            "🧜🏿‍♂️": EmojiWithSkinTones(baseEmoji: .merman, skinTones: [.dark]),
+            "🧜🏿‍♀️": EmojiWithSkinTones(baseEmoji: .mermaid, skinTones: [.dark]),
+            "🧝🏿‍♂️": EmojiWithSkinTones(baseEmoji: .maleElf, skinTones: [.dark]),
+            "🧝🏿‍♀️": EmojiWithSkinTones(baseEmoji: .femaleElf, skinTones: [.dark]),
+            "🧍🏿‍♂️": EmojiWithSkinTones(baseEmoji: .manStanding, skinTones: [.dark]),
+            "🧍🏿‍♀️": EmojiWithSkinTones(baseEmoji: .womanStanding, skinTones: [.dark]),
+            "🧎🏿‍♂️": EmojiWithSkinTones(baseEmoji: .manKneeling, skinTones: [.dark]),
+            "🧎🏿‍♀️": EmojiWithSkinTones(baseEmoji: .womanKneeling, skinTones: [.dark]),
+            "🧖🏿‍♂️": EmojiWithSkinTones(baseEmoji: .manInSteamyRoom, skinTones: [.dark]),
+            "🧖🏿‍♀️": EmojiWithSkinTones(baseEmoji: .womanInSteamyRoom, skinTones: [.dark]),
+            "🧗🏿‍♂️": EmojiWithSkinTones(baseEmoji: .manClimbing, skinTones: [.dark]),
+            "🧗🏿‍♀️": EmojiWithSkinTones(baseEmoji: .womanClimbing, skinTones: [.dark]),
+            "🧘🏿‍♂️": EmojiWithSkinTones(baseEmoji: .manInLotusPosition, skinTones: [.dark]),
+            "🧘🏿‍♀️": EmojiWithSkinTones(baseEmoji: .womanInLotusPosition, skinTones: [.dark])
+        ]
+        return (lookup[rawValue] ?? EmojiWithSkinTones(unsupportedValue: rawValue))
+    }
+    
+    private static func emojiFrom3406(_ rawValue: String) -> EmojiWithSkinTones {
+        let lookup: [String: EmojiWithSkinTones] = [
+            "🧑🏻‍⚕️": EmojiWithSkinTones(baseEmoji: .healthWorker, skinTones: [.light]),
+            "🧑🏻‍⚖️": EmojiWithSkinTones(baseEmoji: .judge, skinTones: [.light]),
+            "🧑🏼‍⚕️": EmojiWithSkinTones(baseEmoji: .healthWorker, skinTones: [.mediumLight]),
+            "🧑🏼‍⚖️": EmojiWithSkinTones(baseEmoji: .judge, skinTones: [.mediumLight]),
+            "🧑🏽‍⚕️": EmojiWithSkinTones(baseEmoji: .healthWorker, skinTones: [.medium]),
+            "🧑🏽‍⚖️": EmojiWithSkinTones(baseEmoji: .judge, skinTones: [.medium]),
+            "🧑🏾‍⚕️": EmojiWithSkinTones(baseEmoji: .healthWorker, skinTones: [.mediumDark]),
+            "🧑🏾‍⚖️": EmojiWithSkinTones(baseEmoji: .judge, skinTones: [.mediumDark]),
+            "🧑🏿‍⚕️": EmojiWithSkinTones(baseEmoji: .healthWorker, skinTones: [.dark]),
+            "🧑🏿‍⚖️": EmojiWithSkinTones(baseEmoji: .judge, skinTones: [.dark])
+        ]
+        return (lookup[rawValue] ?? EmojiWithSkinTones(unsupportedValue: rawValue))
+    }
+    
+    private static func emojiFrom3407(_ rawValue: String) -> EmojiWithSkinTones {
+        let lookup: [String: EmojiWithSkinTones] = [
+            "🧑🏻‍✈️": EmojiWithSkinTones(baseEmoji: .pilot, skinTones: [.light]),
+            "🧑🏼‍✈️": EmojiWithSkinTones(baseEmoji: .pilot, skinTones: [.mediumLight]),
+            "🧑🏽‍✈️": EmojiWithSkinTones(baseEmoji: .pilot, skinTones: [.medium]),
+            "🧑🏾‍✈️": EmojiWithSkinTones(baseEmoji: .pilot, skinTones: [.mediumDark]),
+            "🧑🏿‍✈️": EmojiWithSkinTones(baseEmoji: .pilot, skinTones: [.dark])
+        ]
+        return (lookup[rawValue] ?? EmojiWithSkinTones(unsupportedValue: rawValue))
+    }
+    
+    private static func emojiFrom3477(_ rawValue: String) -> EmojiWithSkinTones {
+        let lookup: [String: EmojiWithSkinTones] = [
+            "👩‍❤️‍👨": EmojiWithSkinTones(baseEmoji: .womanHeartMan, skinTones: nil),
+            "👨‍❤️‍👨": EmojiWithSkinTones(baseEmoji: .manHeartMan, skinTones: nil),
+            "👩‍❤️‍👩": EmojiWithSkinTones(baseEmoji: .womanHeartWoman, skinTones: nil)
+        ]
+        return (lookup[rawValue] ?? EmojiWithSkinTones(unsupportedValue: rawValue))
+    }
+    
+    private static func emojiFrom3921(_ rawValue: String) -> EmojiWithSkinTones {
+        let lookup: [String: EmojiWithSkinTones] = [
+            "👨🏻‍🎓": EmojiWithSkinTones(baseEmoji: .maleStudent, skinTones: [.light]),
+            "👩🏻‍🎓": EmojiWithSkinTones(baseEmoji: .femaleStudent, skinTones: [.light]),
+            "👨🏻‍🌾": EmojiWithSkinTones(baseEmoji: .maleFarmer, skinTones: [.light]),
+            "👩🏻‍🌾": EmojiWithSkinTones(baseEmoji: .femaleFarmer, skinTones: [.light]),
+            "👨🏻‍🍳": EmojiWithSkinTones(baseEmoji: .maleCook, skinTones: [.light]),
+            "👩🏻‍🍳": EmojiWithSkinTones(baseEmoji: .femaleCook, skinTones: [.light]),
+            "👩🏻‍🍼": EmojiWithSkinTones(baseEmoji: .womanFeedingBaby, skinTones: [.light]),
+            "👨🏻‍🍼": EmojiWithSkinTones(baseEmoji: .manFeedingBaby, skinTones: [.light]),
+            "👨🏼‍🎓": EmojiWithSkinTones(baseEmoji: .maleStudent, skinTones: [.mediumLight]),
+            "👩🏼‍🎓": EmojiWithSkinTones(baseEmoji: .femaleStudent, skinTones: [.mediumLight]),
+            "👨🏼‍🌾": EmojiWithSkinTones(baseEmoji: .maleFarmer, skinTones: [.mediumLight]),
+            "👩🏼‍🌾": EmojiWithSkinTones(baseEmoji: .femaleFarmer, skinTones: [.mediumLight]),
+            "👨🏼‍🍳": EmojiWithSkinTones(baseEmoji: .maleCook, skinTones: [.mediumLight]),
+            "👩🏼‍🍳": EmojiWithSkinTones(baseEmoji: .femaleCook, skinTones: [.mediumLight]),
+            "👩🏼‍🍼": EmojiWithSkinTones(baseEmoji: .womanFeedingBaby, skinTones: [.mediumLight]),
+            "👨🏼‍🍼": EmojiWithSkinTones(baseEmoji: .manFeedingBaby, skinTones: [.mediumLight]),
+            "👨🏽‍🎓": EmojiWithSkinTones(baseEmoji: .maleStudent, skinTones: [.medium]),
+            "👩🏽‍🎓": EmojiWithSkinTones(baseEmoji: .femaleStudent, skinTones: [.medium]),
+            "👨🏽‍🌾": EmojiWithSkinTones(baseEmoji: .maleFarmer, skinTones: [.medium]),
+            "👩🏽‍🌾": EmojiWithSkinTones(baseEmoji: .femaleFarmer, skinTones: [.medium]),
+            "👨🏽‍🍳": EmojiWithSkinTones(baseEmoji: .maleCook, skinTones: [.medium]),
+            "👩🏽‍🍳": EmojiWithSkinTones(baseEmoji: .femaleCook, skinTones: [.medium]),
+            "👩🏽‍🍼": EmojiWithSkinTones(baseEmoji: .womanFeedingBaby, skinTones: [.medium]),
+            "👨🏽‍🍼": EmojiWithSkinTones(baseEmoji: .manFeedingBaby, skinTones: [.medium]),
+            "👨🏾‍🎓": EmojiWithSkinTones(baseEmoji: .maleStudent, skinTones: [.mediumDark]),
+            "👩🏾‍🎓": EmojiWithSkinTones(baseEmoji: .femaleStudent, skinTones: [.mediumDark]),
+            "👨🏾‍🌾": EmojiWithSkinTones(baseEmoji: .maleFarmer, skinTones: [.mediumDark]),
+            "👩🏾‍🌾": EmojiWithSkinTones(baseEmoji: .femaleFarmer, skinTones: [.mediumDark]),
+            "👨🏾‍🍳": EmojiWithSkinTones(baseEmoji: .maleCook, skinTones: [.mediumDark]),
+            "👩🏾‍🍳": EmojiWithSkinTones(baseEmoji: .femaleCook, skinTones: [.mediumDark]),
+            "👩🏾‍🍼": EmojiWithSkinTones(baseEmoji: .womanFeedingBaby, skinTones: [.mediumDark]),
+            "👨🏾‍🍼": EmojiWithSkinTones(baseEmoji: .manFeedingBaby, skinTones: [.mediumDark]),
+            "👨🏿‍🎓": EmojiWithSkinTones(baseEmoji: .maleStudent, skinTones: [.dark]),
+            "👨🏿‍🌾": EmojiWithSkinTones(baseEmoji: .maleFarmer, skinTones: [.dark]),
+            "👩🏿‍🌾": EmojiWithSkinTones(baseEmoji: .femaleFarmer, skinTones: [.dark]),
+            "👨🏿‍🍳": EmojiWithSkinTones(baseEmoji: .maleCook, skinTones: [.dark]),
+            "👩🏿‍🍳": EmojiWithSkinTones(baseEmoji: .femaleCook, skinTones: [.dark]),
+            "👩🏿‍🍼": EmojiWithSkinTones(baseEmoji: .womanFeedingBaby, skinTones: [.dark]),
+            "👨🏿‍🍼": EmojiWithSkinTones(baseEmoji: .manFeedingBaby, skinTones: [.dark])
+        ]
+        return (lookup[rawValue] ?? EmojiWithSkinTones(unsupportedValue: rawValue))
+    }
+    
+    private static func emojiFrom3922(_ rawValue: String) -> EmojiWithSkinTones {
+        let lookup: [String: EmojiWithSkinTones] = [
+            "👨🏻‍🏫": EmojiWithSkinTones(baseEmoji: .maleTeacher, skinTones: [.light]),
+            "👩🏻‍🏫": EmojiWithSkinTones(baseEmoji: .femaleTeacher, skinTones: [.light]),
+            "👨🏻‍🏭": EmojiWithSkinTones(baseEmoji: .maleFactoryWorker, skinTones: [.light]),
+            "👩🏻‍🏭": EmojiWithSkinTones(baseEmoji: .femaleFactoryWorker, skinTones: [.light]),
+            "👨🏻‍🎤": EmojiWithSkinTones(baseEmoji: .maleSinger, skinTones: [.light]),
+            "👩🏻‍🎤": EmojiWithSkinTones(baseEmoji: .femaleSinger, skinTones: [.light]),
+            "👨🏻‍🎨": EmojiWithSkinTones(baseEmoji: .maleArtist, skinTones: [.light]),
+            "👩🏻‍🎨": EmojiWithSkinTones(baseEmoji: .femaleArtist, skinTones: [.light]),
+            "👨🏼‍🏫": EmojiWithSkinTones(baseEmoji: .maleTeacher, skinTones: [.mediumLight]),
+            "👩🏼‍🏫": EmojiWithSkinTones(baseEmoji: .femaleTeacher, skinTones: [.mediumLight]),
+            "👨🏼‍🏭": EmojiWithSkinTones(baseEmoji: .maleFactoryWorker, skinTones: [.mediumLight]),
+            "👩🏼‍🏭": EmojiWithSkinTones(baseEmoji: .femaleFactoryWorker, skinTones: [.mediumLight]),
+            "👨🏼‍🎤": EmojiWithSkinTones(baseEmoji: .maleSinger, skinTones: [.mediumLight]),
+            "👩🏼‍🎤": EmojiWithSkinTones(baseEmoji: .femaleSinger, skinTones: [.mediumLight]),
+            "👨🏼‍🎨": EmojiWithSkinTones(baseEmoji: .maleArtist, skinTones: [.mediumLight]),
+            "👩🏼‍🎨": EmojiWithSkinTones(baseEmoji: .femaleArtist, skinTones: [.mediumLight]),
+            "👨🏽‍🏫": EmojiWithSkinTones(baseEmoji: .maleTeacher, skinTones: [.medium]),
+            "👩🏽‍🏫": EmojiWithSkinTones(baseEmoji: .femaleTeacher, skinTones: [.medium]),
+            "👨🏽‍🏭": EmojiWithSkinTones(baseEmoji: .maleFactoryWorker, skinTones: [.medium]),
+            "👩🏽‍🏭": EmojiWithSkinTones(baseEmoji: .femaleFactoryWorker, skinTones: [.medium]),
+            "👨🏽‍🎤": EmojiWithSkinTones(baseEmoji: .maleSinger, skinTones: [.medium]),
+            "👩🏽‍🎤": EmojiWithSkinTones(baseEmoji: .femaleSinger, skinTones: [.medium]),
+            "👨🏽‍🎨": EmojiWithSkinTones(baseEmoji: .maleArtist, skinTones: [.medium]),
+            "👩🏽‍🎨": EmojiWithSkinTones(baseEmoji: .femaleArtist, skinTones: [.medium]),
+            "👨🏾‍🏫": EmojiWithSkinTones(baseEmoji: .maleTeacher, skinTones: [.mediumDark]),
+            "👩🏾‍🏫": EmojiWithSkinTones(baseEmoji: .femaleTeacher, skinTones: [.mediumDark]),
+            "👨🏾‍🏭": EmojiWithSkinTones(baseEmoji: .maleFactoryWorker, skinTones: [.mediumDark]),
+            "👩🏾‍🏭": EmojiWithSkinTones(baseEmoji: .femaleFactoryWorker, skinTones: [.mediumDark]),
+            "👨🏾‍🎤": EmojiWithSkinTones(baseEmoji: .maleSinger, skinTones: [.mediumDark]),
+            "👩🏾‍🎤": EmojiWithSkinTones(baseEmoji: .femaleSinger, skinTones: [.mediumDark]),
+            "👨🏾‍🎨": EmojiWithSkinTones(baseEmoji: .maleArtist, skinTones: [.mediumDark]),
+            "👩🏾‍🎨": EmojiWithSkinTones(baseEmoji: .femaleArtist, skinTones: [.mediumDark]),
+            "👩🏿‍🎓": EmojiWithSkinTones(baseEmoji: .femaleStudent, skinTones: [.dark]),
+            "👨🏿‍🏫": EmojiWithSkinTones(baseEmoji: .maleTeacher, skinTones: [.dark]),
+            "👩🏿‍🏫": EmojiWithSkinTones(baseEmoji: .femaleTeacher, skinTones: [.dark]),
+            "👨🏿‍🏭": EmojiWithSkinTones(baseEmoji: .maleFactoryWorker, skinTones: [.dark]),
+            "👩🏿‍🏭": EmojiWithSkinTones(baseEmoji: .femaleFactoryWorker, skinTones: [.dark]),
+            "👨🏿‍🎤": EmojiWithSkinTones(baseEmoji: .maleSinger, skinTones: [.dark]),
+            "👩🏿‍🎤": EmojiWithSkinTones(baseEmoji: .femaleSinger, skinTones: [.dark]),
+            "👨🏿‍🎨": EmojiWithSkinTones(baseEmoji: .maleArtist, skinTones: [.dark]),
+            "👩🏿‍🎨": EmojiWithSkinTones(baseEmoji: .femaleArtist, skinTones: [.dark])
+        ]
+        return (lookup[rawValue] ?? EmojiWithSkinTones(unsupportedValue: rawValue))
+    }
+    
+    private static func emojiFrom3924(_ rawValue: String) -> EmojiWithSkinTones {
+        let lookup: [String: EmojiWithSkinTones] = [
+            "👨🏻‍💼": EmojiWithSkinTones(baseEmoji: .maleOfficeWorker, skinTones: [.light]),
+            "👩🏻‍💼": EmojiWithSkinTones(baseEmoji: .femaleOfficeWorker, skinTones: [.light]),
+            "👨🏻‍💻": EmojiWithSkinTones(baseEmoji: .maleTechnologist, skinTones: [.light]),
+            "👩🏻‍💻": EmojiWithSkinTones(baseEmoji: .femaleTechnologist, skinTones: [.light]),
+            "👨🏼‍💼": EmojiWithSkinTones(baseEmoji: .maleOfficeWorker, skinTones: [.mediumLight]),
+            "👩🏼‍💼": EmojiWithSkinTones(baseEmoji: .femaleOfficeWorker, skinTones: [.mediumLight]),
+            "👨🏼‍💻": EmojiWithSkinTones(baseEmoji: .maleTechnologist, skinTones: [.mediumLight]),
+            "👩🏼‍💻": EmojiWithSkinTones(baseEmoji: .femaleTechnologist, skinTones: [.mediumLight]),
+            "👨🏽‍💼": EmojiWithSkinTones(baseEmoji: .maleOfficeWorker, skinTones: [.medium]),
+            "👩🏽‍💼": EmojiWithSkinTones(baseEmoji: .femaleOfficeWorker, skinTones: [.medium]),
+            "👨🏽‍💻": EmojiWithSkinTones(baseEmoji: .maleTechnologist, skinTones: [.medium]),
+            "👩🏽‍💻": EmojiWithSkinTones(baseEmoji: .femaleTechnologist, skinTones: [.medium]),
+            "👨🏾‍💼": EmojiWithSkinTones(baseEmoji: .maleOfficeWorker, skinTones: [.mediumDark]),
+            "👩🏾‍💼": EmojiWithSkinTones(baseEmoji: .femaleOfficeWorker, skinTones: [.mediumDark]),
+            "👨🏾‍💻": EmojiWithSkinTones(baseEmoji: .maleTechnologist, skinTones: [.mediumDark]),
+            "👩🏾‍💻": EmojiWithSkinTones(baseEmoji: .femaleTechnologist, skinTones: [.mediumDark]),
+            "👨🏿‍💼": EmojiWithSkinTones(baseEmoji: .maleOfficeWorker, skinTones: [.dark]),
+            "👩🏿‍💼": EmojiWithSkinTones(baseEmoji: .femaleOfficeWorker, skinTones: [.dark]),
+            "👨🏿‍💻": EmojiWithSkinTones(baseEmoji: .maleTechnologist, skinTones: [.dark]),
+            "👩🏿‍💻": EmojiWithSkinTones(baseEmoji: .femaleTechnologist, skinTones: [.dark])
+        ]
+        return (lookup[rawValue] ?? EmojiWithSkinTones(unsupportedValue: rawValue))
+    }
+    
+    private static func emojiFrom3925(_ rawValue: String) -> EmojiWithSkinTones {
+        let lookup: [String: EmojiWithSkinTones] = [
+            "👨🏻‍🔧": EmojiWithSkinTones(baseEmoji: .maleMechanic, skinTones: [.light])
+        ]
+        return (lookup[rawValue] ?? EmojiWithSkinTones(unsupportedValue: rawValue))
+    }
+    
+    private static func emojiFrom3926(_ rawValue: String) -> EmojiWithSkinTones {
+        let lookup: [String: EmojiWithSkinTones] = [
+            "👩🏻‍🔧": EmojiWithSkinTones(baseEmoji: .femaleMechanic, skinTones: [.light]),
+            "👨🏻‍🔬": EmojiWithSkinTones(baseEmoji: .maleScientist, skinTones: [.light]),
+            "👩🏻‍🔬": EmojiWithSkinTones(baseEmoji: .femaleScientist, skinTones: [.light]),
+            "👨🏼‍🔧": EmojiWithSkinTones(baseEmoji: .maleMechanic, skinTones: [.mediumLight]),
+            "👩🏼‍🔧": EmojiWithSkinTones(baseEmoji: .femaleMechanic, skinTones: [.mediumLight]),
+            "👨🏼‍🔬": EmojiWithSkinTones(baseEmoji: .maleScientist, skinTones: [.mediumLight]),
+            "👩🏼‍🔬": EmojiWithSkinTones(baseEmoji: .femaleScientist, skinTones: [.mediumLight]),
+            "👨🏽‍🔧": EmojiWithSkinTones(baseEmoji: .maleMechanic, skinTones: [.medium]),
+            "👩🏽‍🔧": EmojiWithSkinTones(baseEmoji: .femaleMechanic, skinTones: [.medium]),
+            "👨🏽‍🔬": EmojiWithSkinTones(baseEmoji: .maleScientist, skinTones: [.medium]),
+            "👩🏽‍🔬": EmojiWithSkinTones(baseEmoji: .femaleScientist, skinTones: [.medium]),
+            "👨🏾‍🔧": EmojiWithSkinTones(baseEmoji: .maleMechanic, skinTones: [.mediumDark]),
+            "👩🏾‍🔧": EmojiWithSkinTones(baseEmoji: .femaleMechanic, skinTones: [.mediumDark]),
+            "👨🏾‍🔬": EmojiWithSkinTones(baseEmoji: .maleScientist, skinTones: [.mediumDark]),
+            "👩🏾‍🔬": EmojiWithSkinTones(baseEmoji: .femaleScientist, skinTones: [.mediumDark]),
+            "👨🏿‍🔧": EmojiWithSkinTones(baseEmoji: .maleMechanic, skinTones: [.dark]),
+            "👩🏿‍🔧": EmojiWithSkinTones(baseEmoji: .femaleMechanic, skinTones: [.dark]),
+            "👨🏿‍🔬": EmojiWithSkinTones(baseEmoji: .maleScientist, skinTones: [.dark]),
+            "👩🏿‍🔬": EmojiWithSkinTones(baseEmoji: .femaleScientist, skinTones: [.dark])
+        ]
+        return (lookup[rawValue] ?? EmojiWithSkinTones(unsupportedValue: rawValue))
+    }
+    
+    private static func emojiFrom3929(_ rawValue: String) -> EmojiWithSkinTones {
+        let lookup: [String: EmojiWithSkinTones] = [
+            "👨🏻‍🚀": EmojiWithSkinTones(baseEmoji: .maleAstronaut, skinTones: [.light]),
+            "👩🏻‍🚀": EmojiWithSkinTones(baseEmoji: .femaleAstronaut, skinTones: [.light]),
+            "👨🏻‍🚒": EmojiWithSkinTones(baseEmoji: .maleFirefighter, skinTones: [.light]),
+            "👩🏻‍🚒": EmojiWithSkinTones(baseEmoji: .femaleFirefighter, skinTones: [.light]),
+            "👨🏼‍🚀": EmojiWithSkinTones(baseEmoji: .maleAstronaut, skinTones: [.mediumLight]),
+            "👩🏼‍🚀": EmojiWithSkinTones(baseEmoji: .femaleAstronaut, skinTones: [.mediumLight]),
+            "👨🏼‍🚒": EmojiWithSkinTones(baseEmoji: .maleFirefighter, skinTones: [.mediumLight]),
+            "👩🏼‍🚒": EmojiWithSkinTones(baseEmoji: .femaleFirefighter, skinTones: [.mediumLight]),
+            "👨🏽‍🚀": EmojiWithSkinTones(baseEmoji: .maleAstronaut, skinTones: [.medium]),
+            "👩🏽‍🚀": EmojiWithSkinTones(baseEmoji: .femaleAstronaut, skinTones: [.medium]),
+            "👨🏽‍🚒": EmojiWithSkinTones(baseEmoji: .maleFirefighter, skinTones: [.medium]),
+            "👩🏽‍🚒": EmojiWithSkinTones(baseEmoji: .femaleFirefighter, skinTones: [.medium]),
+            "👨🏾‍🚀": EmojiWithSkinTones(baseEmoji: .maleAstronaut, skinTones: [.mediumDark]),
+            "👩🏾‍🚀": EmojiWithSkinTones(baseEmoji: .femaleAstronaut, skinTones: [.mediumDark]),
+            "👨🏾‍🚒": EmojiWithSkinTones(baseEmoji: .maleFirefighter, skinTones: [.mediumDark]),
+            "👩🏾‍🚒": EmojiWithSkinTones(baseEmoji: .femaleFirefighter, skinTones: [.mediumDark]),
+            "👨🏿‍🚀": EmojiWithSkinTones(baseEmoji: .maleAstronaut, skinTones: [.dark]),
+            "👩🏿‍🚀": EmojiWithSkinTones(baseEmoji: .femaleAstronaut, skinTones: [.dark]),
+            "👨🏿‍🚒": EmojiWithSkinTones(baseEmoji: .maleFirefighter, skinTones: [.dark]),
+            "👩🏿‍🚒": EmojiWithSkinTones(baseEmoji: .femaleFirefighter, skinTones: [.dark])
+        ]
+        return (lookup[rawValue] ?? EmojiWithSkinTones(unsupportedValue: rawValue))
+    }
+    
+    private static func emojiFrom3934(_ rawValue: String) -> EmojiWithSkinTones {
+        let lookup: [String: EmojiWithSkinTones] = [
+            "🧑🏻‍🌾": EmojiWithSkinTones(baseEmoji: .farmer, skinTones: [.light]),
+            "🧑🏼‍🌾": EmojiWithSkinTones(baseEmoji: .farmer, skinTones: [.mediumLight]),
+            "🧑🏽‍🌾": EmojiWithSkinTones(baseEmoji: .farmer, skinTones: [.medium]),
+            "🧑🏾‍🌾": EmojiWithSkinTones(baseEmoji: .farmer, skinTones: [.mediumDark]),
+            "🧑🏿‍🌾": EmojiWithSkinTones(baseEmoji: .farmer, skinTones: [.dark])
+        ]
+        return (lookup[rawValue] ?? EmojiWithSkinTones(unsupportedValue: rawValue))
+    }
+    
+    private static func emojiFrom3935(_ rawValue: String) -> EmojiWithSkinTones {
+        let lookup: [String: EmojiWithSkinTones] = [
+            "🧑🏻‍🎓": EmojiWithSkinTones(baseEmoji: .student, skinTones: [.light]),
+            "🧑🏻‍🍳": EmojiWithSkinTones(baseEmoji: .cook, skinTones: [.light]),
+            "🧑🏻‍🎤": EmojiWithSkinTones(baseEmoji: .singer, skinTones: [.light]),
+            "🧑🏻‍🍼": EmojiWithSkinTones(baseEmoji: .personFeedingBaby, skinTones: [.light]),
+            "🧑🏻‍🎄": EmojiWithSkinTones(baseEmoji: .mxClaus, skinTones: [.light]),
+            "🧑🏼‍🎓": EmojiWithSkinTones(baseEmoji: .student, skinTones: [.mediumLight]),
+            "🧑🏼‍🍳": EmojiWithSkinTones(baseEmoji: .cook, skinTones: [.mediumLight]),
+            "🧑🏼‍🎤": EmojiWithSkinTones(baseEmoji: .singer, skinTones: [.mediumLight]),
+            "🧑🏼‍🍼": EmojiWithSkinTones(baseEmoji: .personFeedingBaby, skinTones: [.mediumLight]),
+            "🧑🏼‍🎄": EmojiWithSkinTones(baseEmoji: .mxClaus, skinTones: [.mediumLight]),
+            "🧑🏽‍🎓": EmojiWithSkinTones(baseEmoji: .student, skinTones: [.medium]),
+            "🧑🏽‍🍳": EmojiWithSkinTones(baseEmoji: .cook, skinTones: [.medium]),
+            "🧑🏽‍🎤": EmojiWithSkinTones(baseEmoji: .singer, skinTones: [.medium]),
+            "🧑🏽‍🍼": EmojiWithSkinTones(baseEmoji: .personFeedingBaby, skinTones: [.medium]),
+            "🧑🏽‍🎄": EmojiWithSkinTones(baseEmoji: .mxClaus, skinTones: [.medium]),
+            "🧑🏾‍🎓": EmojiWithSkinTones(baseEmoji: .student, skinTones: [.mediumDark]),
+            "🧑🏾‍🍳": EmojiWithSkinTones(baseEmoji: .cook, skinTones: [.mediumDark]),
+            "🧑🏾‍🍼": EmojiWithSkinTones(baseEmoji: .personFeedingBaby, skinTones: [.mediumDark]),
+            "🧑🏾‍🎄": EmojiWithSkinTones(baseEmoji: .mxClaus, skinTones: [.mediumDark]),
+            "🧑🏿‍🎓": EmojiWithSkinTones(baseEmoji: .student, skinTones: [.dark]),
+            "🧑🏿‍🍳": EmojiWithSkinTones(baseEmoji: .cook, skinTones: [.dark]),
+            "🧑🏿‍🍼": EmojiWithSkinTones(baseEmoji: .personFeedingBaby, skinTones: [.dark]),
+            "🧑🏿‍🎄": EmojiWithSkinTones(baseEmoji: .mxClaus, skinTones: [.dark])
+        ]
+        return (lookup[rawValue] ?? EmojiWithSkinTones(unsupportedValue: rawValue))
+    }
+    
+    private static func emojiFrom3936(_ rawValue: String) -> EmojiWithSkinTones {
+        let lookup: [String: EmojiWithSkinTones] = [
+            "🧑🏻‍🏫": EmojiWithSkinTones(baseEmoji: .teacher, skinTones: [.light]),
+            "🧑🏻‍🏭": EmojiWithSkinTones(baseEmoji: .factoryWorker, skinTones: [.light]),
+            "🧑🏻‍🎨": EmojiWithSkinTones(baseEmoji: .artist, skinTones: [.light]),
+            "🧑🏼‍🏫": EmojiWithSkinTones(baseEmoji: .teacher, skinTones: [.mediumLight]),
+            "🧑🏼‍🏭": EmojiWithSkinTones(baseEmoji: .factoryWorker, skinTones: [.mediumLight]),
+            "🧑🏼‍🎨": EmojiWithSkinTones(baseEmoji: .artist, skinTones: [.mediumLight]),
+            "🧑🏽‍🏫": EmojiWithSkinTones(baseEmoji: .teacher, skinTones: [.medium]),
+            "🧑🏽‍🏭": EmojiWithSkinTones(baseEmoji: .factoryWorker, skinTones: [.medium]),
+            "🧑🏽‍🎨": EmojiWithSkinTones(baseEmoji: .artist, skinTones: [.medium]),
+            "🧑🏾‍🏫": EmojiWithSkinTones(baseEmoji: .teacher, skinTones: [.mediumDark]),
+            "🧑🏾‍🏭": EmojiWithSkinTones(baseEmoji: .factoryWorker, skinTones: [.mediumDark]),
+            "🧑🏾‍🎤": EmojiWithSkinTones(baseEmoji: .singer, skinTones: [.mediumDark]),
+            "🧑🏾‍🎨": EmojiWithSkinTones(baseEmoji: .artist, skinTones: [.mediumDark]),
+            "🧑🏿‍🏫": EmojiWithSkinTones(baseEmoji: .teacher, skinTones: [.dark]),
+            "🧑🏿‍🏭": EmojiWithSkinTones(baseEmoji: .factoryWorker, skinTones: [.dark]),
+            "🧑🏿‍🎤": EmojiWithSkinTones(baseEmoji: .singer, skinTones: [.dark]),
+            "🧑🏿‍🎨": EmojiWithSkinTones(baseEmoji: .artist, skinTones: [.dark])
+        ]
+        return (lookup[rawValue] ?? EmojiWithSkinTones(unsupportedValue: rawValue))
+    }
+    
+    private static func emojiFrom3937(_ rawValue: String) -> EmojiWithSkinTones {
+        let lookup: [String: EmojiWithSkinTones] = [
+            "👨🏻‍🦰": EmojiWithSkinTones(baseEmoji: .redHairedMan, skinTones: [.light]),
+            "👨🏻‍🦱": EmojiWithSkinTones(baseEmoji: .curlyHairedMan, skinTones: [.light]),
+            "👨🏻‍🦳": EmojiWithSkinTones(baseEmoji: .whiteHairedMan, skinTones: [.light]),
+            "👨🏻‍🦲": EmojiWithSkinTones(baseEmoji: .baldMan, skinTones: [.light]),
+            "👩🏻‍🦰": EmojiWithSkinTones(baseEmoji: .redHairedWoman, skinTones: [.light]),
+            "👩🏻‍🦱": EmojiWithSkinTones(baseEmoji: .curlyHairedWoman, skinTones: [.light]),
+            "👩🏻‍🦳": EmojiWithSkinTones(baseEmoji: .whiteHairedWoman, skinTones: [.light]),
+            "👩🏻‍🦲": EmojiWithSkinTones(baseEmoji: .baldWoman, skinTones: [.light]),
+            "👨🏻‍🦯": EmojiWithSkinTones(baseEmoji: .manWithProbingCane, skinTones: [.light]),
+            "👩🏻‍🦯": EmojiWithSkinTones(baseEmoji: .womanWithProbingCane, skinTones: [.light]),
+            "👨🏻‍🦼": EmojiWithSkinTones(baseEmoji: .manInMotorizedWheelchair, skinTones: [.light]),
+            "👩🏻‍🦼": EmojiWithSkinTones(baseEmoji: .womanInMotorizedWheelchair, skinTones: [.light]),
+            "👨🏻‍🦽": EmojiWithSkinTones(baseEmoji: .manInManualWheelchair, skinTones: [.light]),
+            "👩🏻‍🦽": EmojiWithSkinTones(baseEmoji: .womanInManualWheelchair, skinTones: [.light]),
+            "👨🏼‍🦰": EmojiWithSkinTones(baseEmoji: .redHairedMan, skinTones: [.mediumLight]),
+            "👨🏼‍🦱": EmojiWithSkinTones(baseEmoji: .curlyHairedMan, skinTones: [.mediumLight]),
+            "👨🏼‍🦳": EmojiWithSkinTones(baseEmoji: .whiteHairedMan, skinTones: [.mediumLight]),
+            "👨🏼‍🦲": EmojiWithSkinTones(baseEmoji: .baldMan, skinTones: [.mediumLight]),
+            "👩🏼‍🦰": EmojiWithSkinTones(baseEmoji: .redHairedWoman, skinTones: [.mediumLight]),
+            "👩🏼‍🦱": EmojiWithSkinTones(baseEmoji: .curlyHairedWoman, skinTones: [.mediumLight]),
+            "👩🏼‍🦳": EmojiWithSkinTones(baseEmoji: .whiteHairedWoman, skinTones: [.mediumLight]),
+            "👩🏼‍🦲": EmojiWithSkinTones(baseEmoji: .baldWoman, skinTones: [.mediumLight]),
+            "👨🏼‍🦯": EmojiWithSkinTones(baseEmoji: .manWithProbingCane, skinTones: [.mediumLight]),
+            "👩🏼‍🦯": EmojiWithSkinTones(baseEmoji: .womanWithProbingCane, skinTones: [.mediumLight]),
+            "👨🏼‍🦼": EmojiWithSkinTones(baseEmoji: .manInMotorizedWheelchair, skinTones: [.mediumLight]),
+            "👩🏼‍🦼": EmojiWithSkinTones(baseEmoji: .womanInMotorizedWheelchair, skinTones: [.mediumLight]),
+            "👨🏼‍🦽": EmojiWithSkinTones(baseEmoji: .manInManualWheelchair, skinTones: [.mediumLight]),
+            "👩🏼‍🦽": EmojiWithSkinTones(baseEmoji: .womanInManualWheelchair, skinTones: [.mediumLight]),
+            "👨🏽‍🦰": EmojiWithSkinTones(baseEmoji: .redHairedMan, skinTones: [.medium]),
+            "👨🏽‍🦱": EmojiWithSkinTones(baseEmoji: .curlyHairedMan, skinTones: [.medium]),
+            "👨🏽‍🦳": EmojiWithSkinTones(baseEmoji: .whiteHairedMan, skinTones: [.medium]),
+            "👨🏽‍🦲": EmojiWithSkinTones(baseEmoji: .baldMan, skinTones: [.medium]),
+            "👩🏽‍🦰": EmojiWithSkinTones(baseEmoji: .redHairedWoman, skinTones: [.medium]),
+            "👩🏽‍🦱": EmojiWithSkinTones(baseEmoji: .curlyHairedWoman, skinTones: [.medium]),
+            "👩🏽‍🦳": EmojiWithSkinTones(baseEmoji: .whiteHairedWoman, skinTones: [.medium]),
+            "👩🏽‍🦲": EmojiWithSkinTones(baseEmoji: .baldWoman, skinTones: [.medium]),
+            "👨🏽‍🦯": EmojiWithSkinTones(baseEmoji: .manWithProbingCane, skinTones: [.medium]),
+            "👩🏽‍🦯": EmojiWithSkinTones(baseEmoji: .womanWithProbingCane, skinTones: [.medium]),
+            "👨🏽‍🦼": EmojiWithSkinTones(baseEmoji: .manInMotorizedWheelchair, skinTones: [.medium]),
+            "👩🏽‍🦼": EmojiWithSkinTones(baseEmoji: .womanInMotorizedWheelchair, skinTones: [.medium]),
+            "👨🏽‍🦽": EmojiWithSkinTones(baseEmoji: .manInManualWheelchair, skinTones: [.medium]),
+            "👩🏽‍🦽": EmojiWithSkinTones(baseEmoji: .womanInManualWheelchair, skinTones: [.medium]),
+            "👨🏾‍🦰": EmojiWithSkinTones(baseEmoji: .redHairedMan, skinTones: [.mediumDark]),
+            "👨🏾‍🦱": EmojiWithSkinTones(baseEmoji: .curlyHairedMan, skinTones: [.mediumDark]),
+            "👨🏾‍🦳": EmojiWithSkinTones(baseEmoji: .whiteHairedMan, skinTones: [.mediumDark]),
+            "👨🏾‍🦲": EmojiWithSkinTones(baseEmoji: .baldMan, skinTones: [.mediumDark]),
+            "👩🏾‍🦰": EmojiWithSkinTones(baseEmoji: .redHairedWoman, skinTones: [.mediumDark]),
+            "👩🏾‍🦱": EmojiWithSkinTones(baseEmoji: .curlyHairedWoman, skinTones: [.mediumDark]),
+            "👩🏾‍🦳": EmojiWithSkinTones(baseEmoji: .whiteHairedWoman, skinTones: [.mediumDark]),
+            "👩🏾‍🦲": EmojiWithSkinTones(baseEmoji: .baldWoman, skinTones: [.mediumDark]),
+            "👨🏾‍🦯": EmojiWithSkinTones(baseEmoji: .manWithProbingCane, skinTones: [.mediumDark]),
+            "👩🏾‍🦯": EmojiWithSkinTones(baseEmoji: .womanWithProbingCane, skinTones: [.mediumDark]),
+            "👨🏾‍🦼": EmojiWithSkinTones(baseEmoji: .manInMotorizedWheelchair, skinTones: [.mediumDark]),
+            "👩🏾‍🦼": EmojiWithSkinTones(baseEmoji: .womanInMotorizedWheelchair, skinTones: [.mediumDark]),
+            "👨🏾‍🦽": EmojiWithSkinTones(baseEmoji: .manInManualWheelchair, skinTones: [.mediumDark]),
+            "👩🏾‍🦽": EmojiWithSkinTones(baseEmoji: .womanInManualWheelchair, skinTones: [.mediumDark]),
+            "👨🏿‍🦰": EmojiWithSkinTones(baseEmoji: .redHairedMan, skinTones: [.dark]),
+            "👨🏿‍🦱": EmojiWithSkinTones(baseEmoji: .curlyHairedMan, skinTones: [.dark]),
+            "👨🏿‍🦳": EmojiWithSkinTones(baseEmoji: .whiteHairedMan, skinTones: [.dark]),
+            "👨🏿‍🦲": EmojiWithSkinTones(baseEmoji: .baldMan, skinTones: [.dark]),
+            "👩🏿‍🦰": EmojiWithSkinTones(baseEmoji: .redHairedWoman, skinTones: [.dark]),
+            "👩🏿‍🦱": EmojiWithSkinTones(baseEmoji: .curlyHairedWoman, skinTones: [.dark]),
+            "👩🏿‍🦳": EmojiWithSkinTones(baseEmoji: .whiteHairedWoman, skinTones: [.dark]),
+            "👩🏿‍🦲": EmojiWithSkinTones(baseEmoji: .baldWoman, skinTones: [.dark]),
+            "👨🏿‍🦯": EmojiWithSkinTones(baseEmoji: .manWithProbingCane, skinTones: [.dark]),
+            "👩🏿‍🦯": EmojiWithSkinTones(baseEmoji: .womanWithProbingCane, skinTones: [.dark]),
+            "👨🏿‍🦼": EmojiWithSkinTones(baseEmoji: .manInMotorizedWheelchair, skinTones: [.dark]),
+            "👩🏿‍🦼": EmojiWithSkinTones(baseEmoji: .womanInMotorizedWheelchair, skinTones: [.dark]),
+            "👨🏿‍🦽": EmojiWithSkinTones(baseEmoji: .manInManualWheelchair, skinTones: [.dark]),
+            "👩🏿‍🦽": EmojiWithSkinTones(baseEmoji: .womanInManualWheelchair, skinTones: [.dark])
+        ]
+        return (lookup[rawValue] ?? EmojiWithSkinTones(unsupportedValue: rawValue))
+    }
+    
+    private static func emojiFrom3938(_ rawValue: String) -> EmojiWithSkinTones {
+        let lookup: [String: EmojiWithSkinTones] = [
+            "🧑🏻‍💼": EmojiWithSkinTones(baseEmoji: .officeWorker, skinTones: [.light]),
+            "🧑🏻‍💻": EmojiWithSkinTones(baseEmoji: .technologist, skinTones: [.light]),
+            "🧑🏼‍💼": EmojiWithSkinTones(baseEmoji: .officeWorker, skinTones: [.mediumLight]),
+            "🧑🏼‍💻": EmojiWithSkinTones(baseEmoji: .technologist, skinTones: [.mediumLight]),
+            "🧑🏽‍💼": EmojiWithSkinTones(baseEmoji: .officeWorker, skinTones: [.medium]),
+            "🧑🏽‍💻": EmojiWithSkinTones(baseEmoji: .technologist, skinTones: [.medium]),
+            "🧑🏾‍💼": EmojiWithSkinTones(baseEmoji: .officeWorker, skinTones: [.mediumDark]),
+            "🧑🏾‍💻": EmojiWithSkinTones(baseEmoji: .technologist, skinTones: [.mediumDark]),
+            "🧑🏿‍💼": EmojiWithSkinTones(baseEmoji: .officeWorker, skinTones: [.dark]),
+            "🧑🏿‍💻": EmojiWithSkinTones(baseEmoji: .technologist, skinTones: [.dark])
+        ]
+        return (lookup[rawValue] ?? EmojiWithSkinTones(unsupportedValue: rawValue))
+    }
+    
+    private static func emojiFrom3939(_ rawValue: String) -> EmojiWithSkinTones {
+        let lookup: [String: EmojiWithSkinTones] = [
+            "🧑🏻‍🔧": EmojiWithSkinTones(baseEmoji: .mechanic, skinTones: [.light]),
+            "🧑🏻‍🔬": EmojiWithSkinTones(baseEmoji: .scientist, skinTones: [.light]),
+            "🧑🏼‍🔧": EmojiWithSkinTones(baseEmoji: .mechanic, skinTones: [.mediumLight]),
+            "🧑🏼‍🔬": EmojiWithSkinTones(baseEmoji: .scientist, skinTones: [.mediumLight]),
+            "🧑🏽‍🔧": EmojiWithSkinTones(baseEmoji: .mechanic, skinTones: [.medium]),
+            "🧑🏽‍🔬": EmojiWithSkinTones(baseEmoji: .scientist, skinTones: [.medium]),
+            "🧑🏾‍🔧": EmojiWithSkinTones(baseEmoji: .mechanic, skinTones: [.mediumDark]),
+            "🧑🏾‍🔬": EmojiWithSkinTones(baseEmoji: .scientist, skinTones: [.mediumDark]),
+            "🧑🏿‍🔧": EmojiWithSkinTones(baseEmoji: .mechanic, skinTones: [.dark]),
+            "🧑🏿‍🔬": EmojiWithSkinTones(baseEmoji: .scientist, skinTones: [.dark])
+        ]
+        return (lookup[rawValue] ?? EmojiWithSkinTones(unsupportedValue: rawValue))
+    }
+    
+    private static func emojiFrom3943(_ rawValue: String) -> EmojiWithSkinTones {
+        let lookup: [String: EmojiWithSkinTones] = [
+            "🧑🏻‍🚀": EmojiWithSkinTones(baseEmoji: .astronaut, skinTones: [.light]),
+            "🧑🏻‍🚒": EmojiWithSkinTones(baseEmoji: .firefighter, skinTones: [.light]),
+            "🧑🏼‍🚀": EmojiWithSkinTones(baseEmoji: .astronaut, skinTones: [.mediumLight]),
+            "🧑🏼‍🚒": EmojiWithSkinTones(baseEmoji: .firefighter, skinTones: [.mediumLight]),
+            "🧑🏽‍🚀": EmojiWithSkinTones(baseEmoji: .astronaut, skinTones: [.medium]),
+            "🧑🏽‍🚒": EmojiWithSkinTones(baseEmoji: .firefighter, skinTones: [.medium]),
+            "🧑🏾‍🚀": EmojiWithSkinTones(baseEmoji: .astronaut, skinTones: [.mediumDark]),
+            "🧑🏾‍🚒": EmojiWithSkinTones(baseEmoji: .firefighter, skinTones: [.mediumDark]),
+            "🧑🏿‍🚀": EmojiWithSkinTones(baseEmoji: .astronaut, skinTones: [.dark]),
+            "🧑🏿‍🚒": EmojiWithSkinTones(baseEmoji: .firefighter, skinTones: [.dark])
+        ]
+        return (lookup[rawValue] ?? EmojiWithSkinTones(unsupportedValue: rawValue))
+    }
+    
+    private static func emojiFrom3948(_ rawValue: String) -> EmojiWithSkinTones {
+        let lookup: [String: EmojiWithSkinTones] = [
+            "👁️‍🗨️": EmojiWithSkinTones(baseEmoji: .eyeInSpeechBubble, skinTones: nil)
+        ]
+        return (lookup[rawValue] ?? EmojiWithSkinTones(unsupportedValue: rawValue))
+    }
+    
+    private static func emojiFrom3951(_ rawValue: String) -> EmojiWithSkinTones {
+        let lookup: [String: EmojiWithSkinTones] = [
+            "🧑🏻‍🦰": EmojiWithSkinTones(baseEmoji: .redHairedPerson, skinTones: [.light]),
+            "🧑🏻‍🦱": EmojiWithSkinTones(baseEmoji: .curlyHairedPerson, skinTones: [.light]),
+            "🧑🏻‍🦳": EmojiWithSkinTones(baseEmoji: .whiteHairedPerson, skinTones: [.light]),
+            "🧑🏻‍🦲": EmojiWithSkinTones(baseEmoji: .baldPerson, skinTones: [.light]),
+            "🧑🏻‍🦯": EmojiWithSkinTones(baseEmoji: .personWithProbingCane, skinTones: [.light]),
+            "🧑🏻‍🦼": EmojiWithSkinTones(baseEmoji: .personInMotorizedWheelchair, skinTones: [.light]),
+            "🧑🏻‍🦽": EmojiWithSkinTones(baseEmoji: .personInManualWheelchair, skinTones: [.light]),
+            "🧑🏼‍🦰": EmojiWithSkinTones(baseEmoji: .redHairedPerson, skinTones: [.mediumLight]),
+            "🧑🏼‍🦱": EmojiWithSkinTones(baseEmoji: .curlyHairedPerson, skinTones: [.mediumLight]),
+            "🧑🏼‍🦳": EmojiWithSkinTones(baseEmoji: .whiteHairedPerson, skinTones: [.mediumLight]),
+            "🧑🏼‍🦲": EmojiWithSkinTones(baseEmoji: .baldPerson, skinTones: [.mediumLight]),
+            "🧑🏼‍🦯": EmojiWithSkinTones(baseEmoji: .personWithProbingCane, skinTones: [.mediumLight]),
+            "🧑🏼‍🦼": EmojiWithSkinTones(baseEmoji: .personInMotorizedWheelchair, skinTones: [.mediumLight]),
+            "🧑🏼‍🦽": EmojiWithSkinTones(baseEmoji: .personInManualWheelchair, skinTones: [.mediumLight]),
+            "🧑🏽‍🦰": EmojiWithSkinTones(baseEmoji: .redHairedPerson, skinTones: [.medium]),
+            "🧑🏽‍🦱": EmojiWithSkinTones(baseEmoji: .curlyHairedPerson, skinTones: [.medium]),
+            "🧑🏽‍🦳": EmojiWithSkinTones(baseEmoji: .whiteHairedPerson, skinTones: [.medium]),
+            "🧑🏽‍🦲": EmojiWithSkinTones(baseEmoji: .baldPerson, skinTones: [.medium]),
+            "🧑🏽‍🦯": EmojiWithSkinTones(baseEmoji: .personWithProbingCane, skinTones: [.medium]),
+            "🧑🏽‍🦼": EmojiWithSkinTones(baseEmoji: .personInMotorizedWheelchair, skinTones: [.medium]),
+            "🧑🏽‍🦽": EmojiWithSkinTones(baseEmoji: .personInManualWheelchair, skinTones: [.medium]),
+            "🧑🏾‍🦰": EmojiWithSkinTones(baseEmoji: .redHairedPerson, skinTones: [.mediumDark]),
+            "🧑🏾‍🦱": EmojiWithSkinTones(baseEmoji: .curlyHairedPerson, skinTones: [.mediumDark]),
+            "🧑🏾‍🦳": EmojiWithSkinTones(baseEmoji: .whiteHairedPerson, skinTones: [.mediumDark]),
+            "🧑🏾‍🦲": EmojiWithSkinTones(baseEmoji: .baldPerson, skinTones: [.mediumDark]),
+            "🧑🏾‍🦯": EmojiWithSkinTones(baseEmoji: .personWithProbingCane, skinTones: [.mediumDark]),
+            "🧑🏾‍🦼": EmojiWithSkinTones(baseEmoji: .personInMotorizedWheelchair, skinTones: [.mediumDark]),
+            "🧑🏾‍🦽": EmojiWithSkinTones(baseEmoji: .personInManualWheelchair, skinTones: [.mediumDark]),
+            "🧑🏿‍🦰": EmojiWithSkinTones(baseEmoji: .redHairedPerson, skinTones: [.dark]),
+            "🧑🏿‍🦱": EmojiWithSkinTones(baseEmoji: .curlyHairedPerson, skinTones: [.dark]),
+            "🧑🏿‍🦳": EmojiWithSkinTones(baseEmoji: .whiteHairedPerson, skinTones: [.dark]),
+            "🧑🏿‍🦲": EmojiWithSkinTones(baseEmoji: .baldPerson, skinTones: [.dark]),
+            "🧑🏿‍🦯": EmojiWithSkinTones(baseEmoji: .personWithProbingCane, skinTones: [.dark]),
+            "🧑🏿‍🦼": EmojiWithSkinTones(baseEmoji: .personInMotorizedWheelchair, skinTones: [.dark]),
+            "🧑🏿‍🦽": EmojiWithSkinTones(baseEmoji: .personInManualWheelchair, skinTones: [.dark])
+        ]
+        return (lookup[rawValue] ?? EmojiWithSkinTones(unsupportedValue: rawValue))
+    }
+    
+    private static func emojiFrom4007(_ rawValue: String) -> EmojiWithSkinTones {
+        let lookup: [String: EmojiWithSkinTones] = [
+            "👨‍👩‍👦": EmojiWithSkinTones(baseEmoji: .manWomanBoy, skinTones: nil),
+            "👨‍👩‍👧": EmojiWithSkinTones(baseEmoji: .manWomanGirl, skinTones: nil),
+            "👨‍👨‍👦": EmojiWithSkinTones(baseEmoji: .manManBoy, skinTones: nil),
+            "👨‍👨‍👧": EmojiWithSkinTones(baseEmoji: .manManGirl, skinTones: nil),
+            "👩‍👩‍👦": EmojiWithSkinTones(baseEmoji: .womanWomanBoy, skinTones: nil),
+            "👩‍👩‍👧": EmojiWithSkinTones(baseEmoji: .womanWomanGirl, skinTones: nil),
+            "👨‍👦‍👦": EmojiWithSkinTones(baseEmoji: .manBoyBoy, skinTones: nil),
+            "👨‍👧‍👦": EmojiWithSkinTones(baseEmoji: .manGirlBoy, skinTones: nil),
+            "👨‍👧‍👧": EmojiWithSkinTones(baseEmoji: .manGirlGirl, skinTones: nil),
+            "👩‍👦‍👦": EmojiWithSkinTones(baseEmoji: .womanBoyBoy, skinTones: nil),
+            "👩‍👧‍👦": EmojiWithSkinTones(baseEmoji: .womanGirlBoy, skinTones: nil),
+            "👩‍👧‍👧": EmojiWithSkinTones(baseEmoji: .womanGirlGirl, skinTones: nil)
+        ]
+        return (lookup[rawValue] ?? EmojiWithSkinTones(unsupportedValue: rawValue))
+    }
+    
+    private static func emojiFrom4046(_ rawValue: String) -> EmojiWithSkinTones {
+        let lookup: [String: EmojiWithSkinTones] = [
+            "🧑‍🤝‍🧑": EmojiWithSkinTones(baseEmoji: .peopleHoldingHands, skinTones: nil)
+        ]
+        return (lookup[rawValue] ?? EmojiWithSkinTones(unsupportedValue: rawValue))
+    }
+    
+    private static func emojiFrom4840(_ rawValue: String) -> EmojiWithSkinTones {
+        let lookup: [String: EmojiWithSkinTones] = [
+            "👩‍❤️‍💋‍👨": EmojiWithSkinTones(baseEmoji: .womanKissMan, skinTones: nil),
+            "👨‍❤️‍💋‍👨": EmojiWithSkinTones(baseEmoji: .manKissMan, skinTones: nil),
+            "👩‍❤️‍💋‍👩": EmojiWithSkinTones(baseEmoji: .womanKissWoman, skinTones: nil)
+        ]
+        return (lookup[rawValue] ?? EmojiWithSkinTones(unsupportedValue: rawValue))
+    }
+    
+    private static func emojiFrom5237(_ rawValue: String) -> EmojiWithSkinTones {
+        let lookup: [String: EmojiWithSkinTones] = [
+            "🫱🏻‍🫲🏼": EmojiWithSkinTones(baseEmoji: .handshake, skinTones: [.light, .mediumLight]),
+            "🫱🏻‍🫲🏽": EmojiWithSkinTones(baseEmoji: .handshake, skinTones: [.light, .medium]),
+            "🫱🏻‍🫲🏾": EmojiWithSkinTones(baseEmoji: .handshake, skinTones: [.light, .mediumDark]),
+            "🫱🏻‍🫲🏿": EmojiWithSkinTones(baseEmoji: .handshake, skinTones: [.light, .dark]),
+            "🫱🏼‍🫲🏻": EmojiWithSkinTones(baseEmoji: .handshake, skinTones: [.mediumLight, .light]),
+            "🫱🏼‍🫲🏽": EmojiWithSkinTones(baseEmoji: .handshake, skinTones: [.mediumLight, .medium]),
+            "🫱🏼‍🫲🏾": EmojiWithSkinTones(baseEmoji: .handshake, skinTones: [.mediumLight, .mediumDark]),
+            "🫱🏼‍🫲🏿": EmojiWithSkinTones(baseEmoji: .handshake, skinTones: [.mediumLight, .dark]),
+            "🫱🏽‍🫲🏻": EmojiWithSkinTones(baseEmoji: .handshake, skinTones: [.medium, .light]),
+            "🫱🏽‍🫲🏼": EmojiWithSkinTones(baseEmoji: .handshake, skinTones: [.medium, .mediumLight]),
+            "🫱🏽‍🫲🏾": EmojiWithSkinTones(baseEmoji: .handshake, skinTones: [.medium, .mediumDark]),
+            "🫱🏽‍🫲🏿": EmojiWithSkinTones(baseEmoji: .handshake, skinTones: [.medium, .dark]),
+            "🫱🏾‍🫲🏻": EmojiWithSkinTones(baseEmoji: .handshake, skinTones: [.mediumDark, .light]),
+            "🫱🏾‍🫲🏼": EmojiWithSkinTones(baseEmoji: .handshake, skinTones: [.mediumDark, .mediumLight]),
+            "🫱🏾‍🫲🏽": EmojiWithSkinTones(baseEmoji: .handshake, skinTones: [.mediumDark, .medium]),
+            "🫱🏾‍🫲🏿": EmojiWithSkinTones(baseEmoji: .handshake, skinTones: [.mediumDark, .dark]),
+            "🫱🏿‍🫲🏻": EmojiWithSkinTones(baseEmoji: .handshake, skinTones: [.dark, .light]),
+            "🫱🏿‍🫲🏼": EmojiWithSkinTones(baseEmoji: .handshake, skinTones: [.dark, .mediumLight]),
+            "🫱🏿‍🫲🏽": EmojiWithSkinTones(baseEmoji: .handshake, skinTones: [.dark, .medium]),
+            "🫱🏿‍🫲🏾": EmojiWithSkinTones(baseEmoji: .handshake, skinTones: [.dark, .mediumDark])
+        ]
+        return (lookup[rawValue] ?? EmojiWithSkinTones(unsupportedValue: rawValue))
+    }
+    
+    private static func emojiFrom5370(_ rawValue: String) -> EmojiWithSkinTones {
+        let lookup: [String: EmojiWithSkinTones] = [
+            "👨‍👩‍👧‍👦": EmojiWithSkinTones(baseEmoji: .manWomanGirlBoy, skinTones: nil),
+            "👨‍👩‍👦‍👦": EmojiWithSkinTones(baseEmoji: .manWomanBoyBoy, skinTones: nil),
+            "👨‍👩‍👧‍👧": EmojiWithSkinTones(baseEmoji: .manWomanGirlGirl, skinTones: nil),
+            "👨‍👨‍👧‍👦": EmojiWithSkinTones(baseEmoji: .manManGirlBoy, skinTones: nil),
+            "👨‍👨‍👦‍👦": EmojiWithSkinTones(baseEmoji: .manManBoyBoy, skinTones: nil),
+            "👨‍👨‍👧‍👧": EmojiWithSkinTones(baseEmoji: .manManGirlGirl, skinTones: nil),
+            "👩‍👩‍👧‍👦": EmojiWithSkinTones(baseEmoji: .womanWomanGirlBoy, skinTones: nil),
+            "👩‍👩‍👦‍👦": EmojiWithSkinTones(baseEmoji: .womanWomanBoyBoy, skinTones: nil),
+            "👩‍👩‍👧‍👧": EmojiWithSkinTones(baseEmoji: .womanWomanGirlGirl, skinTones: nil)
+        ]
+        return (lookup[rawValue] ?? EmojiWithSkinTones(unsupportedValue: rawValue))
+    }
+    
+    private static func emojiFrom6037(_ rawValue: String) -> EmojiWithSkinTones {
+        let lookup: [String: EmojiWithSkinTones] = [
+            "👩🏻‍❤️‍👨🏻": EmojiWithSkinTones(baseEmoji: .womanHeartMan, skinTones: [.light]),
+            "👨🏻‍❤️‍👨🏻": EmojiWithSkinTones(baseEmoji: .manHeartMan, skinTones: [.light]),
+            "👩🏻‍❤️‍👩🏻": EmojiWithSkinTones(baseEmoji: .womanHeartWoman, skinTones: [.light]),
+            "👩🏻‍❤️‍👨🏼": EmojiWithSkinTones(baseEmoji: .womanHeartMan, skinTones: [.light, .mediumLight]),
+            "👨🏻‍❤️‍👨🏼": EmojiWithSkinTones(baseEmoji: .manHeartMan, skinTones: [.light, .mediumLight]),
+            "👩🏻‍❤️‍👩🏼": EmojiWithSkinTones(baseEmoji: .womanHeartWoman, skinTones: [.light, .mediumLight]),
+            "👩🏻‍❤️‍👨🏽": EmojiWithSkinTones(baseEmoji: .womanHeartMan, skinTones: [.light, .medium]),
+            "👨🏻‍❤️‍👨🏽": EmojiWithSkinTones(baseEmoji: .manHeartMan, skinTones: [.light, .medium]),
+            "👩🏻‍❤️‍👩🏽": EmojiWithSkinTones(baseEmoji: .womanHeartWoman, skinTones: [.light, .medium]),
+            "👩🏻‍❤️‍👨🏾": EmojiWithSkinTones(baseEmoji: .womanHeartMan, skinTones: [.light, .mediumDark]),
+            "👨🏻‍❤️‍👨🏾": EmojiWithSkinTones(baseEmoji: .manHeartMan, skinTones: [.light, .mediumDark]),
+            "👩🏻‍❤️‍👩🏾": EmojiWithSkinTones(baseEmoji: .womanHeartWoman, skinTones: [.light, .mediumDark]),
+            "👩🏻‍❤️‍👨🏿": EmojiWithSkinTones(baseEmoji: .womanHeartMan, skinTones: [.light, .dark]),
+            "👨🏻‍❤️‍👨🏿": EmojiWithSkinTones(baseEmoji: .manHeartMan, skinTones: [.light, .dark]),
+            "👩🏻‍❤️‍👩🏿": EmojiWithSkinTones(baseEmoji: .womanHeartWoman, skinTones: [.light, .dark]),
+            "👩🏼‍❤️‍👨🏼": EmojiWithSkinTones(baseEmoji: .womanHeartMan, skinTones: [.mediumLight]),
+            "👨🏼‍❤️‍👨🏼": EmojiWithSkinTones(baseEmoji: .manHeartMan, skinTones: [.mediumLight]),
+            "👩🏼‍❤️‍👩🏼": EmojiWithSkinTones(baseEmoji: .womanHeartWoman, skinTones: [.mediumLight]),
+            "👩🏼‍❤️‍👨🏻": EmojiWithSkinTones(baseEmoji: .womanHeartMan, skinTones: [.mediumLight, .light]),
+            "👨🏼‍❤️‍👨🏻": EmojiWithSkinTones(baseEmoji: .manHeartMan, skinTones: [.mediumLight, .light]),
+            "👩🏼‍❤️‍👩🏻": EmojiWithSkinTones(baseEmoji: .womanHeartWoman, skinTones: [.mediumLight, .light]),
+            "👩🏼‍❤️‍👨🏽": EmojiWithSkinTones(baseEmoji: .womanHeartMan, skinTones: [.mediumLight, .medium]),
+            "👨🏼‍❤️‍👨🏽": EmojiWithSkinTones(baseEmoji: .manHeartMan, skinTones: [.mediumLight, .medium]),
+            "👩🏼‍❤️‍👩🏽": EmojiWithSkinTones(baseEmoji: .womanHeartWoman, skinTones: [.mediumLight, .medium]),
+            "👩🏼‍❤️‍👨🏾": EmojiWithSkinTones(baseEmoji: .womanHeartMan, skinTones: [.mediumLight, .mediumDark]),
+            "👨🏼‍❤️‍👨🏾": EmojiWithSkinTones(baseEmoji: .manHeartMan, skinTones: [.mediumLight, .mediumDark]),
+            "👩🏼‍❤️‍👩🏾": EmojiWithSkinTones(baseEmoji: .womanHeartWoman, skinTones: [.mediumLight, .mediumDark]),
+            "👩🏼‍❤️‍👨🏿": EmojiWithSkinTones(baseEmoji: .womanHeartMan, skinTones: [.mediumLight, .dark]),
+            "👨🏼‍❤️‍👨🏿": EmojiWithSkinTones(baseEmoji: .manHeartMan, skinTones: [.mediumLight, .dark]),
+            "👩🏼‍❤️‍👩🏿": EmojiWithSkinTones(baseEmoji: .womanHeartWoman, skinTones: [.mediumLight, .dark]),
+            "👩🏽‍❤️‍👨🏽": EmojiWithSkinTones(baseEmoji: .womanHeartMan, skinTones: [.medium]),
+            "👨🏽‍❤️‍👨🏽": EmojiWithSkinTones(baseEmoji: .manHeartMan, skinTones: [.medium]),
+            "👩🏽‍❤️‍👩🏽": EmojiWithSkinTones(baseEmoji: .womanHeartWoman, skinTones: [.medium]),
+            "👩🏽‍❤️‍👨🏻": EmojiWithSkinTones(baseEmoji: .womanHeartMan, skinTones: [.medium, .light]),
+            "👨🏽‍❤️‍👨🏻": EmojiWithSkinTones(baseEmoji: .manHeartMan, skinTones: [.medium, .light]),
+            "👩🏽‍❤️‍👩🏻": EmojiWithSkinTones(baseEmoji: .womanHeartWoman, skinTones: [.medium, .light]),
+            "👩🏽‍❤️‍👨🏼": EmojiWithSkinTones(baseEmoji: .womanHeartMan, skinTones: [.medium, .mediumLight]),
+            "👨🏽‍❤️‍👨🏼": EmojiWithSkinTones(baseEmoji: .manHeartMan, skinTones: [.medium, .mediumLight]),
+            "👩🏽‍❤️‍👩🏼": EmojiWithSkinTones(baseEmoji: .womanHeartWoman, skinTones: [.medium, .mediumLight]),
+            "👩🏽‍❤️‍👨🏾": EmojiWithSkinTones(baseEmoji: .womanHeartMan, skinTones: [.medium, .mediumDark]),
+            "👨🏽‍❤️‍👨🏾": EmojiWithSkinTones(baseEmoji: .manHeartMan, skinTones: [.medium, .mediumDark]),
+            "👩🏽‍❤️‍👩🏾": EmojiWithSkinTones(baseEmoji: .womanHeartWoman, skinTones: [.medium, .mediumDark]),
+            "👩🏽‍❤️‍👨🏿": EmojiWithSkinTones(baseEmoji: .womanHeartMan, skinTones: [.medium, .dark]),
+            "👨🏽‍❤️‍👨🏿": EmojiWithSkinTones(baseEmoji: .manHeartMan, skinTones: [.medium, .dark]),
+            "👩🏽‍❤️‍👩🏿": EmojiWithSkinTones(baseEmoji: .womanHeartWoman, skinTones: [.medium, .dark]),
+            "👩🏾‍❤️‍👨🏾": EmojiWithSkinTones(baseEmoji: .womanHeartMan, skinTones: [.mediumDark]),
+            "👨🏾‍❤️‍👨🏾": EmojiWithSkinTones(baseEmoji: .manHeartMan, skinTones: [.mediumDark]),
+            "👩🏾‍❤️‍👩🏾": EmojiWithSkinTones(baseEmoji: .womanHeartWoman, skinTones: [.mediumDark]),
+            "👩🏾‍❤️‍👨🏻": EmojiWithSkinTones(baseEmoji: .womanHeartMan, skinTones: [.mediumDark, .light]),
+            "👨🏾‍❤️‍👨🏻": EmojiWithSkinTones(baseEmoji: .manHeartMan, skinTones: [.mediumDark, .light]),
+            "👩🏾‍❤️‍👩🏻": EmojiWithSkinTones(baseEmoji: .womanHeartWoman, skinTones: [.mediumDark, .light]),
+            "👩🏾‍❤️‍👨🏼": EmojiWithSkinTones(baseEmoji: .womanHeartMan, skinTones: [.mediumDark, .mediumLight]),
+            "👨🏾‍❤️‍👨🏼": EmojiWithSkinTones(baseEmoji: .manHeartMan, skinTones: [.mediumDark, .mediumLight]),
+            "👩🏾‍❤️‍👩🏼": EmojiWithSkinTones(baseEmoji: .womanHeartWoman, skinTones: [.mediumDark, .mediumLight]),
+            "👩🏾‍❤️‍👨🏽": EmojiWithSkinTones(baseEmoji: .womanHeartMan, skinTones: [.mediumDark, .medium]),
+            "👨🏾‍❤️‍👨🏽": EmojiWithSkinTones(baseEmoji: .manHeartMan, skinTones: [.mediumDark, .medium]),
+            "👩🏾‍❤️‍👩🏽": EmojiWithSkinTones(baseEmoji: .womanHeartWoman, skinTones: [.mediumDark, .medium]),
+            "👩🏾‍❤️‍👨🏿": EmojiWithSkinTones(baseEmoji: .womanHeartMan, skinTones: [.mediumDark, .dark]),
+            "👨🏾‍❤️‍👨🏿": EmojiWithSkinTones(baseEmoji: .manHeartMan, skinTones: [.mediumDark, .dark]),
+            "👩🏾‍❤️‍👩🏿": EmojiWithSkinTones(baseEmoji: .womanHeartWoman, skinTones: [.mediumDark, .dark]),
+            "👩🏿‍❤️‍👨🏿": EmojiWithSkinTones(baseEmoji: .womanHeartMan, skinTones: [.dark]),
+            "👨🏿‍❤️‍👨🏿": EmojiWithSkinTones(baseEmoji: .manHeartMan, skinTones: [.dark]),
+            "👩🏿‍❤️‍👩🏿": EmojiWithSkinTones(baseEmoji: .womanHeartWoman, skinTones: [.dark]),
+            "👩🏿‍❤️‍👨🏻": EmojiWithSkinTones(baseEmoji: .womanHeartMan, skinTones: [.dark, .light]),
+            "👨🏿‍❤️‍👨🏻": EmojiWithSkinTones(baseEmoji: .manHeartMan, skinTones: [.dark, .light]),
+            "👩🏿‍❤️‍👩🏻": EmojiWithSkinTones(baseEmoji: .womanHeartWoman, skinTones: [.dark, .light]),
+            "👩🏿‍❤️‍👨🏼": EmojiWithSkinTones(baseEmoji: .womanHeartMan, skinTones: [.dark, .mediumLight]),
+            "👨🏿‍❤️‍👨🏼": EmojiWithSkinTones(baseEmoji: .manHeartMan, skinTones: [.dark, .mediumLight]),
+            "👩🏿‍❤️‍👩🏼": EmojiWithSkinTones(baseEmoji: .womanHeartWoman, skinTones: [.dark, .mediumLight]),
+            "👩🏿‍❤️‍👨🏽": EmojiWithSkinTones(baseEmoji: .womanHeartMan, skinTones: [.dark, .medium]),
+            "👨🏿‍❤️‍👨🏽": EmojiWithSkinTones(baseEmoji: .manHeartMan, skinTones: [.dark, .medium]),
+            "👩🏿‍❤️‍👩🏽": EmojiWithSkinTones(baseEmoji: .womanHeartWoman, skinTones: [.dark, .medium]),
+            "👩🏿‍❤️‍👨🏾": EmojiWithSkinTones(baseEmoji: .womanHeartMan, skinTones: [.dark, .mediumDark]),
+            "👨🏿‍❤️‍👨🏾": EmojiWithSkinTones(baseEmoji: .manHeartMan, skinTones: [.dark, .mediumDark]),
+            "👩🏿‍❤️‍👩🏾": EmojiWithSkinTones(baseEmoji: .womanHeartWoman, skinTones: [.dark, .mediumDark])
+        ]
+        return (lookup[rawValue] ?? EmojiWithSkinTones(unsupportedValue: rawValue))
+    }
+    
+    private static func emojiFrom6065(_ rawValue: String) -> EmojiWithSkinTones {
+        let lookup: [String: EmojiWithSkinTones] = [
+            "🧑🏻‍❤️‍🧑🏼": EmojiWithSkinTones(baseEmoji: .personHeartPerson, skinTones: [.light, .mediumLight]),
+            "🧑🏻‍❤️‍🧑🏽": EmojiWithSkinTones(baseEmoji: .personHeartPerson, skinTones: [.light, .medium]),
+            "🧑🏻‍❤️‍🧑🏾": EmojiWithSkinTones(baseEmoji: .personHeartPerson, skinTones: [.light, .mediumDark]),
+            "🧑🏻‍❤️‍🧑🏿": EmojiWithSkinTones(baseEmoji: .personHeartPerson, skinTones: [.light, .dark]),
+            "🧑🏼‍❤️‍🧑🏻": EmojiWithSkinTones(baseEmoji: .personHeartPerson, skinTones: [.mediumLight, .light]),
+            "🧑🏼‍❤️‍🧑🏽": EmojiWithSkinTones(baseEmoji: .personHeartPerson, skinTones: [.mediumLight, .medium]),
+            "🧑🏼‍❤️‍🧑🏾": EmojiWithSkinTones(baseEmoji: .personHeartPerson, skinTones: [.mediumLight, .mediumDark]),
+            "🧑🏼‍❤️‍🧑🏿": EmojiWithSkinTones(baseEmoji: .personHeartPerson, skinTones: [.mediumLight, .dark]),
+            "🧑🏽‍❤️‍🧑🏻": EmojiWithSkinTones(baseEmoji: .personHeartPerson, skinTones: [.medium, .light]),
+            "🧑🏽‍❤️‍🧑🏼": EmojiWithSkinTones(baseEmoji: .personHeartPerson, skinTones: [.medium, .mediumLight]),
+            "🧑🏽‍❤️‍🧑🏾": EmojiWithSkinTones(baseEmoji: .personHeartPerson, skinTones: [.medium, .mediumDark]),
+            "🧑🏽‍❤️‍🧑🏿": EmojiWithSkinTones(baseEmoji: .personHeartPerson, skinTones: [.medium, .dark]),
+            "🧑🏾‍❤️‍🧑🏻": EmojiWithSkinTones(baseEmoji: .personHeartPerson, skinTones: [.mediumDark, .light]),
+            "🧑🏾‍❤️‍🧑🏼": EmojiWithSkinTones(baseEmoji: .personHeartPerson, skinTones: [.mediumDark, .mediumLight]),
+            "🧑🏾‍❤️‍🧑🏽": EmojiWithSkinTones(baseEmoji: .personHeartPerson, skinTones: [.mediumDark, .medium]),
+            "🧑🏾‍❤️‍🧑🏿": EmojiWithSkinTones(baseEmoji: .personHeartPerson, skinTones: [.mediumDark, .dark]),
+            "🧑🏿‍❤️‍🧑🏻": EmojiWithSkinTones(baseEmoji: .personHeartPerson, skinTones: [.dark, .light]),
+            "🧑🏿‍❤️‍🧑🏼": EmojiWithSkinTones(baseEmoji: .personHeartPerson, skinTones: [.dark, .mediumLight]),
+            "🧑🏿‍❤️‍🧑🏽": EmojiWithSkinTones(baseEmoji: .personHeartPerson, skinTones: [.dark, .medium]),
+            "🧑🏿‍❤️‍🧑🏾": EmojiWithSkinTones(baseEmoji: .personHeartPerson, skinTones: [.dark, .mediumDark])
+        ]
+        return (lookup[rawValue] ?? EmojiWithSkinTones(unsupportedValue: rawValue))
+    }
+    
+    private static func emojiFrom6579(_ rawValue: String) -> EmojiWithSkinTones {
+        let lookup: [String: EmojiWithSkinTones] = [
+            "👩🏻‍🤝‍👩🏼": EmojiWithSkinTones(baseEmoji: .twoWomenHoldingHands, skinTones: [.light, .mediumLight]),
+            "👩🏻‍🤝‍👨🏼": EmojiWithSkinTones(baseEmoji: .manAndWomanHoldingHands, skinTones: [.light, .mediumLight]),
+            "👨🏻‍🤝‍👨🏼": EmojiWithSkinTones(baseEmoji: .twoMenHoldingHands, skinTones: [.light, .mediumLight]),
+            "👩🏻‍🤝‍👩🏽": EmojiWithSkinTones(baseEmoji: .twoWomenHoldingHands, skinTones: [.light, .medium]),
+            "👩🏻‍🤝‍👨🏽": EmojiWithSkinTones(baseEmoji: .manAndWomanHoldingHands, skinTones: [.light, .medium]),
+            "👨🏻‍🤝‍👨🏽": EmojiWithSkinTones(baseEmoji: .twoMenHoldingHands, skinTones: [.light, .medium]),
+            "👩🏻‍🤝‍👩🏾": EmojiWithSkinTones(baseEmoji: .twoWomenHoldingHands, skinTones: [.light, .mediumDark]),
+            "👩🏻‍🤝‍👨🏾": EmojiWithSkinTones(baseEmoji: .manAndWomanHoldingHands, skinTones: [.light, .mediumDark]),
+            "👨🏻‍🤝‍👨🏾": EmojiWithSkinTones(baseEmoji: .twoMenHoldingHands, skinTones: [.light, .mediumDark]),
+            "👩🏻‍🤝‍👩🏿": EmojiWithSkinTones(baseEmoji: .twoWomenHoldingHands, skinTones: [.light, .dark]),
+            "👩🏻‍🤝‍👨🏿": EmojiWithSkinTones(baseEmoji: .manAndWomanHoldingHands, skinTones: [.light, .dark]),
+            "👨🏻‍🤝‍👨🏿": EmojiWithSkinTones(baseEmoji: .twoMenHoldingHands, skinTones: [.light, .dark]),
+            "👩🏼‍🤝‍👩🏻": EmojiWithSkinTones(baseEmoji: .twoWomenHoldingHands, skinTones: [.mediumLight, .light]),
+            "👩🏼‍🤝‍👨🏻": EmojiWithSkinTones(baseEmoji: .manAndWomanHoldingHands, skinTones: [.mediumLight, .light]),
+            "👨🏼‍🤝‍👨🏻": EmojiWithSkinTones(baseEmoji: .twoMenHoldingHands, skinTones: [.mediumLight, .light]),
+            "👩🏼‍🤝‍👩🏽": EmojiWithSkinTones(baseEmoji: .twoWomenHoldingHands, skinTones: [.mediumLight, .medium]),
+            "👩🏼‍🤝‍👨🏽": EmojiWithSkinTones(baseEmoji: .manAndWomanHoldingHands, skinTones: [.mediumLight, .medium]),
+            "👨🏼‍🤝‍👨🏽": EmojiWithSkinTones(baseEmoji: .twoMenHoldingHands, skinTones: [.mediumLight, .medium]),
+            "👩🏼‍🤝‍👩🏾": EmojiWithSkinTones(baseEmoji: .twoWomenHoldingHands, skinTones: [.mediumLight, .mediumDark]),
+            "👩🏼‍🤝‍👨🏾": EmojiWithSkinTones(baseEmoji: .manAndWomanHoldingHands, skinTones: [.mediumLight, .mediumDark]),
+            "👨🏼‍🤝‍👨🏾": EmojiWithSkinTones(baseEmoji: .twoMenHoldingHands, skinTones: [.mediumLight, .mediumDark]),
+            "👩🏼‍🤝‍👩🏿": EmojiWithSkinTones(baseEmoji: .twoWomenHoldingHands, skinTones: [.mediumLight, .dark]),
+            "👩🏼‍🤝‍👨🏿": EmojiWithSkinTones(baseEmoji: .manAndWomanHoldingHands, skinTones: [.mediumLight, .dark]),
+            "👨🏼‍🤝‍👨🏿": EmojiWithSkinTones(baseEmoji: .twoMenHoldingHands, skinTones: [.mediumLight, .dark]),
+            "👩🏽‍🤝‍👩🏻": EmojiWithSkinTones(baseEmoji: .twoWomenHoldingHands, skinTones: [.medium, .light]),
+            "👩🏽‍🤝‍👨🏻": EmojiWithSkinTones(baseEmoji: .manAndWomanHoldingHands, skinTones: [.medium, .light]),
+            "👨🏽‍🤝‍👨🏻": EmojiWithSkinTones(baseEmoji: .twoMenHoldingHands, skinTones: [.medium, .light]),
+            "👩🏽‍🤝‍👩🏼": EmojiWithSkinTones(baseEmoji: .twoWomenHoldingHands, skinTones: [.medium, .mediumLight]),
+            "👩🏽‍🤝‍👨🏼": EmojiWithSkinTones(baseEmoji: .manAndWomanHoldingHands, skinTones: [.medium, .mediumLight]),
+            "👨🏽‍🤝‍👨🏼": EmojiWithSkinTones(baseEmoji: .twoMenHoldingHands, skinTones: [.medium, .mediumLight]),
+            "👩🏽‍🤝‍👩🏾": EmojiWithSkinTones(baseEmoji: .twoWomenHoldingHands, skinTones: [.medium, .mediumDark]),
+            "👩🏽‍🤝‍👨🏾": EmojiWithSkinTones(baseEmoji: .manAndWomanHoldingHands, skinTones: [.medium, .mediumDark]),
+            "👨🏽‍🤝‍👨🏾": EmojiWithSkinTones(baseEmoji: .twoMenHoldingHands, skinTones: [.medium, .mediumDark]),
+            "👩🏽‍🤝‍👩🏿": EmojiWithSkinTones(baseEmoji: .twoWomenHoldingHands, skinTones: [.medium, .dark]),
+            "👩🏽‍🤝‍👨🏿": EmojiWithSkinTones(baseEmoji: .manAndWomanHoldingHands, skinTones: [.medium, .dark]),
+            "👨🏽‍🤝‍👨🏿": EmojiWithSkinTones(baseEmoji: .twoMenHoldingHands, skinTones: [.medium, .dark]),
+            "👩🏾‍🤝‍👩🏻": EmojiWithSkinTones(baseEmoji: .twoWomenHoldingHands, skinTones: [.mediumDark, .light]),
+            "👩🏾‍🤝‍👨🏻": EmojiWithSkinTones(baseEmoji: .manAndWomanHoldingHands, skinTones: [.mediumDark, .light]),
+            "👨🏾‍🤝‍👨🏻": EmojiWithSkinTones(baseEmoji: .twoMenHoldingHands, skinTones: [.mediumDark, .light]),
+            "👩🏾‍🤝‍👩🏼": EmojiWithSkinTones(baseEmoji: .twoWomenHoldingHands, skinTones: [.mediumDark, .mediumLight]),
+            "👩🏾‍🤝‍👨🏼": EmojiWithSkinTones(baseEmoji: .manAndWomanHoldingHands, skinTones: [.mediumDark, .mediumLight]),
+            "👨🏾‍🤝‍👨🏼": EmojiWithSkinTones(baseEmoji: .twoMenHoldingHands, skinTones: [.mediumDark, .mediumLight]),
+            "👩🏾‍🤝‍👩🏽": EmojiWithSkinTones(baseEmoji: .twoWomenHoldingHands, skinTones: [.mediumDark, .medium]),
+            "👩🏾‍🤝‍👨🏽": EmojiWithSkinTones(baseEmoji: .manAndWomanHoldingHands, skinTones: [.mediumDark, .medium]),
+            "👨🏾‍🤝‍👨🏽": EmojiWithSkinTones(baseEmoji: .twoMenHoldingHands, skinTones: [.mediumDark, .medium]),
+            "👩🏾‍🤝‍👩🏿": EmojiWithSkinTones(baseEmoji: .twoWomenHoldingHands, skinTones: [.mediumDark, .dark]),
+            "👩🏾‍🤝‍👨🏿": EmojiWithSkinTones(baseEmoji: .manAndWomanHoldingHands, skinTones: [.mediumDark, .dark]),
+            "👨🏾‍🤝‍👨🏿": EmojiWithSkinTones(baseEmoji: .twoMenHoldingHands, skinTones: [.mediumDark, .dark]),
+            "👩🏿‍🤝‍👩🏻": EmojiWithSkinTones(baseEmoji: .twoWomenHoldingHands, skinTones: [.dark, .light]),
+            "👩🏿‍🤝‍👨🏻": EmojiWithSkinTones(baseEmoji: .manAndWomanHoldingHands, skinTones: [.dark, .light]),
+            "👨🏿‍🤝‍👨🏻": EmojiWithSkinTones(baseEmoji: .twoMenHoldingHands, skinTones: [.dark, .light]),
+            "👩🏿‍🤝‍👩🏼": EmojiWithSkinTones(baseEmoji: .twoWomenHoldingHands, skinTones: [.dark, .mediumLight]),
+            "👩🏿‍🤝‍👨🏼": EmojiWithSkinTones(baseEmoji: .manAndWomanHoldingHands, skinTones: [.dark, .mediumLight]),
+            "👨🏿‍🤝‍👨🏼": EmojiWithSkinTones(baseEmoji: .twoMenHoldingHands, skinTones: [.dark, .mediumLight]),
+            "👩🏿‍🤝‍👩🏽": EmojiWithSkinTones(baseEmoji: .twoWomenHoldingHands, skinTones: [.dark, .medium]),
+            "👩🏿‍🤝‍👨🏽": EmojiWithSkinTones(baseEmoji: .manAndWomanHoldingHands, skinTones: [.dark, .medium]),
+            "👨🏿‍🤝‍👨🏽": EmojiWithSkinTones(baseEmoji: .twoMenHoldingHands, skinTones: [.dark, .medium]),
+            "👩🏿‍🤝‍👩🏾": EmojiWithSkinTones(baseEmoji: .twoWomenHoldingHands, skinTones: [.dark, .mediumDark]),
+            "👩🏿‍🤝‍👨🏾": EmojiWithSkinTones(baseEmoji: .manAndWomanHoldingHands, skinTones: [.dark, .mediumDark]),
+            "👨🏿‍🤝‍👨🏾": EmojiWithSkinTones(baseEmoji: .twoMenHoldingHands, skinTones: [.dark, .mediumDark])
+        ]
+        return (lookup[rawValue] ?? EmojiWithSkinTones(unsupportedValue: rawValue))
+    }
+    
+    private static func emojiFrom6606(_ rawValue: String) -> EmojiWithSkinTones {
+        let lookup: [String: EmojiWithSkinTones] = [
+            "🧑🏻‍🤝‍🧑🏻": EmojiWithSkinTones(baseEmoji: .peopleHoldingHands, skinTones: [.light]),
+            "🧑🏻‍🤝‍🧑🏼": EmojiWithSkinTones(baseEmoji: .peopleHoldingHands, skinTones: [.light, .mediumLight]),
+            "🧑🏻‍🤝‍🧑🏽": EmojiWithSkinTones(baseEmoji: .peopleHoldingHands, skinTones: [.light, .medium]),
+            "🧑🏻‍🤝‍🧑🏾": EmojiWithSkinTones(baseEmoji: .peopleHoldingHands, skinTones: [.light, .mediumDark]),
+            "🧑🏻‍🤝‍🧑🏿": EmojiWithSkinTones(baseEmoji: .peopleHoldingHands, skinTones: [.light, .dark]),
+            "🧑🏼‍🤝‍🧑🏼": EmojiWithSkinTones(baseEmoji: .peopleHoldingHands, skinTones: [.mediumLight]),
+            "🧑🏼‍🤝‍🧑🏻": EmojiWithSkinTones(baseEmoji: .peopleHoldingHands, skinTones: [.mediumLight, .light]),
+            "🧑🏼‍🤝‍🧑🏽": EmojiWithSkinTones(baseEmoji: .peopleHoldingHands, skinTones: [.mediumLight, .medium]),
+            "🧑🏼‍🤝‍🧑🏾": EmojiWithSkinTones(baseEmoji: .peopleHoldingHands, skinTones: [.mediumLight, .mediumDark]),
+            "🧑🏼‍🤝‍🧑🏿": EmojiWithSkinTones(baseEmoji: .peopleHoldingHands, skinTones: [.mediumLight, .dark]),
+            "🧑🏽‍🤝‍🧑🏽": EmojiWithSkinTones(baseEmoji: .peopleHoldingHands, skinTones: [.medium]),
+            "🧑🏽‍🤝‍🧑🏻": EmojiWithSkinTones(baseEmoji: .peopleHoldingHands, skinTones: [.medium, .light]),
+            "🧑🏽‍🤝‍🧑🏼": EmojiWithSkinTones(baseEmoji: .peopleHoldingHands, skinTones: [.medium, .mediumLight]),
+            "🧑🏽‍🤝‍🧑🏾": EmojiWithSkinTones(baseEmoji: .peopleHoldingHands, skinTones: [.medium, .mediumDark]),
+            "🧑🏽‍🤝‍🧑🏿": EmojiWithSkinTones(baseEmoji: .peopleHoldingHands, skinTones: [.medium, .dark]),
+            "🧑🏾‍🤝‍🧑🏾": EmojiWithSkinTones(baseEmoji: .peopleHoldingHands, skinTones: [.mediumDark]),
+            "🧑🏾‍🤝‍🧑🏻": EmojiWithSkinTones(baseEmoji: .peopleHoldingHands, skinTones: [.mediumDark, .light]),
+            "🧑🏾‍🤝‍🧑🏼": EmojiWithSkinTones(baseEmoji: .peopleHoldingHands, skinTones: [.mediumDark, .mediumLight]),
+            "🧑🏾‍🤝‍🧑🏽": EmojiWithSkinTones(baseEmoji: .peopleHoldingHands, skinTones: [.mediumDark, .medium]),
+            "🧑🏾‍🤝‍🧑🏿": EmojiWithSkinTones(baseEmoji: .peopleHoldingHands, skinTones: [.mediumDark, .dark]),
+            "🧑🏿‍🤝‍🧑🏿": EmojiWithSkinTones(baseEmoji: .peopleHoldingHands, skinTones: [.dark]),
+            "🧑🏿‍🤝‍🧑🏻": EmojiWithSkinTones(baseEmoji: .peopleHoldingHands, skinTones: [.dark, .light]),
+            "🧑🏿‍🤝‍🧑🏼": EmojiWithSkinTones(baseEmoji: .peopleHoldingHands, skinTones: [.dark, .mediumLight]),
+            "🧑🏿‍🤝‍🧑🏽": EmojiWithSkinTones(baseEmoji: .peopleHoldingHands, skinTones: [.dark, .medium]),
+            "🧑🏿‍🤝‍🧑🏾": EmojiWithSkinTones(baseEmoji: .peopleHoldingHands, skinTones: [.dark, .mediumDark])
+        ]
+        return (lookup[rawValue] ?? EmojiWithSkinTones(unsupportedValue: rawValue))
+    }
+    
+    private static func emojiFrom7400(_ rawValue: String) -> EmojiWithSkinTones {
+        let lookup: [String: EmojiWithSkinTones] = [
+            "👩🏻‍❤️‍💋‍👨🏻": EmojiWithSkinTones(baseEmoji: .womanKissMan, skinTones: [.light]),
+            "👨🏻‍❤️‍💋‍👨🏻": EmojiWithSkinTones(baseEmoji: .manKissMan, skinTones: [.light]),
+            "👩🏻‍❤️‍💋‍👩🏻": EmojiWithSkinTones(baseEmoji: .womanKissWoman, skinTones: [.light]),
+            "👩🏻‍❤️‍💋‍👨🏼": EmojiWithSkinTones(baseEmoji: .womanKissMan, skinTones: [.light, .mediumLight]),
+            "👨🏻‍❤️‍💋‍👨🏼": EmojiWithSkinTones(baseEmoji: .manKissMan, skinTones: [.light, .mediumLight]),
+            "👩🏻‍❤️‍💋‍👩🏼": EmojiWithSkinTones(baseEmoji: .womanKissWoman, skinTones: [.light, .mediumLight]),
+            "👩🏻‍❤️‍💋‍👨🏽": EmojiWithSkinTones(baseEmoji: .womanKissMan, skinTones: [.light, .medium]),
+            "👨🏻‍❤️‍💋‍👨🏽": EmojiWithSkinTones(baseEmoji: .manKissMan, skinTones: [.light, .medium]),
+            "👩🏻‍❤️‍💋‍👩🏽": EmojiWithSkinTones(baseEmoji: .womanKissWoman, skinTones: [.light, .medium]),
+            "👩🏻‍❤️‍💋‍👨🏾": EmojiWithSkinTones(baseEmoji: .womanKissMan, skinTones: [.light, .mediumDark]),
+            "👨🏻‍❤️‍💋‍👨🏾": EmojiWithSkinTones(baseEmoji: .manKissMan, skinTones: [.light, .mediumDark]),
+            "👩🏻‍❤️‍💋‍👩🏾": EmojiWithSkinTones(baseEmoji: .womanKissWoman, skinTones: [.light, .mediumDark]),
+            "👩🏻‍❤️‍💋‍👨🏿": EmojiWithSkinTones(baseEmoji: .womanKissMan, skinTones: [.light, .dark]),
+            "👨🏻‍❤️‍💋‍👨🏿": EmojiWithSkinTones(baseEmoji: .manKissMan, skinTones: [.light, .dark]),
+            "👩🏻‍❤️‍💋‍👩🏿": EmojiWithSkinTones(baseEmoji: .womanKissWoman, skinTones: [.light, .dark]),
+            "👩🏼‍❤️‍💋‍👨🏼": EmojiWithSkinTones(baseEmoji: .womanKissMan, skinTones: [.mediumLight]),
+            "👨🏼‍❤️‍💋‍👨🏼": EmojiWithSkinTones(baseEmoji: .manKissMan, skinTones: [.mediumLight]),
+            "👩🏼‍❤️‍💋‍👩🏼": EmojiWithSkinTones(baseEmoji: .womanKissWoman, skinTones: [.mediumLight]),
+            "👩🏼‍❤️‍💋‍👨🏻": EmojiWithSkinTones(baseEmoji: .womanKissMan, skinTones: [.mediumLight, .light]),
+            "👨🏼‍❤️‍💋‍👨🏻": EmojiWithSkinTones(baseEmoji: .manKissMan, skinTones: [.mediumLight, .light]),
+            "👩🏼‍❤️‍💋‍👩🏻": EmojiWithSkinTones(baseEmoji: .womanKissWoman, skinTones: [.mediumLight, .light]),
+            "👩🏼‍❤️‍💋‍👨🏽": EmojiWithSkinTones(baseEmoji: .womanKissMan, skinTones: [.mediumLight, .medium]),
+            "👨🏼‍❤️‍💋‍👨🏽": EmojiWithSkinTones(baseEmoji: .manKissMan, skinTones: [.mediumLight, .medium]),
+            "👩🏼‍❤️‍💋‍👩🏽": EmojiWithSkinTones(baseEmoji: .womanKissWoman, skinTones: [.mediumLight, .medium]),
+            "👩🏼‍❤️‍💋‍👨🏾": EmojiWithSkinTones(baseEmoji: .womanKissMan, skinTones: [.mediumLight, .mediumDark]),
+            "👨🏼‍❤️‍💋‍👨🏾": EmojiWithSkinTones(baseEmoji: .manKissMan, skinTones: [.mediumLight, .mediumDark]),
+            "👩🏼‍❤️‍💋‍👩🏾": EmojiWithSkinTones(baseEmoji: .womanKissWoman, skinTones: [.mediumLight, .mediumDark]),
+            "👩🏼‍❤️‍💋‍👨🏿": EmojiWithSkinTones(baseEmoji: .womanKissMan, skinTones: [.mediumLight, .dark]),
+            "👨🏼‍❤️‍💋‍👨🏿": EmojiWithSkinTones(baseEmoji: .manKissMan, skinTones: [.mediumLight, .dark]),
+            "👩🏼‍❤️‍💋‍👩🏿": EmojiWithSkinTones(baseEmoji: .womanKissWoman, skinTones: [.mediumLight, .dark]),
+            "👩🏽‍❤️‍💋‍👨🏽": EmojiWithSkinTones(baseEmoji: .womanKissMan, skinTones: [.medium]),
+            "👨🏽‍❤️‍💋‍👨🏽": EmojiWithSkinTones(baseEmoji: .manKissMan, skinTones: [.medium]),
+            "👩🏽‍❤️‍💋‍👩🏽": EmojiWithSkinTones(baseEmoji: .womanKissWoman, skinTones: [.medium]),
+            "👩🏽‍❤️‍💋‍👨🏻": EmojiWithSkinTones(baseEmoji: .womanKissMan, skinTones: [.medium, .light]),
+            "👨🏽‍❤️‍💋‍👨🏻": EmojiWithSkinTones(baseEmoji: .manKissMan, skinTones: [.medium, .light]),
+            "👩🏽‍❤️‍💋‍👩🏻": EmojiWithSkinTones(baseEmoji: .womanKissWoman, skinTones: [.medium, .light]),
+            "👩🏽‍❤️‍💋‍👨🏼": EmojiWithSkinTones(baseEmoji: .womanKissMan, skinTones: [.medium, .mediumLight]),
+            "👨🏽‍❤️‍💋‍👨🏼": EmojiWithSkinTones(baseEmoji: .manKissMan, skinTones: [.medium, .mediumLight]),
+            "👩🏽‍❤️‍💋‍👩🏼": EmojiWithSkinTones(baseEmoji: .womanKissWoman, skinTones: [.medium, .mediumLight]),
+            "👩🏽‍❤️‍💋‍👨🏾": EmojiWithSkinTones(baseEmoji: .womanKissMan, skinTones: [.medium, .mediumDark]),
+            "👨🏽‍❤️‍💋‍👨🏾": EmojiWithSkinTones(baseEmoji: .manKissMan, skinTones: [.medium, .mediumDark]),
+            "👩🏽‍❤️‍💋‍👩🏾": EmojiWithSkinTones(baseEmoji: .womanKissWoman, skinTones: [.medium, .mediumDark]),
+            "👩🏽‍❤️‍💋‍👨🏿": EmojiWithSkinTones(baseEmoji: .womanKissMan, skinTones: [.medium, .dark]),
+            "👨🏽‍❤️‍💋‍👨🏿": EmojiWithSkinTones(baseEmoji: .manKissMan, skinTones: [.medium, .dark]),
+            "👩🏽‍❤️‍💋‍👩🏿": EmojiWithSkinTones(baseEmoji: .womanKissWoman, skinTones: [.medium, .dark]),
+            "👩🏾‍❤️‍💋‍👨🏾": EmojiWithSkinTones(baseEmoji: .womanKissMan, skinTones: [.mediumDark]),
+            "👨🏾‍❤️‍💋‍👨🏾": EmojiWithSkinTones(baseEmoji: .manKissMan, skinTones: [.mediumDark]),
+            "👩🏾‍❤️‍💋‍👩🏾": EmojiWithSkinTones(baseEmoji: .womanKissWoman, skinTones: [.mediumDark]),
+            "👩🏾‍❤️‍💋‍👨🏻": EmojiWithSkinTones(baseEmoji: .womanKissMan, skinTones: [.mediumDark, .light]),
+            "👨🏾‍❤️‍💋‍👨🏻": EmojiWithSkinTones(baseEmoji: .manKissMan, skinTones: [.mediumDark, .light]),
+            "👩🏾‍❤️‍💋‍👩🏻": EmojiWithSkinTones(baseEmoji: .womanKissWoman, skinTones: [.mediumDark, .light]),
+            "👩🏾‍❤️‍💋‍👨🏼": EmojiWithSkinTones(baseEmoji: .womanKissMan, skinTones: [.mediumDark, .mediumLight]),
+            "👨🏾‍❤️‍💋‍👨🏼": EmojiWithSkinTones(baseEmoji: .manKissMan, skinTones: [.mediumDark, .mediumLight]),
+            "👩🏾‍❤️‍💋‍👩🏼": EmojiWithSkinTones(baseEmoji: .womanKissWoman, skinTones: [.mediumDark, .mediumLight]),
+            "👩🏾‍❤️‍💋‍👨🏽": EmojiWithSkinTones(baseEmoji: .womanKissMan, skinTones: [.mediumDark, .medium]),
+            "👨🏾‍❤️‍💋‍👨🏽": EmojiWithSkinTones(baseEmoji: .manKissMan, skinTones: [.mediumDark, .medium]),
+            "👩🏾‍❤️‍💋‍👩🏽": EmojiWithSkinTones(baseEmoji: .womanKissWoman, skinTones: [.mediumDark, .medium]),
+            "👩🏾‍❤️‍💋‍👨🏿": EmojiWithSkinTones(baseEmoji: .womanKissMan, skinTones: [.mediumDark, .dark]),
+            "👨🏾‍❤️‍💋‍👨🏿": EmojiWithSkinTones(baseEmoji: .manKissMan, skinTones: [.mediumDark, .dark]),
+            "👩🏾‍❤️‍💋‍👩🏿": EmojiWithSkinTones(baseEmoji: .womanKissWoman, skinTones: [.mediumDark, .dark]),
+            "👩🏿‍❤️‍💋‍👨🏿": EmojiWithSkinTones(baseEmoji: .womanKissMan, skinTones: [.dark]),
+            "👨🏿‍❤️‍💋‍👨🏿": EmojiWithSkinTones(baseEmoji: .manKissMan, skinTones: [.dark]),
+            "👩🏿‍❤️‍💋‍👩🏿": EmojiWithSkinTones(baseEmoji: .womanKissWoman, skinTones: [.dark]),
+            "👩🏿‍❤️‍💋‍👨🏻": EmojiWithSkinTones(baseEmoji: .womanKissMan, skinTones: [.dark, .light]),
+            "👨🏿‍❤️‍💋‍👨🏻": EmojiWithSkinTones(baseEmoji: .manKissMan, skinTones: [.dark, .light]),
+            "👩🏿‍❤️‍💋‍👩🏻": EmojiWithSkinTones(baseEmoji: .womanKissWoman, skinTones: [.dark, .light]),
+            "👩🏿‍❤️‍💋‍👨🏼": EmojiWithSkinTones(baseEmoji: .womanKissMan, skinTones: [.dark, .mediumLight]),
+            "👨🏿‍❤️‍💋‍👨🏼": EmojiWithSkinTones(baseEmoji: .manKissMan, skinTones: [.dark, .mediumLight]),
+            "👩🏿‍❤️‍💋‍👩🏼": EmojiWithSkinTones(baseEmoji: .womanKissWoman, skinTones: [.dark, .mediumLight]),
+            "👩🏿‍❤️‍💋‍👨🏽": EmojiWithSkinTones(baseEmoji: .womanKissMan, skinTones: [.dark, .medium]),
+            "👨🏿‍❤️‍💋‍👨🏽": EmojiWithSkinTones(baseEmoji: .manKissMan, skinTones: [.dark, .medium]),
+            "👩🏿‍❤️‍💋‍👩🏽": EmojiWithSkinTones(baseEmoji: .womanKissWoman, skinTones: [.dark, .medium]),
+            "👩🏿‍❤️‍💋‍👨🏾": EmojiWithSkinTones(baseEmoji: .womanKissMan, skinTones: [.dark, .mediumDark]),
+            "👨🏿‍❤️‍💋‍👨🏾": EmojiWithSkinTones(baseEmoji: .manKissMan, skinTones: [.dark, .mediumDark]),
+            "👩🏿‍❤️‍💋‍👩🏾": EmojiWithSkinTones(baseEmoji: .womanKissWoman, skinTones: [.dark, .mediumDark])
+        ]
+        return (lookup[rawValue] ?? EmojiWithSkinTones(unsupportedValue: rawValue))
+    }
+    
+    private static func emojiFrom7428(_ rawValue: String) -> EmojiWithSkinTones {
+        let lookup: [String: EmojiWithSkinTones] = [
+            "🧑🏻‍❤️‍💋‍🧑🏼": EmojiWithSkinTones(baseEmoji: .personKissPerson, skinTones: [.light, .mediumLight]),
+            "🧑🏻‍❤️‍💋‍🧑🏽": EmojiWithSkinTones(baseEmoji: .personKissPerson, skinTones: [.light, .medium]),
+            "🧑🏻‍❤️‍💋‍🧑🏾": EmojiWithSkinTones(baseEmoji: .personKissPerson, skinTones: [.light, .mediumDark]),
+            "🧑🏻‍❤️‍💋‍🧑🏿": EmojiWithSkinTones(baseEmoji: .personKissPerson, skinTones: [.light, .dark]),
+            "🧑🏼‍❤️‍💋‍🧑🏻": EmojiWithSkinTones(baseEmoji: .personKissPerson, skinTones: [.mediumLight, .light]),
+            "🧑🏼‍❤️‍💋‍🧑🏽": EmojiWithSkinTones(baseEmoji: .personKissPerson, skinTones: [.mediumLight, .medium]),
+            "🧑🏼‍❤️‍💋‍🧑🏾": EmojiWithSkinTones(baseEmoji: .personKissPerson, skinTones: [.mediumLight, .mediumDark]),
+            "🧑🏼‍❤️‍💋‍🧑🏿": EmojiWithSkinTones(baseEmoji: .personKissPerson, skinTones: [.mediumLight, .dark]),
+            "🧑🏽‍❤️‍💋‍🧑🏻": EmojiWithSkinTones(baseEmoji: .personKissPerson, skinTones: [.medium, .light]),
+            "🧑🏽‍❤️‍💋‍🧑🏼": EmojiWithSkinTones(baseEmoji: .personKissPerson, skinTones: [.medium, .mediumLight]),
+            "🧑🏽‍❤️‍💋‍🧑🏾": EmojiWithSkinTones(baseEmoji: .personKissPerson, skinTones: [.medium, .mediumDark]),
+            "🧑🏽‍❤️‍💋‍🧑🏿": EmojiWithSkinTones(baseEmoji: .personKissPerson, skinTones: [.medium, .dark]),
+            "🧑🏾‍❤️‍💋‍🧑🏻": EmojiWithSkinTones(baseEmoji: .personKissPerson, skinTones: [.mediumDark, .light]),
+            "🧑🏾‍❤️‍💋‍🧑🏼": EmojiWithSkinTones(baseEmoji: .personKissPerson, skinTones: [.mediumDark, .mediumLight]),
+            "🧑🏾‍❤️‍💋‍🧑🏽": EmojiWithSkinTones(baseEmoji: .personKissPerson, skinTones: [.mediumDark, .medium]),
+            "🧑🏾‍❤️‍💋‍🧑🏿": EmojiWithSkinTones(baseEmoji: .personKissPerson, skinTones: [.mediumDark, .dark]),
+            "🧑🏿‍❤️‍💋‍🧑🏻": EmojiWithSkinTones(baseEmoji: .personKissPerson, skinTones: [.dark, .light]),
+            "🧑🏿‍❤️‍💋‍🧑🏼": EmojiWithSkinTones(baseEmoji: .personKissPerson, skinTones: [.dark, .mediumLight]),
+            "🧑🏿‍❤️‍💋‍🧑🏽": EmojiWithSkinTones(baseEmoji: .personKissPerson, skinTones: [.dark, .medium]),
+            "🧑🏿‍❤️‍💋‍🧑🏾": EmojiWithSkinTones(baseEmoji: .personKissPerson, skinTones: [.dark, .mediumDark])
+        ]
+        return (lookup[rawValue] ?? EmojiWithSkinTones(unsupportedValue: rawValue))
+    }
+    
+    private static func emojiFrom56336(_ rawValue: String) -> EmojiWithSkinTones {
+        let lookup: [String: EmojiWithSkinTones] = [
+            "🏴󠁧󠁢󠁥󠁮󠁧󠁿": EmojiWithSkinTones(baseEmoji: .flagEngland, skinTones: nil),
+            "🏴󠁧󠁢󠁳󠁣󠁴󠁿": EmojiWithSkinTones(baseEmoji: .flagScotland, skinTones: nil),
+            "🏴󠁧󠁢󠁷󠁬󠁳󠁿": EmojiWithSkinTones(baseEmoji: .flagWales, skinTones: nil)
+        ]
+        return (lookup[rawValue] ?? EmojiWithSkinTones(unsupportedValue: rawValue))
+    }
 }
diff --git a/Session/Media Viewing & Editing/PhotoCaptureViewController.swift b/Session/Media Viewing & Editing/PhotoCaptureViewController.swift
index 3dd46b425..58dbe3767 100644
--- a/Session/Media Viewing & Editing/PhotoCaptureViewController.swift	
+++ b/Session/Media Viewing & Editing/PhotoCaptureViewController.swift	
@@ -275,14 +275,11 @@ class PhotoCaptureViewController: OWSViewController {
 
         let transformFromOrientation: CGAffineTransform
         switch captureOrientation {
-        case .portrait:
-            transformFromOrientation = .identity
-        case .portraitUpsideDown:
-            transformFromOrientation = CGAffineTransform(rotationAngle: .pi)
-        case .landscapeLeft:
-            transformFromOrientation = CGAffineTransform(rotationAngle: .halfPi)
-        case .landscapeRight:
-            transformFromOrientation = CGAffineTransform(rotationAngle: -1 * .halfPi)
+            case .portrait: transformFromOrientation = .identity
+            case .portraitUpsideDown: transformFromOrientation = CGAffineTransform(rotationAngle: .pi)
+            case .landscapeLeft: transformFromOrientation = CGAffineTransform(rotationAngle: .halfPi)
+            case .landscapeRight: transformFromOrientation = CGAffineTransform(rotationAngle: -1 * .halfPi)
+            @unknown default: transformFromOrientation = .identity
         }
 
         // Don't "unrotate" the switch camera icon if the front facing camera had been selected.
diff --git a/Session/Notifications/PushRegistrationManager.swift b/Session/Notifications/PushRegistrationManager.swift
index 6645428a5..0b9aa560b 100644
--- a/Session/Notifications/PushRegistrationManager.swift
+++ b/Session/Notifications/PushRegistrationManager.swift
@@ -59,8 +59,7 @@ public enum PushRegistrationError: Error {
             .tryFlatMap { _ -> AnyPublisher<(pushToken: String, voipToken: String), Error> in
                 #if targetEnvironment(simulator)
                 throw PushRegistrationError.pushNotSupported(description: "Push not supported on simulators")
-                #endif
-
+                #else
                 return self.registerForVanillaPushToken()
                     .flatMap { vanillaPushToken -> AnyPublisher<(pushToken: String, voipToken: String), Error> in
                         self.registerForVoipPushToken()
@@ -68,6 +67,7 @@ public enum PushRegistrationError: Error {
                             .eraseToAnyPublisher()
                     }
                     .eraseToAnyPublisher()
+                #endif
             }
             .eraseToAnyPublisher()
     }
diff --git a/SessionMessagingKit/Calls/WebRTCSession.swift b/SessionMessagingKit/Calls/WebRTCSession.swift
index 9db449481..ab99e1080 100644
--- a/SessionMessagingKit/Calls/WebRTCSession.swift
+++ b/SessionMessagingKit/Calls/WebRTCSession.swift
@@ -160,9 +160,7 @@ public final class WebRTCSession : NSObject, RTCPeerConnectionDelegate {
         return Deferred {
             Future<Void, Error> { [weak self] resolver in
                 self?.peerConnection?.offer(for: mediaConstraints) { sdp, error in
-                    if let error = error {
-                        return
-                    }
+                    guard error == nil else { return }
                     
                     guard let sdp: RTCSessionDescription = self?.correctSessionDescription(sdp: sdp) else {
                         preconditionFailure()
diff --git a/SessionMessagingKit/Database/Models/SessionThread.swift b/SessionMessagingKit/Database/Models/SessionThread.swift
index 414c04ba4..fcb375fcf 100644
--- a/SessionMessagingKit/Database/Models/SessionThread.swift
+++ b/SessionMessagingKit/Database/Models/SessionThread.swift
@@ -61,7 +61,7 @@ public struct SessionThread: Codable, Identifiable, Equatable, FetchableRecord,
     public let shouldBeVisible: Bool
     
     /// A flag indicating whether the thread is pinned
-    @available(*, unavailable, message: "use 'pinnedPriority' instead")
+//    @available(*, unavailable, message: "use 'pinnedPriority' instead")
     public let isPinned: Bool = false
     
     /// The value the user started entering into the input field before they left the conversation screen
diff --git a/SessionMessagingKit/Protos/Generated/SNProto.swift b/SessionMessagingKit/Protos/Generated/SNProto.swift
index 72e4ca517..e164c4827 100644
--- a/SessionMessagingKit/Protos/Generated/SNProto.swift
+++ b/SessionMessagingKit/Protos/Generated/SNProto.swift
@@ -165,12 +165,12 @@ public enum SNProtoError: Error {
 
     fileprivate class func parseProto(_ proto: SessionProtos_Envelope) throws -> SNProtoEnvelope {
         guard proto.hasType else {
-            throw SNProtoError.invalidProtobuf(description: "\(logTag) missing required field: type")
+            throw SNProtoError.invalidProtobuf(description: "\(String(describing: logTag)) missing required field: type")
         }
         let type = SNProtoEnvelopeTypeWrap(proto.type)
 
         guard proto.hasTimestamp else {
-            throw SNProtoError.invalidProtobuf(description: "\(logTag) missing required field: timestamp")
+            throw SNProtoError.invalidProtobuf(description: "\(String(describing: logTag)) missing required field: timestamp")
         }
         let timestamp = proto.timestamp
 
@@ -298,12 +298,12 @@ extension SNProtoEnvelope.SNProtoEnvelopeBuilder {
 
     fileprivate class func parseProto(_ proto: SessionProtos_TypingMessage) throws -> SNProtoTypingMessage {
         guard proto.hasTimestamp else {
-            throw SNProtoError.invalidProtobuf(description: "\(logTag) missing required field: timestamp")
+            throw SNProtoError.invalidProtobuf(description: "\(String(describing: logTag)) missing required field: timestamp")
         }
         let timestamp = proto.timestamp
 
         guard proto.hasAction else {
-            throw SNProtoError.invalidProtobuf(description: "\(logTag) missing required field: action")
+            throw SNProtoError.invalidProtobuf(description: "\(String(describing: logTag)) missing required field: action")
         }
         let action = SNProtoTypingMessageActionWrap(proto.action)
 
@@ -410,12 +410,12 @@ extension SNProtoTypingMessage.SNProtoTypingMessageBuilder {
 
     fileprivate class func parseProto(_ proto: SessionProtos_UnsendRequest) throws -> SNProtoUnsendRequest {
         guard proto.hasTimestamp else {
-            throw SNProtoError.invalidProtobuf(description: "\(logTag) missing required field: timestamp")
+            throw SNProtoError.invalidProtobuf(description: "\(String(describing: logTag)) missing required field: timestamp")
         }
         let timestamp = proto.timestamp
 
         guard proto.hasAuthor else {
-            throw SNProtoError.invalidProtobuf(description: "\(logTag) missing required field: author")
+            throw SNProtoError.invalidProtobuf(description: "\(String(describing: logTag)) missing required field: author")
         }
         let author = proto.author
 
@@ -541,7 +541,7 @@ extension SNProtoUnsendRequest.SNProtoUnsendRequestBuilder {
 
     fileprivate class func parseProto(_ proto: SessionProtos_MessageRequestResponse) throws -> SNProtoMessageRequestResponse {
         guard proto.hasIsApproved else {
-            throw SNProtoError.invalidProtobuf(description: "\(logTag) missing required field: isApproved")
+            throw SNProtoError.invalidProtobuf(description: "\(String(describing: logTag)) missing required field: isApproved")
         }
         let isApproved = proto.isApproved
 
@@ -961,12 +961,12 @@ extension SNProtoContent.SNProtoContentBuilder {
 
     fileprivate class func parseProto(_ proto: SessionProtos_CallMessage) throws -> SNProtoCallMessage {
         guard proto.hasType else {
-            throw SNProtoError.invalidProtobuf(description: "\(logTag) missing required field: type")
+            throw SNProtoError.invalidProtobuf(description: "\(String(describing: logTag)) missing required field: type")
         }
         let type = SNProtoCallMessageTypeWrap(proto.type)
 
         guard proto.hasUuid else {
-            throw SNProtoError.invalidProtobuf(description: "\(logTag) missing required field: uuid")
+            throw SNProtoError.invalidProtobuf(description: "\(String(describing: logTag)) missing required field: uuid")
         }
         let uuid = proto.uuid
 
@@ -1073,12 +1073,12 @@ extension SNProtoCallMessage.SNProtoCallMessageBuilder {
 
     fileprivate class func parseProto(_ proto: SessionProtos_KeyPair) throws -> SNProtoKeyPair {
         guard proto.hasPublicKey else {
-            throw SNProtoError.invalidProtobuf(description: "\(logTag) missing required field: publicKey")
+            throw SNProtoError.invalidProtobuf(description: "\(String(describing: logTag)) missing required field: publicKey")
         }
         let publicKey = proto.publicKey
 
         guard proto.hasPrivateKey else {
-            throw SNProtoError.invalidProtobuf(description: "\(logTag) missing required field: privateKey")
+            throw SNProtoError.invalidProtobuf(description: "\(String(describing: logTag)) missing required field: privateKey")
         }
         let privateKey = proto.privateKey
 
@@ -1211,7 +1211,7 @@ extension SNProtoKeyPair.SNProtoKeyPairBuilder {
 
     fileprivate class func parseProto(_ proto: SessionProtos_DataExtractionNotification) throws -> SNProtoDataExtractionNotification {
         guard proto.hasType else {
-            throw SNProtoError.invalidProtobuf(description: "\(logTag) missing required field: type")
+            throw SNProtoError.invalidProtobuf(description: "\(String(describing: logTag)) missing required field: type")
         }
         let type = SNProtoDataExtractionNotificationTypeWrap(proto.type)
 
@@ -1620,12 +1620,12 @@ extension SNProtoDataMessageQuoteQuotedAttachment.SNProtoDataMessageQuoteQuotedA
 
     fileprivate class func parseProto(_ proto: SessionProtos_DataMessage.Quote) throws -> SNProtoDataMessageQuote {
         guard proto.hasID else {
-            throw SNProtoError.invalidProtobuf(description: "\(logTag) missing required field: id")
+            throw SNProtoError.invalidProtobuf(description: "\(String(describing: logTag)) missing required field: id")
         }
         let id = proto.id
 
         guard proto.hasAuthor else {
-            throw SNProtoError.invalidProtobuf(description: "\(logTag) missing required field: author")
+            throw SNProtoError.invalidProtobuf(description: "\(String(describing: logTag)) missing required field: author")
         }
         let author = proto.author
 
@@ -1755,7 +1755,7 @@ extension SNProtoDataMessageQuote.SNProtoDataMessageQuoteBuilder {
 
     fileprivate class func parseProto(_ proto: SessionProtos_DataMessage.Preview) throws -> SNProtoDataMessagePreview {
         guard proto.hasURL else {
-            throw SNProtoError.invalidProtobuf(description: "\(logTag) missing required field: url")
+            throw SNProtoError.invalidProtobuf(description: "\(String(describing: logTag)) missing required field: url")
         }
         let url = proto.url
 
@@ -1914,17 +1914,17 @@ extension SNProtoDataMessagePreview.SNProtoDataMessagePreviewBuilder {
 
     fileprivate class func parseProto(_ proto: SessionProtos_DataMessage.Reaction) throws -> SNProtoDataMessageReaction {
         guard proto.hasID else {
-            throw SNProtoError.invalidProtobuf(description: "\(logTag) missing required field: id")
+            throw SNProtoError.invalidProtobuf(description: "\(String(describing: logTag)) missing required field: id")
         }
         let id = proto.id
 
         guard proto.hasAuthor else {
-            throw SNProtoError.invalidProtobuf(description: "\(logTag) missing required field: author")
+            throw SNProtoError.invalidProtobuf(description: "\(String(describing: logTag)) missing required field: author")
         }
         let author = proto.author
 
         guard proto.hasAction else {
-            throw SNProtoError.invalidProtobuf(description: "\(logTag) missing required field: action")
+            throw SNProtoError.invalidProtobuf(description: "\(String(describing: logTag)) missing required field: action")
         }
         let action = SNProtoDataMessageReactionActionWrap(proto.action)
 
@@ -2032,12 +2032,12 @@ extension SNProtoDataMessageReaction.SNProtoDataMessageReactionBuilder {
 
     fileprivate class func parseProto(_ proto: SessionProtos_DataMessage.OpenGroupInvitation) throws -> SNProtoDataMessageOpenGroupInvitation {
         guard proto.hasURL else {
-            throw SNProtoError.invalidProtobuf(description: "\(logTag) missing required field: url")
+            throw SNProtoError.invalidProtobuf(description: "\(String(describing: logTag)) missing required field: url")
         }
         let url = proto.url
 
         guard proto.hasName else {
-            throw SNProtoError.invalidProtobuf(description: "\(logTag) missing required field: name")
+            throw SNProtoError.invalidProtobuf(description: "\(String(describing: logTag)) missing required field: name")
         }
         let name = proto.name
 
@@ -2144,12 +2144,12 @@ extension SNProtoDataMessageOpenGroupInvitation.SNProtoDataMessageOpenGroupInvit
 
     fileprivate class func parseProto(_ proto: SessionProtos_DataMessage.ClosedGroupControlMessage.KeyPairWrapper) throws -> SNProtoDataMessageClosedGroupControlMessageKeyPairWrapper {
         guard proto.hasPublicKey else {
-            throw SNProtoError.invalidProtobuf(description: "\(logTag) missing required field: publicKey")
+            throw SNProtoError.invalidProtobuf(description: "\(String(describing: logTag)) missing required field: publicKey")
         }
         let publicKey = proto.publicKey
 
         guard proto.hasEncryptedKeyPair else {
-            throw SNProtoError.invalidProtobuf(description: "\(logTag) missing required field: encryptedKeyPair")
+            throw SNProtoError.invalidProtobuf(description: "\(String(describing: logTag)) missing required field: encryptedKeyPair")
         }
         let encryptedKeyPair = proto.encryptedKeyPair
 
@@ -2387,7 +2387,7 @@ extension SNProtoDataMessageClosedGroupControlMessageKeyPairWrapper.SNProtoDataM
 
     fileprivate class func parseProto(_ proto: SessionProtos_DataMessage.ClosedGroupControlMessage) throws -> SNProtoDataMessageClosedGroupControlMessage {
         guard proto.hasType else {
-            throw SNProtoError.invalidProtobuf(description: "\(logTag) missing required field: type")
+            throw SNProtoError.invalidProtobuf(description: "\(String(describing: logTag)) missing required field: type")
         }
         let type = SNProtoDataMessageClosedGroupControlMessageTypeWrap(proto.type)
 
@@ -3076,12 +3076,12 @@ extension SNProtoConfigurationMessageClosedGroup.SNProtoConfigurationMessageClos
 
     fileprivate class func parseProto(_ proto: SessionProtos_ConfigurationMessage.Contact) throws -> SNProtoConfigurationMessageContact {
         guard proto.hasPublicKey else {
-            throw SNProtoError.invalidProtobuf(description: "\(logTag) missing required field: publicKey")
+            throw SNProtoError.invalidProtobuf(description: "\(String(describing: logTag)) missing required field: publicKey")
         }
         let publicKey = proto.publicKey
 
         guard proto.hasName else {
-            throw SNProtoError.invalidProtobuf(description: "\(logTag) missing required field: name")
+            throw SNProtoError.invalidProtobuf(description: "\(String(describing: logTag)) missing required field: name")
         }
         let name = proto.name
 
@@ -3396,7 +3396,7 @@ extension SNProtoConfigurationMessage.SNProtoConfigurationMessageBuilder {
 
     fileprivate class func parseProto(_ proto: SessionProtos_ReceiptMessage) throws -> SNProtoReceiptMessage {
         guard proto.hasType else {
-            throw SNProtoError.invalidProtobuf(description: "\(logTag) missing required field: type")
+            throw SNProtoError.invalidProtobuf(description: "\(String(describing: logTag)) missing required field: type")
         }
         let type = SNProtoReceiptMessageTypeWrap(proto.type)
 
@@ -3686,7 +3686,7 @@ extension SNProtoReceiptMessage.SNProtoReceiptMessageBuilder {
 
     fileprivate class func parseProto(_ proto: SessionProtos_AttachmentPointer) throws -> SNProtoAttachmentPointer {
         guard proto.hasID else {
-            throw SNProtoError.invalidProtobuf(description: "\(logTag) missing required field: id")
+            throw SNProtoError.invalidProtobuf(description: "\(String(describing: logTag)) missing required field: id")
         }
         let id = proto.id
 
@@ -3828,17 +3828,17 @@ extension SNProtoAttachmentPointer.SNProtoAttachmentPointerBuilder {
 
     fileprivate class func parseProto(_ proto: SessionProtos_SharedConfigMessage) throws -> SNProtoSharedConfigMessage {
         guard proto.hasKind else {
-            throw SNProtoError.invalidProtobuf(description: "\(logTag) missing required field: kind")
+            throw SNProtoError.invalidProtobuf(description: "\(String(describing: logTag)) missing required field: kind")
         }
         let kind = SNProtoSharedConfigMessageKindWrap(proto.kind)
 
         guard proto.hasSeqno else {
-            throw SNProtoError.invalidProtobuf(description: "\(logTag) missing required field: seqno")
+            throw SNProtoError.invalidProtobuf(description: "\(String(describing: logTag)) missing required field: seqno")
         }
         let seqno = proto.seqno
 
         guard proto.hasData else {
-            throw SNProtoError.invalidProtobuf(description: "\(logTag) missing required field: data")
+            throw SNProtoError.invalidProtobuf(description: "\(String(describing: logTag)) missing required field: data")
         }
         let data = proto.data
 
diff --git a/SessionMessagingKit/Protos/Generated/WebSocketProto.swift b/SessionMessagingKit/Protos/Generated/WebSocketProto.swift
index c886ccc95..63b9e8dc2 100644
--- a/SessionMessagingKit/Protos/Generated/WebSocketProto.swift
+++ b/SessionMessagingKit/Protos/Generated/WebSocketProto.swift
@@ -123,17 +123,17 @@ public enum WebSocketProtoError: Error {
 
     fileprivate class func parseProto(_ proto: WebSocketProtos_WebSocketRequestMessage) throws -> WebSocketProtoWebSocketRequestMessage {
         guard proto.hasVerb else {
-            throw WebSocketProtoError.invalidProtobuf(description: "\(logTag) missing required field: verb")
+            throw WebSocketProtoError.invalidProtobuf(description: "\(String(describing: logTag)) missing required field: verb")
         }
         let verb = proto.verb
 
         guard proto.hasPath else {
-            throw WebSocketProtoError.invalidProtobuf(description: "\(logTag) missing required field: path")
+            throw WebSocketProtoError.invalidProtobuf(description: "\(String(describing: logTag)) missing required field: path")
         }
         let path = proto.path
 
         guard proto.hasRequestID else {
-            throw WebSocketProtoError.invalidProtobuf(description: "\(logTag) missing required field: requestID")
+            throw WebSocketProtoError.invalidProtobuf(description: "\(String(describing: logTag)) missing required field: requestID")
         }
         let requestID = proto.requestID
 
@@ -290,12 +290,12 @@ extension WebSocketProtoWebSocketRequestMessage.WebSocketProtoWebSocketRequestMe
 
     fileprivate class func parseProto(_ proto: WebSocketProtos_WebSocketResponseMessage) throws -> WebSocketProtoWebSocketResponseMessage {
         guard proto.hasRequestID else {
-            throw WebSocketProtoError.invalidProtobuf(description: "\(logTag) missing required field: requestID")
+            throw WebSocketProtoError.invalidProtobuf(description: "\(String(describing: logTag)) missing required field: requestID")
         }
         let requestID = proto.requestID
 
         guard proto.hasStatus else {
-            throw WebSocketProtoError.invalidProtobuf(description: "\(logTag) missing required field: status")
+            throw WebSocketProtoError.invalidProtobuf(description: "\(String(describing: logTag)) missing required field: status")
         }
         let status = proto.status
 
@@ -439,7 +439,7 @@ extension WebSocketProtoWebSocketResponseMessage.WebSocketProtoWebSocketResponse
 
     fileprivate class func parseProto(_ proto: WebSocketProtos_WebSocketMessage) throws -> WebSocketProtoWebSocketMessage {
         guard proto.hasType else {
-            throw WebSocketProtoError.invalidProtobuf(description: "\(logTag) missing required field: type")
+            throw WebSocketProtoError.invalidProtobuf(description: "\(String(describing: logTag)) missing required field: type")
         }
         let type = WebSocketProtoWebSocketMessageTypeWrap(proto.type)
 
diff --git a/SessionMessagingKit/Sending & Receiving/Message Handling/MessageReceiver+VisibleMessages.swift b/SessionMessagingKit/Sending & Receiving/Message Handling/MessageReceiver+VisibleMessages.swift
index 520002125..508d53546 100644
--- a/SessionMessagingKit/Sending & Receiving/Message Handling/MessageReceiver+VisibleMessages.swift	
+++ b/SessionMessagingKit/Sending & Receiving/Message Handling/MessageReceiver+VisibleMessages.swift	
@@ -88,11 +88,9 @@ extension MessageReceiver {
             // Need to check if the blinded id matches for open groups
             switch senderSessionId.prefix {
                 case .blinded15, .blinded25:
-                    let sodium: Sodium = Sodium()
-                    
                     guard
                         let userEdKeyPair: KeyPair = Identity.fetchUserEd25519KeyPair(db),
-                        let blindedKeyPair: KeyPair = try? dependencies.crypto.generate(
+                        let blindedKeyPair: KeyPair = dependencies.crypto.generate(
                             .blindedKeyPair(
                                 serverPublicKey: openGroup.publicKey,
                                 edKeyPair: userEdKeyPair,
diff --git a/SessionMessagingKit/Sending & Receiving/Notification+MessageReceiver.swift b/SessionMessagingKit/Sending & Receiving/Notification+MessageReceiver.swift
index df890e31d..96fdfb9d1 100644
--- a/SessionMessagingKit/Sending & Receiving/Notification+MessageReceiver.swift	
+++ b/SessionMessagingKit/Sending & Receiving/Notification+MessageReceiver.swift	
@@ -1,6 +1,7 @@
 // Copyright © 2022 Rangeproof Pty Ltd. All rights reserved.
 
 import Foundation
+import SessionUtilitiesKit
 
 public extension Notification.Name {
     static let missedCall = Notification.Name("missedCall")
diff --git a/SessionUtilitiesKit/Networking/HTTP.swift b/SessionUtilitiesKit/Networking/HTTP.swift
index e22a80af6..d209456c1 100644
--- a/SessionUtilitiesKit/Networking/HTTP.swift
+++ b/SessionUtilitiesKit/Networking/HTTP.swift
@@ -4,6 +4,11 @@ import Foundation
 import Combine
 
 public enum HTTP {
+    private struct Certificates {
+        let isValid: Bool
+        let certificates: [SecCertificate]
+    }
+    
     private static let seedNodeURLSession = URLSession(configuration: .ephemeral, delegate: seedNodeURLSessionDelegate, delegateQueue: nil)
     private static let seedNodeURLSessionDelegate = SeedNodeURLSessionDelegateImplementation()
     private static let snodeURLSession = URLSession(configuration: .ephemeral, delegate: snodeURLSessionDelegate, delegateQueue: nil)
@@ -14,22 +19,21 @@ public enum HTTP {
     /// **Note:** These certificates will need to be regenerated and replaced at the start of April 2025, iOS has a restriction after iOS 13
     /// where certificates can have a maximum lifetime of 825 days (https://support.apple.com/en-au/HT210176) as a result we
     /// can't use the 10 year certificates that the other platforms use
-    private static let storageSeed1Cert: SecCertificate = {
-        let path = Bundle.main.path(forResource: "seed1-2023-2y", ofType: "der")!
-        let data = try! Data(contentsOf: URL(fileURLWithPath: path))
-        return SecCertificateCreateWithData(nil, data as CFData)!
-    }()
-
-    private static let storageSeed2Cert: SecCertificate = {
-        let path = Bundle.main.path(forResource: "seed2-2023-2y", ofType: "der")!
-        let data = try! Data(contentsOf: URL(fileURLWithPath: path))
-        return SecCertificateCreateWithData(nil, data as CFData)!
-    }()
-
-    private static let storageSeed3Cert: SecCertificate = {
-        let path = Bundle.main.path(forResource: "seed3-2023-2y", ofType: "der")!
-        let data = try! Data(contentsOf: URL(fileURLWithPath: path))
-        return SecCertificateCreateWithData(nil, data as CFData)!
+    private static let storageSeedCertificates: Atomic<Certificates> = {
+        let certFileNames: [String] = [
+            "seed1-2023-2y",
+            "seed2-2023-2y",
+            "seed3-2023-2y"
+        ]
+        let paths: [String] = certFileNames.compactMap { Bundle.main.path(forResource: $0, ofType: "der") }
+        let certData: [Data] = paths.compactMap { try? Data(contentsOf: URL(fileURLWithPath: $0)) }
+        let certificates: [SecCertificate] = certData.compactMap { SecCertificateCreateWithData(nil, $0 as CFData) }
+        
+        guard certificates.count == certFileNames.count else {
+            return Atomic(Certificates(isValid: false, certificates: []))
+        }
+        
+        return Atomic(Certificates(isValid: true, certificates: certificates))
     }()
     
     // MARK: - Settings
@@ -41,12 +45,15 @@ public enum HTTP {
     private final class SeedNodeURLSessionDelegateImplementation : NSObject, URLSessionDelegate {
 
         func urlSession(_ session: URLSession, didReceive challenge: URLAuthenticationChallenge, completionHandler: @escaping (URLSession.AuthChallengeDisposition, URLCredential?) -> Void) {
+            guard HTTP.storageSeedCertificates.wrappedValue.isValid else {
+                SNLog("Failed to set load seed node certificates.")
+                return completionHandler(.cancelAuthenticationChallenge, nil)
+            }
             guard let trust = challenge.protectionSpace.serverTrust else {
                 return completionHandler(.cancelAuthenticationChallenge, nil)
             }
             // Mark the seed node certificates as trusted
-            let certificates = [ storageSeed1Cert, storageSeed2Cert, storageSeed3Cert ]
-            guard SecTrustSetAnchorCertificates(trust, certificates as CFArray) == errSecSuccess else {
+            guard SecTrustSetAnchorCertificates(trust, HTTP.storageSeedCertificates.wrappedValue.certificates as CFArray) == errSecSuccess else {
                 SNLog("Failed to set seed node certificates.")
                 return completionHandler(.cancelAuthenticationChallenge, nil)
             }