[stdlib] Make the rest of the scalar properties native (#40233)

* Factor out the scalar bit array index mechanism

* Implement native numeric scalar properties

* Implement native scalar name aliases

* Implement native scalar mappings

* Implement native scalar names

* Implement native scalar age

* Implement native scalar general category

* Address Michael's and others comments

fix special mappings

fix bug

stdlib/public/SwiftShims/UnicodeData.h

@@ -21,6 +21,26 @@
 extern "C" {
 #endif
 
+#define SWIFT_STDLIB_LARGEST_NAME_COUNT 88
+
+//===----------------------------------------------------------------------===//
+// Utilities
+//===----------------------------------------------------------------------===//
+
+__swift_intptr_t _swift_stdlib_getMphIdx(__swift_uint32_t scalar,
+                                         __swift_intptr_t levels,
+                                         const __swift_uint64_t * const *keys,
+                                         const __swift_uint16_t * const *ranks,
+                                         const __swift_uint16_t * const sizes);
+
+__swift_intptr_t _swift_stdlib_getScalarBitArrayIdx(__swift_uint32_t scalar,
+                                              const __swift_uint64_t *bitArrays,
+                                              const __swift_uint16_t *ranks);
+
+//===----------------------------------------------------------------------===//
+// Normalization
+//===----------------------------------------------------------------------===//
+
 SWIFT_RUNTIME_STDLIB_INTERNAL
 __swift_uint16_t _swift_stdlib_getNormData(__swift_uint32_t scalar);
 
@@ -34,19 +54,50 @@ SWIFT_RUNTIME_STDLIB_INTERNAL
 __swift_uint32_t _swift_stdlib_getComposition(__swift_uint32_t x,
                                               __swift_uint32_t y);
 
-SWIFT_RUNTIME_STDLIB_INTERNAL
-__swift_intptr_t _swift_stdlib_getMphIdx(__swift_uint32_t scalar,
-                                         __swift_intptr_t levels,
-                                         const __swift_uint64_t * const *keys,
-                                         const __swift_uint16_t * const *ranks,
-                                         const __swift_uint16_t * const sizes);
+//===----------------------------------------------------------------------===//
+// Grapheme Breaking
+//===----------------------------------------------------------------------===//
+
 
 SWIFT_RUNTIME_STDLIB_INTERNAL
 __swift_uint8_t _swift_stdlib_getGraphemeBreakProperty(__swift_uint32_t scalar);
 
+//===----------------------------------------------------------------------===//
+// Unicode.Scalar.Properties
+//===----------------------------------------------------------------------===//
+
 SWIFT_RUNTIME_STDLIB_INTERNAL
 __swift_uint64_t _swift_stdlib_getBinaryProperties(__swift_uint32_t scalar);
 
+SWIFT_RUNTIME_STDLIB_INTERNAL
+__swift_uint8_t _swift_stdlib_getNumericType(__swift_uint32_t scalar);
+
+SWIFT_RUNTIME_STDLIB_INTERNAL
+double _swift_stdlib_getNumericValue(__swift_uint32_t scalar);
+
+SWIFT_RUNTIME_STDLIB_INTERNAL
+const char *_swift_stdlib_getNameAlias(__swift_uint32_t scalar);
+
+SWIFT_RUNTIME_STDLIB_INTERNAL
+__swift_int32_t _swift_stdlib_getMapping(__swift_uint32_t scalar,
+                                         __swift_uint8_t mapping);
+
+SWIFT_RUNTIME_STDLIB_INTERNAL
+const __swift_uint8_t *_swift_stdlib_getSpecialMapping(__swift_uint32_t scalar,
+                                                       __swift_uint8_t mapping,
+                                                       __swift_intptr_t *length);
+
+SWIFT_RUNTIME_STDLIB_INTERNAL
+__swift_intptr_t _swift_stdlib_getScalarName(__swift_uint32_t scalar,
+                                             __swift_uint8_t *buffer,
+                                             __swift_intptr_t capacity);
+
+SWIFT_RUNTIME_STDLIB_INTERNAL
+__swift_uint16_t _swift_stdlib_getAge(__swift_uint32_t scalar);
+
+SWIFT_RUNTIME_STDLIB_INTERNAL
+__swift_uint8_t _swift_stdlib_getGeneralCategory(__swift_uint32_t scalar);
+
 #ifdef __cplusplus
 } // extern "C"
 #endif

stdlib/public/SwiftShims/UnicodeShims.h

@@ -29,16 +29,6 @@
 extern "C" {
 #endif
 
-SWIFT_RUNTIME_STDLIB_API
-__swift_int32_t _swift_stdlib_unicode_strToUpper(
-  __swift_uint16_t *Destination, __swift_int32_t DestinationCapacity,
-  const __swift_uint16_t *Source, __swift_int32_t SourceLength);
-
-SWIFT_RUNTIME_STDLIB_API
-__swift_int32_t _swift_stdlib_unicode_strToLower(
-  __swift_uint16_t *Destination, __swift_int32_t DestinationCapacity,
-  const __swift_uint16_t *Source, __swift_int32_t SourceLength);
-
 typedef enum __swift_stdlib_UProperty {
   __swift_stdlib_UCHAR_GENERAL_CATEGORY = 0x1005,
   __swift_stdlib_UCHAR_NUMERIC_TYPE = 0x1009,
@@ -264,16 +254,6 @@ typedef enum __swift_stdlib_UCharNameChoice {
 #endif
 } __swift_stdlib_UCharNameChoice;
 
-typedef enum __swift_stdlib_UNumericType {
-  __swift_stdlib_U_NT_NONE,
-  __swift_stdlib_U_NT_DECIMAL,
-  __swift_stdlib_U_NT_DIGIT,
-  __swift_stdlib_U_NT_NUMERIC,
-#ifndef U_HIDE_DEPRECATED_API
-  __swift_stdlib_U_NT_COUNT
-#endif
-} __swift_stdlib_UNumericType;
-
 typedef struct __swift_stdlib_UBreakIterator __swift_stdlib_UBreakIterator;
 typedef struct __swift_stdlib_UText __swift_stdlib_UText;
 typedef __swift_int8_t __swift_stdlib_UBool;
@@ -291,44 +271,6 @@ typedef __swift_uint16_t __swift_stdlib_UChar;
 typedef __swift_uint8_t
     __swift_stdlib_UVersionInfo[__SWIFT_STDLIB_U_MAX_VERSION_LENGTH];
 
-SWIFT_RUNTIME_STDLIB_API
-void __swift_stdlib_u_charAge(
-    __swift_stdlib_UChar32, __swift_stdlib_UVersionInfo _Nonnull);
-
-SWIFT_RUNTIME_STDLIB_API
-__swift_int32_t
-    __swift_stdlib_u_getIntPropertyValue(__swift_stdlib_UChar32,
-                                         __swift_stdlib_UProperty);
-
-SWIFT_RUNTIME_STDLIB_API
-__swift_int32_t __swift_stdlib_u_charName(
-    __swift_stdlib_UChar32 code, __swift_stdlib_UCharNameChoice nameChoice,
-    char *_Nullable buffer, __swift_int32_t bufferLength,
-    __swift_stdlib_UErrorCode *pErrorCode);
-
-SWIFT_RUNTIME_STDLIB_API
-__swift_int32_t __swift_stdlib_u_strToLower(
-    __swift_stdlib_UChar *dest, __swift_int32_t destCapacity,
-    const __swift_stdlib_UChar *src, __swift_int32_t srcLength,
-    const char *_Nullable locale, __swift_stdlib_UErrorCode *pErrorCode);
-
-SWIFT_RUNTIME_STDLIB_API
-__swift_int32_t __swift_stdlib_u_strToTitle(
-    __swift_stdlib_UChar *dest, __swift_int32_t destCapacity,
-    const __swift_stdlib_UChar *src, __swift_int32_t srcLength,
-    __swift_stdlib_UBreakIterator *_Nullable titleIter,
-    const char *_Nullable locale, __swift_stdlib_UErrorCode *pErrorCode);
-
-SWIFT_RUNTIME_STDLIB_API
-__swift_int32_t __swift_stdlib_u_strToUpper(
-    __swift_stdlib_UChar *dest, __swift_int32_t destCapacity,
-    const __swift_stdlib_UChar *src, __swift_int32_t srcLength,
-    const char *_Nullable locale, __swift_stdlib_UErrorCode *pErrorCode);
-
-SWIFT_RUNTIME_STDLIB_API
-double __swift_stdlib_u_getNumericValue(__swift_stdlib_UChar32 c);
-
-
 #ifdef __cplusplus
 } // extern "C"
 #endif

stdlib/public/core/String.swift

@@ -849,42 +849,15 @@ extension String {
       }
     }
 
-    // TODO(String performance): Try out incremental case-conversion rather than
-    // make UTF-16 array beforehand
-    let codeUnits = Array(self.utf16).withUnsafeBufferPointer {
-      (uChars: UnsafeBufferPointer<UInt16>) -> Array<UInt16> in
-      var length: Int = 0
-      let result = Array<UInt16>(unsafeUninitializedCapacity: uChars.count) {
-        buffer, initializedCount in
-        var error = __swift_stdlib_U_ZERO_ERROR
-        length = Int(truncatingIfNeeded:
-          __swift_stdlib_u_strToLower(
-            buffer.baseAddress._unsafelyUnwrappedUnchecked,
-            Int32(buffer.count),
-            uChars.baseAddress._unsafelyUnwrappedUnchecked,
-            Int32(uChars.count),
-            "",
-            &error))
-        initializedCount = min(length, uChars.count)
-      }
-      if length > uChars.count {
-        var error = __swift_stdlib_U_ZERO_ERROR
-        return Array<UInt16>(unsafeUninitializedCapacity: length) {
-          buffer, initializedCount in
-          __swift_stdlib_u_strToLower(
-            buffer.baseAddress._unsafelyUnwrappedUnchecked,
-            Int32(buffer.count),
-            uChars.baseAddress._unsafelyUnwrappedUnchecked,
-            Int32(uChars.count),
-            "",
-            &error)
-          initializedCount = length
-        }
+    var result = ""
+    result.reserveCapacity(utf8.count)
+
+    for scalar in unicodeScalars {
+      result += scalar.properties.lowercaseMapping
     }
+
     return result
   }
-    return codeUnits.withUnsafeBufferPointer { String._uncheckedFromUTF16($0) }
-  }
 
   /// Returns an uppercase version of the string.
   ///
@@ -910,42 +883,15 @@ extension String {
       }
     }
 
-    // TODO(String performance): Try out incremental case-conversion rather than
-    // make UTF-16 array beforehand
-    let codeUnits = Array(self.utf16).withUnsafeBufferPointer {
-      (uChars: UnsafeBufferPointer<UInt16>) -> Array<UInt16> in
-      var length: Int = 0
-      let result = Array<UInt16>(unsafeUninitializedCapacity: uChars.count) {
-        buffer, initializedCount in
-        var err = __swift_stdlib_U_ZERO_ERROR
-        length = Int(truncatingIfNeeded:
-          __swift_stdlib_u_strToUpper(
-            buffer.baseAddress._unsafelyUnwrappedUnchecked,
-            Int32(buffer.count),
-            uChars.baseAddress._unsafelyUnwrappedUnchecked,
-            Int32(uChars.count),
-            "",
-            &err))
-        initializedCount = min(length, uChars.count)
-      }
-      if length > uChars.count {
-        var err = __swift_stdlib_U_ZERO_ERROR
-        return Array<UInt16>(unsafeUninitializedCapacity: length) {
-          buffer, initializedCount in
-          __swift_stdlib_u_strToUpper(
-            buffer.baseAddress._unsafelyUnwrappedUnchecked,
-            Int32(buffer.count),
-            uChars.baseAddress._unsafelyUnwrappedUnchecked,
-            Int32(uChars.count),
-            "",
-            &err)
-          initializedCount = length
-        }
+    var result = ""
+    result.reserveCapacity(utf8.count)
+
+    for scalar in unicodeScalars {
+      result += scalar.properties.uppercaseMapping
     }
+
     return result
   }
-    return codeUnits.withUnsafeBufferPointer { String._uncheckedFromUTF16($0) }
-  }
 
   /// Creates an instance from the description of a given
   /// `LosslessStringConvertible` instance.

stdlib/public/core/UnicodeScalarProperties.swift

@@ -26,11 +26,6 @@ extension Unicode.Scalar {
     internal init(_ scalar: Unicode.Scalar) {
       self._scalar = scalar
     }
-
-    // Provide the value as UChar32 to make calling the ICU APIs cleaner
-    internal var icuValue: __swift_stdlib_UChar32 {
-      return __swift_stdlib_UChar32(bitPattern: self._scalar._value)
-    }
   }
 
   /// Properties of this scalar defined by the Unicode standard.
@@ -748,69 +743,50 @@ extension Unicode.Scalar.Properties {
 
 /// Case mapping properties.
 extension Unicode.Scalar.Properties {
-  // The type of ICU case conversion functions.
-  internal typealias _U_StrToX = (
-    /* dest */ UnsafeMutablePointer<__swift_stdlib_UChar>,
-    /* destCapacity */ Int32,
-    /* src */ UnsafePointer<__swift_stdlib_UChar>,
-    /* srcLength */ Int32,
-    /* locale */ UnsafePointer<Int8>,
-    /* pErrorCode */ UnsafeMutablePointer<__swift_stdlib_UErrorCode>
-  ) -> Int32
+  fileprivate struct _CaseMapping {
+    let rawValue: UInt8
 
-  /// Applies the given ICU string mapping to the scalar.
-  ///
-  /// This function attempts first to write the mapping into a stack-based
-  /// UTF-16 buffer capable of holding 16 code units, which should be enough for
-  /// all current case mappings. In the event more space is needed, it will be
-  /// allocated on the heap.
-  internal func _applyMapping(_ u_strTo: _U_StrToX) -> String {
-    // Allocate 16 code units on the stack.
-    var fixedArray = _FixedArray16<UInt16>(allZeros: ())
-    let count: Int = fixedArray.withUnsafeMutableBufferPointer { buf in
-      return _scalar.withUTF16CodeUnits { utf16 in
-        var err = __swift_stdlib_U_ZERO_ERROR
-        let correctSize = u_strTo(
-          buf.baseAddress._unsafelyUnwrappedUnchecked,
-          Int32(buf.count),
-          utf16.baseAddress._unsafelyUnwrappedUnchecked,
-          Int32(utf16.count),
-          "",
-          &err)
-        guard err.isSuccess else {
-          fatalError("Unexpected error case-converting Unicode scalar.")
+    static let uppercase = _CaseMapping(rawValue: 0)
+    static let lowercase = _CaseMapping(rawValue: 1)
+    static let titlecase = _CaseMapping(rawValue: 2)
   }
-        return Int(correctSize)
+
+  fileprivate func _getMapping(_ mapping: _CaseMapping) -> String {
+    // First, check if our scalar has a special mapping where it's mapped to
+    // more than 1 scalar.
+    var specialMappingLength = 0
+
+    let specialMappingPtr = _swift_stdlib_getSpecialMapping(
+      _scalar.value,
+      mapping.rawValue,
+      &specialMappingLength
+    )
+
+    if let specialMapping = specialMappingPtr, specialMappingLength != 0 {
+      let buffer = UnsafeBufferPointer<UInt8>(
+        start: specialMapping,
+        count: specialMappingLength
+      )
+
+      return String._uncheckedFromUTF8(buffer, isASCII: false)
     }
+
+    // If we did not have a special mapping, check if we have a direct scalar
+    // to scalar mapping.
+    let mappingDistance = _swift_stdlib_getMapping(
+      _scalar.value,
+      mapping.rawValue
+    )
+
+    if mappingDistance != 0 {
+      let scalar = Unicode.Scalar(
+        _unchecked: UInt32(Int(_scalar.value) &+ Int(mappingDistance))
+      )
+      return String(scalar)
     }
-    if _fastPath(count <= 16) {
-      fixedArray.count = count
-      return fixedArray.withUnsafeBufferPointer {
-        String._uncheckedFromUTF16($0)
-      }
-    }
-    // Allocate `count` code units on the heap.
-    let array = Array<UInt16>(unsafeUninitializedCapacity: count) {
-      buf, initializedCount in
-      _scalar.withUTF16CodeUnits { utf16 in
-        var err = __swift_stdlib_U_ZERO_ERROR
-        let correctSize = u_strTo(
-          buf.baseAddress._unsafelyUnwrappedUnchecked,
-          Int32(buf.count),
-          utf16.baseAddress._unsafelyUnwrappedUnchecked,
-          Int32(utf16.count),
-          "",
-          &err)
-        guard err.isSuccess else {
-          fatalError("Unexpected error case-converting Unicode scalar.")
-        }
-        _internalInvariant(count == correctSize, "inconsistent ICU behavior")
-        initializedCount = count
-      }
-    }
-    return array.withUnsafeBufferPointer {
-      String._uncheckedFromUTF16($0)
-    }
+
+    // We did not have any mapping. Return the scalar as is.
+    return String(_scalar)
   }
 
   /// The lowercase mapping of the scalar.
@@ -824,7 +800,7 @@ extension Unicode.Scalar.Properties {
   /// This property corresponds to the "Lowercase_Mapping" property in the
   /// [Unicode Standard](http://www.unicode.org/versions/latest/).
   public var lowercaseMapping: String {
-    return _applyMapping(__swift_stdlib_u_strToLower)
+    _getMapping(.lowercase)
   }
 
   /// The titlecase mapping of the scalar.
@@ -838,9 +814,7 @@ extension Unicode.Scalar.Properties {
   /// This property corresponds to the "Titlecase_Mapping" property in the
   /// [Unicode Standard](http://www.unicode.org/versions/latest/).
   public var titlecaseMapping: String {
-    return _applyMapping { ptr, cap, src, len, locale, err in
-      return __swift_stdlib_u_strToTitle(ptr, cap, src, len, nil, locale, err)
-    }
+    _getMapping(.titlecase)
   }
 
   /// The uppercase mapping of the scalar.
@@ -854,7 +828,7 @@ extension Unicode.Scalar.Properties {
   /// This property corresponds to the "Uppercase_Mapping" property in the
   /// [Unicode Standard](http://www.unicode.org/versions/latest/).
   public var uppercaseMapping: String {
-    return _applyMapping(__swift_stdlib_u_strToUpper)
+    _getMapping(.uppercase)
   }
 }
 
@@ -875,15 +849,16 @@ extension Unicode.Scalar.Properties {
   /// This property corresponds to the "Age" property in the
   /// [Unicode Standard](http://www.unicode.org/versions/latest/).
   public var age: Unicode.Version? {
-    var versionInfo: __swift_stdlib_UVersionInfo = (0, 0, 0, 0)
-    withUnsafeMutablePointer(to: &versionInfo) { tuplePtr in
-      tuplePtr.withMemoryRebound(to: UInt8.self, capacity: 4) {
-        versionInfoPtr in
-        __swift_stdlib_u_charAge(icuValue, versionInfoPtr)
+    let age: UInt16 = _swift_stdlib_getAge(_scalar.value)
+
+    if age == .max {
+      return nil
     }
-    }
-    guard versionInfo.0 != 0 else { return nil }
-    return (major: Int(versionInfo.0), minor: Int(versionInfo.1))
+
+    let major = age & 0xFF
+    let minor = (age & 0xFF00) >> 8
+
+    return (major: Int(major), minor: Int(minor))
   }
 }
 
@@ -1108,38 +1083,38 @@ extension Unicode {
     /// [Unicode Standard](https://unicode.org/reports/tr44/#General_Category_Values).
     case unassigned
 
-    internal init(rawValue: __swift_stdlib_UCharCategory) {
+    internal init(rawValue: UInt8) {
       switch rawValue {
-      case __swift_stdlib_U_UNASSIGNED: self = .unassigned
-      case __swift_stdlib_U_UPPERCASE_LETTER: self = .uppercaseLetter
-      case __swift_stdlib_U_LOWERCASE_LETTER: self = .lowercaseLetter
-      case __swift_stdlib_U_TITLECASE_LETTER: self = .titlecaseLetter
-      case __swift_stdlib_U_MODIFIER_LETTER: self = .modifierLetter
-      case __swift_stdlib_U_OTHER_LETTER: self = .otherLetter
-      case __swift_stdlib_U_NON_SPACING_MARK: self = .nonspacingMark
-      case __swift_stdlib_U_ENCLOSING_MARK: self = .enclosingMark
-      case __swift_stdlib_U_COMBINING_SPACING_MARK: self = .spacingMark
-      case __swift_stdlib_U_DECIMAL_DIGIT_NUMBER: self = .decimalNumber
-      case __swift_stdlib_U_LETTER_NUMBER: self = .letterNumber
-      case __swift_stdlib_U_OTHER_NUMBER: self = .otherNumber
-      case __swift_stdlib_U_SPACE_SEPARATOR: self = .spaceSeparator
-      case __swift_stdlib_U_LINE_SEPARATOR: self = .lineSeparator
-      case __swift_stdlib_U_PARAGRAPH_SEPARATOR: self = .paragraphSeparator
-      case __swift_stdlib_U_CONTROL_CHAR: self = .control
-      case __swift_stdlib_U_FORMAT_CHAR: self = .format
-      case __swift_stdlib_U_PRIVATE_USE_CHAR: self = .privateUse
-      case __swift_stdlib_U_SURROGATE: self = .surrogate
-      case __swift_stdlib_U_DASH_PUNCTUATION: self = .dashPunctuation
-      case __swift_stdlib_U_START_PUNCTUATION: self = .openPunctuation
-      case __swift_stdlib_U_END_PUNCTUATION: self = .closePunctuation
-      case __swift_stdlib_U_CONNECTOR_PUNCTUATION: self = .connectorPunctuation
-      case __swift_stdlib_U_OTHER_PUNCTUATION: self = .otherPunctuation
-      case __swift_stdlib_U_MATH_SYMBOL: self = .mathSymbol
-      case __swift_stdlib_U_CURRENCY_SYMBOL: self = .currencySymbol
-      case __swift_stdlib_U_MODIFIER_SYMBOL: self = .modifierSymbol
-      case __swift_stdlib_U_OTHER_SYMBOL: self = .otherSymbol
-      case __swift_stdlib_U_INITIAL_PUNCTUATION: self = .initialPunctuation
-      case __swift_stdlib_U_FINAL_PUNCTUATION: self = .finalPunctuation
+      case 0: self = .uppercaseLetter
+      case 1: self = .lowercaseLetter
+      case 2: self = .titlecaseLetter
+      case 3: self = .modifierLetter
+      case 4: self = .otherLetter
+      case 5: self = .nonspacingMark
+      case 6: self = .spacingMark
+      case 7: self = .enclosingMark
+      case 8: self = .decimalNumber
+      case 9: self = .letterNumber
+      case 10: self = .otherNumber
+      case 11: self = .connectorPunctuation
+      case 12: self = .dashPunctuation
+      case 13: self = .openPunctuation
+      case 14: self = .closePunctuation
+      case 15: self = .initialPunctuation
+      case 16: self = .finalPunctuation
+      case 17: self = .otherPunctuation
+      case 18: self = .mathSymbol
+      case 19: self = .currencySymbol
+      case 20: self = .modifierSymbol
+      case 21: self = .otherSymbol
+      case 22: self = .spaceSeparator
+      case 23: self = .lineSeparator
+      case 24: self = .paragraphSeparator
+      case 25: self = .control
+      case 26: self = .format
+      case 27: self = .surrogate
+      case 28: self = .privateUse
+      case 29: self = .unassigned
       default: fatalError("Unknown general category \(rawValue)")
       }
     }
@@ -1173,42 +1148,86 @@ extension Unicode.Scalar.Properties {
   /// This property corresponds to the "General_Category" property in the
   /// [Unicode Standard](http://www.unicode.org/versions/latest/).
   public var generalCategory: Unicode.GeneralCategory {
-    let rawValue = __swift_stdlib_UCharCategory(
-      __swift_stdlib_UCharCategory.RawValue(
-      __swift_stdlib_u_getIntPropertyValue(
-        icuValue, __swift_stdlib_UCHAR_GENERAL_CATEGORY)))
+    let rawValue = _swift_stdlib_getGeneralCategory(_scalar.value)
     return Unicode.GeneralCategory(rawValue: rawValue)
   }
 }
 
 extension Unicode.Scalar.Properties {
+  internal func _hangulName() -> String {
+    // T = Hangul tail consonants
+    let T: (base: UInt32, count: UInt32) = (base: 0x11A7, count: 28)
+    // N = Number of precomposed Hangul syllables that start with the same
+    //     leading consonant. (There is no base for N).
+    let N: (base: UInt32, count: UInt32) = (base: 0x0, count: 588)
+    // S = Hangul precomposed syllables
+    let S: (base: UInt32, count: UInt32) = (base: 0xAC00, count: 11172)
 
-  internal func _scalarName(
-    _ choice: __swift_stdlib_UCharNameChoice
-  ) -> String? {
-    var error = __swift_stdlib_U_ZERO_ERROR
-    let count = Int(__swift_stdlib_u_charName(icuValue, choice, nil, 0, &error))
-    guard count > 0 else { return nil }
+    let hangulLTable = ["G", "GG", "N", "D", "DD", "R", "M", "B", "BB", "S",
+                        "SS", "", "J", "JJ", "C", "K", "T", "P", "H"]
 
-    // ICU writes a trailing null, so we have to save room for it as well.
-    let array = Array<UInt8>(unsafeUninitializedCapacity: count + 1) {
-      buffer, initializedCount in
-      var error = __swift_stdlib_U_ZERO_ERROR
-      let correctSize = __swift_stdlib_u_charName(
-        icuValue,
-        choice,
-        UnsafeMutableRawPointer(buffer.baseAddress._unsafelyUnwrappedUnchecked)
-          .assumingMemoryBound(to: Int8.self),
-        Int32(buffer.count),
-        &error)
-      guard error.isSuccess else {
-        fatalError("Unexpected error case-converting Unicode scalar.")
+    let hangulVTable = ["A", "AE", "YA", "YAE", "EO", "E", "YEO", "YE", "O",
+                        "WA", "WAE", "OE", "YO", "U", "WEO", "WE", "WI", "YU",
+                        "EU", "YI", "I"]
+
+    let hangulTTable = ["", "G", "GG", "GS", "N", "NJ", "NH", "D", "L", "LG",
+                        "LM", "LB", "LS", "LT", "LP", "LH", "M", "B", "BS", "S",
+                        "SS", "NG", "J", "C", "K", "T", "P", "H"]
+
+    let sIdx = _scalar.value &- S.base
+    let lIdx = Int(sIdx / N.count)
+    let vIdx = Int((sIdx % N.count) / T.count)
+    let tIdx = Int(sIdx % T.count)
+
+    let scalarName = hangulLTable[lIdx] + hangulVTable[vIdx] + hangulTTable[tIdx]
+    return "HANGUL SYLLABLE \(scalarName)"
   }
-      _internalInvariant(count == correctSize, "inconsistent ICU behavior")
-      initializedCount = count + 1
-    }
-    return array.withUnsafeBufferPointer { buffer in
-      String._fromASCII(UnsafeBufferPointer(rebasing: buffer[..<count]))
+
+  // Used to potentially return a name who can either be represented in a large
+  // range or algorithmetically. A good example are the Hangul names. Instead of
+  // storing those names, we can define an algorithm to generate the name.
+  internal func _fastScalarName() -> String? {
+    // Define a couple algorithmetic names below.
+
+    let scalarName = String(_scalar.value, radix: 16, uppercase: true)
+
+    switch _scalar.value {
+    // Hangul Syllable *
+    case (0xAC00 ... 0xD7A3):
+      return _hangulName()
+
+    // Variation Selector-17 through Variation Selector-256
+    case (0xE0100 ... 0xE01EF):
+      return "VARIATION SELECTOR-\(_scalar.value - 0xE0100 + 17)"
+
+    case (0x3400 ... 0x4DBF),
+         (0x4E00 ... 0x9FFF),
+         (0x20000 ... 0x2A6DF),
+         (0x2A700 ... 0x2B738),
+         (0x2B740 ... 0x2B81D),
+         (0x2B820 ... 0x2CEA1),
+         (0x2CEB0 ... 0x2EBE0),
+         (0x2F800 ... 0x2FA1D),
+         (0x30000 ... 0x3134A):
+      return "CJK UNIFIED IDEOGRAPH-\(scalarName)"
+
+    case (0xF900 ... 0xFA6D),
+         (0xFA70 ... 0xFAD9):
+      return "CJK COMPATIBILITY IDEOGRAPH-\(scalarName)"
+
+    case (0x17000 ... 0x187F7),
+         (0x18D00 ... 0x18D08):
+      return "TANGUT IDEOGRAPH-\(scalarName)"
+
+    case (0x18B00 ... 0x18CD5):
+      return "KHITAN SMALL SCRIPT CHARACTER-\(scalarName)"
+
+    case (0x1B170 ... 0x1B2FB):
+      return "NUSHU CHARACTER-\(scalarName)"
+
+    // Otherwise, go look it up.
+    default:
+      return nil
     }
   }
 
@@ -1221,7 +1240,22 @@ extension Unicode.Scalar.Properties {
   /// This property corresponds to the "Name" property in the
   /// [Unicode Standard](http://www.unicode.org/versions/latest/).
   public var name: String? {
-    return _scalarName(__swift_stdlib_U_UNICODE_CHAR_NAME)
+    if let fastName = _fastScalarName() {
+      return fastName
+    }
+
+    // The longest name that Unicode defines is 88 characters long.
+    let largestCount = Int(SWIFT_STDLIB_LARGEST_NAME_COUNT)
+
+    let name = String(_uninitializedCapacity: largestCount) { buffer in
+      _swift_stdlib_getScalarName(
+        _scalar.value,
+        buffer.baseAddress,
+        buffer.count
+      )
+    }
+
+    return name.isEmpty ? nil : name
   }
 
   /// The normative formal alias of the scalar.
@@ -1238,7 +1272,11 @@ extension Unicode.Scalar.Properties {
   /// This property corresponds to the "Name_Alias" property in the
   /// [Unicode Standard](http://www.unicode.org/versions/latest/).
   public var nameAlias: String? {
-    return _scalarName(__swift_stdlib_U_CHAR_NAME_ALIAS)
+    guard let nameAliasPtr = _swift_stdlib_getNameAlias(_scalar.value) else {
+      return nil
+    }
+
+    return String(cString: nameAliasPtr)
   }
 }
 
@@ -1388,9 +1426,8 @@ extension Unicode.Scalar.Properties {
   /// This property corresponds to the "Canonical_Combining_Class" property in
   /// the [Unicode Standard](http://www.unicode.org/versions/latest/).
   public var canonicalCombiningClass: Unicode.CanonicalCombiningClass {
-    let normData = _swift_stdlib_getNormData(_scalar.value)
-    let rawValue = UInt8(normData >> 3)
-    return Unicode.CanonicalCombiningClass(rawValue: rawValue)
+    let normData = Unicode._NormData(_scalar)
+    return Unicode.CanonicalCombiningClass(rawValue: normData.ccc)
   }
 }
 
@@ -1438,13 +1475,16 @@ extension Unicode {
     /// and programs can treat `digit` and `numeric` equivalently.
     case numeric
 
-    internal init?(rawValue: __swift_stdlib_UNumericType) {
+    internal init(rawValue: UInt8) {
       switch rawValue {
-      case __swift_stdlib_U_NT_NONE: return nil
-      case __swift_stdlib_U_NT_DECIMAL: self = .decimal
-      case __swift_stdlib_U_NT_DIGIT: self = .digit
-      case __swift_stdlib_U_NT_NUMERIC: self = .numeric
-      default: fatalError("Unknown numeric type \(rawValue)")
+      case 0:
+        self = .numeric
+      case 1:
+        self = .digit
+      case 2:
+        self = .decimal
+      default:
+        fatalError("Unknown numeric type \(rawValue)")
       }
     }
   }
@@ -1470,10 +1510,12 @@ extension Unicode.Scalar.Properties {
   /// This property corresponds to the "Numeric_Type" property in the
   /// [Unicode Standard](http://www.unicode.org/versions/latest/).
   public var numericType: Unicode.NumericType? {
-    let rawValue = __swift_stdlib_UNumericType(
-      __swift_stdlib_UNumericType.RawValue(
-      __swift_stdlib_u_getIntPropertyValue(
-        icuValue, __swift_stdlib_UCHAR_NUMERIC_TYPE)))
+    let rawValue = _swift_stdlib_getNumericType(_scalar.value)
+
+    guard rawValue != .max else {
+      return nil
+    }
+
     return Unicode.NumericType(rawValue: rawValue)
   }
 
@@ -1494,8 +1536,10 @@ extension Unicode.Scalar.Properties {
   /// This property corresponds to the "Numeric_Value" property in the [Unicode
   /// Standard](http://www.unicode.org/versions/latest/).
   public var numericValue: Double? {
-    let icuNoNumericValue: Double = -123456789
-    let result = __swift_stdlib_u_getNumericValue(icuValue)
-    return result != icuNoNumericValue ? result : nil
+    guard numericType != nil else {
+      return nil
+    }
+
+    return _swift_stdlib_getNumericValue(_scalar.value)
   }
 }

stdlib/public/stubs/UnicodeData.cpp

@@ -11,6 +11,7 @@
 //===----------------------------------------------------------------------===//
 
 #include "../SwiftShims/UnicodeData.h"
+#include <limits>
 
 // Every 4 byte chunks of data that we need to hash (in this case only ever
 // scalars and levels who are all uint32), we need to calculate K. At the end
@@ -47,7 +48,6 @@ static __swift_uint32_t hash(__swift_uint32_t scalar, __swift_uint32_t level,
 
 // This implementation is based on the minimal perfect hashing strategy found
 // here: https://arxiv.org/pdf/1702.03154.pdf
-SWIFT_RUNTIME_STDLIB_INTERNAL
 __swift_intptr_t _swift_stdlib_getMphIdx(__swift_uint32_t scalar,
                                          __swift_intptr_t levels,
                                          const __swift_uint64_t * const *keys,
@@ -102,3 +102,57 @@ __swift_intptr_t _swift_stdlib_getMphIdx(__swift_uint32_t scalar,
 
   return resultIdx;
 }
+
+__swift_intptr_t _swift_stdlib_getScalarBitArrayIdx(__swift_uint32_t scalar,
+                                              const __swift_uint64_t *bitArrays,
+                                              const __swift_uint16_t *ranks) {
+  auto chunkSize = 0x110000 / 64 / 64;
+  auto base = scalar / chunkSize;
+  auto idx = base / 64;
+  auto chunkBit = base % 64;
+  
+  auto quickLookSize = bitArrays[0];
+  
+  // If our chunk index is larger than the quick look indices, then it means
+  // our scalar appears in chunks who are all 0 and trailing.
+  if ((__swift_uint64_t) idx > quickLookSize) {
+    return std::numeric_limits<__swift_intptr_t>::max();
+  }
+  
+  auto quickLook = bitArrays[idx + 1];
+  
+  if ((quickLook & ((__swift_uint64_t) 1 << chunkBit)) == 0) {
+    return std::numeric_limits<__swift_intptr_t>::max();
+  }
+  
+  // Ok, our scalar failed the quick look check. Go lookup our scalar in the
+  // chunk specific bit array.
+  auto chunkRank = ranks[idx];
+  
+  if (chunkBit != 0) {
+    chunkRank += __builtin_popcountll(quickLook << (64 - chunkBit));
+  }
+  
+  auto chunkBA = bitArrays + 1 + quickLookSize + (chunkRank * 5);
+  
+  auto scalarOverallBit = scalar - (base * chunkSize);
+  auto scalarSpecificBit = scalarOverallBit % 64;
+  auto scalarWord = scalarOverallBit / 64;
+  
+  auto chunkWord = chunkBA[scalarWord];
+  
+  // If our scalar specifically is not turned on, then we're done.
+  if ((chunkWord & ((__swift_uint64_t) 1 << scalarSpecificBit)) == 0) {
+    return std::numeric_limits<__swift_intptr_t>::max();
+  }
+  
+  auto scalarRank = ranks[quickLookSize + (chunkRank * 5) + scalarWord];
+  
+  if (scalarSpecificBit != 0) {
+    scalarRank += __builtin_popcountll(chunkWord << (64 - scalarSpecificBit));
+  }
+  
+  auto chunkDataIdx = chunkBA[4] >> 16;
+
+  return chunkDataIdx + scalarRank;
+}

stdlib/public/stubs/UnicodeNormalization.cpp

@@ -351,59 +351,17 @@ __swift_uint16_t _swift_stdlib_getNormData(__swift_uint32_t scalar) {
     return 0;
   }
 
-  auto chunkSize = 0x110000 / 64 / 64;
-  auto base = scalar / chunkSize;
-  auto idx = base / 64;
-  auto chunkBit = base % 64;
+  auto dataIdx = _swift_stdlib_getScalarBitArrayIdx(scalar,
+                                                    _swift_stdlib_normData,
+                                                  _swift_stdlib_normData_ranks);
 
-  auto quickLookSize = _swift_stdlib_normData[0];
-  
-  // If our chunk index is larger than the quick look indices, then it means
-  // our scalar appears in chunks who are all 0 and trailing.
-  if ((__swift_uint64_t) idx > quickLookSize) {
+  // If we don't have an index into the data indices, then this scalar has no
+  // normalization information.
+  if (dataIdx == std::numeric_limits<__swift_intptr_t>::max()) {
     return 0;
   }
 
-  auto quickLook = _swift_stdlib_normData[idx + 1];
-  
-  if ((quickLook & ((__swift_uint64_t) 1 << chunkBit)) == 0) {
-    return 0;
-  }
-  
-  // Ok, our scalar failed the quick look check. Go lookup our scalar in the
-  // chunk specific bit array.
-  auto chunkRank = _swift_stdlib_normData_ranks[idx];
-  
-  if (chunkBit != 0) {
-    chunkRank += __builtin_popcountll(quickLook << (64 - chunkBit));
-  }
-  
-  auto chunkBA = _swift_stdlib_normData + 1 + quickLookSize + (chunkRank * 5);
-  
-  auto scalarOverallBit = scalar - (base * chunkSize);
-  auto scalarSpecificBit = scalarOverallBit % 64;
-  auto scalarWord = scalarOverallBit / 64;
-  
-  auto chunkWord = chunkBA[scalarWord];
-  
-  // If our scalar specifically is not turned on, then we're done.
-  if ((chunkWord & ((__swift_uint64_t) 1 << scalarSpecificBit)) == 0) {
-    return 0;
-  }
-  
-  auto scalarRank = _swift_stdlib_normData_ranks[
-    quickLookSize + (chunkRank * 5) + scalarWord
-  ];
-  
-  if (scalarSpecificBit != 0) {
-    scalarRank += __builtin_popcountll(chunkWord << (64 - scalarSpecificBit));
-  }
-  
-  auto chunkDataIdx = chunkBA[4] >> 16;
-  auto scalarDataIdx = _swift_stdlib_normData_data_indices[
-    chunkDataIdx + scalarRank
-  ];
-  
+  auto scalarDataIdx = _swift_stdlib_normData_data_indices[dataIdx];
   return _swift_stdlib_normData_data[scalarDataIdx];
 }
 

stdlib/public/stubs/UnicodeScalarProps.cpp

@@ -10,613 +10,9 @@
 //
 //===----------------------------------------------------------------------===//
 
-// This was auto-generated by utils/gen-unicode-data/GenScalarProps,
-// please do not edit this file yourself!
-
+#include "UnicodeScalarProps.h"
 #include "../SwiftShims/UnicodeData.h"
-
-static const __swift_uint64_t _swift_stdlib_scalar_binProps_data[188] = {
-  0xC003124008BB, 0x400002A08408, 0x420002600408, 0x800450000, 0x800400400, 0x400002408000,
-  0x20000400008, 0xC00012500080, 0xC80012400888, 0x400000000, 0x201000000000, 0x80000400880,
-  0xC001134008F2, 0x500002802408, 0xA00600208, 0x800604208, 0x800400008, 0x400002408080,
-  0x400102808CBB, 0x200401008, 0x400002808400, 0x400002802408, 0xC00012400480, 0x28800400400,
-  0x20000600008, 0x28000400408, 0x400202400008, 0x6408, 0xC00012400080, 0x2000400408,
-  0xC001126008BA, 0xC8001260088F, 0xC40032400080, 0xA00400200, 0x400202400000, 0xC00112408C80,
-  0xC00112410888, 0x8000040088F, 0x1004008BA, 0x800400000, 0x800411000, 0x400002808000,
-  0x2000400208, 0xC00032600088, 0xC00012408488, 0xC800134008CF, 0x4400000, 0xC00032400080,
-  0xC80012400886, 0x400002900400, 0xC00112400880, 0x400200, 0x200400208, 0xC00012608488, 0x400008,
-  0x608408, 0x20800400000, 0x800400200, 0x500000, 0x400002800080, 0x401008, 0x80000400888,
-  0xC00012400088, 0x400002800480, 0x8400000, 0x600008, 0x400002400008, 0x200400008, 0x2800400200,
-  0x2800400400, 0x800408400, 0xC001124008BA, 0xC001134008BA, 0xC00012600088, 0x1000002508, 0x490000,
-  0xC00012800480, 0x28000400000, 0x408408, 0x400000, 0x8000041088F, 0x400002508400, 0x800400408,
-  0xC80212400888, 0x40802408, 0xC10112400880, 0x450000, 0x2800400000, 0x0, 0x4000400008,
-  0xC8001240088F, 0x112408C88, 0x2508, 0x400002800400, 0xA00410000, 0x400012808488, 0x200400000,
-  0x400003410040, 0xC10312400888, 0xC00012402088, 0x410000, 0x400003400008, 0xC00012408480,
-  0xC00012500480, 0xC00112400888, 0xC00012508488, 0x8004D0000, 0x400408, 0x800490000,
-  0xC00092400080, 0x4000400000, 0xC00112408C88, 0x20000400000, 0x400, 0xC10112408C88,
-  0x400002808480, 0xC00012400000, 0xC8001340088F, 0xC00012408080, 0xC00212400088, 0x12400088,
-  0xC001124048BB, 0x12408408, 0x20000400408, 0x400002400080, 0x800000000, 0xC001124008B2, 0x408400,
-  0xC101124008B2, 0x80000410880, 0x400400, 0x401000, 0x800408480, 0xC8001240089F, 0xC00032400088,
-  0x20800400400, 0x400208, 0xA00400008, 0xA00490000, 0x28800410008, 0x4B0400, 0xC00312400888,
-  0x800401008, 0x400022800400, 0x2000400008, 0x2008, 0xA00400208, 0xC000124008AF, 0xC00212400000,
-  0xC00012508480, 0x2408, 0x28800400000, 0x200408408, 0xC00012400488, 0xC10112400C88,
-  0xC001124008A2, 0xA00408400, 0x408000, 0x800400, 0xA00400000, 0x400012400088, 0x400002400000,
-  0xC001124008BB, 0x808400, 0xA00401000, 0x201000400000, 0x400202800400, 0x200000400008,
-  0xC00012404080, 0x28800400008, 0x4D0000, 0x400002908400, 0x28000400008, 0x400002800000,
-  0x400002A00488, 0x400002804488, 0x410008, 0x802408, 0x200000400000, 0x200002408, 0x490008,
-  0x800410000, 0x800401000, 0xC00112400C88, 0x40002408, 0x400002908480, 0x200000600008,
-  0xC8021240088F,
-};
-
-static const __swift_uint32_t _swift_stdlib_scalar_binProps[4855] = {
-  0xB000000, 0x1400009, 0xB00000E, 0x14A00020, 0x12E00021, 0xAE00022, 0x16A00023, 0x4E00024,
-  0x8A00027, 0x7200028, 0x16A0002A, 0x13E0002B, 0x700002C, 0x16C0002D, 0x2E0002E, 0x4E0002F,
-  0xC200030, 0x10E0003A, 0x700003B, 0x420003C, 0x13E0003D, 0x420003E, 0x12E0003F, 0x4E00040,
-  0x5A00041, 0xB400047, 0x720005B, 0x4E0005C, 0x720005D, 0x1380005E, 0x1420005F, 0x8C00060,
-  0x1800061, 0xFC00067, 0x10000069, 0xFC0006B, 0x720007B, 0x13E0007C, 0x720007D, 0x13E0007E,
-  0xB00007F, 0x1400085, 0xB000086, 0x14E000A0, 0x4E000A1, 0x9C000A8, 0x16A000A9, 0xD0000AA,
-  0x88000AB, 0x13E000AC, 0x12C000AD, 0x16A000AE, 0x9C000AF, 0x4E000B0, 0x13E000B1, 0x6C000B2,
-  0x9C000B4, 0x144000B5, 0x4E000B6, 0xA2000B7, 0x9C000B8, 0x6C000B9, 0xD0000BA, 0x88000BB,
-  0x6C000BC, 0x4E000BF, 0xB4000C0, 0x13E000D7, 0xB4000D8, 0x144000DF, 0xFC000E0, 0x13E000F7,
-  0xFC000F8, 0xB400100, 0xFC00101, 0xB400102, 0xFC00103, 0xB400104, 0xFC00105, 0xB400106, 0xFC00107,
-  0xB400108, 0xFC00109, 0xB40010A, 0xFC0010B, 0xB40010C, 0xFC0010D, 0xB40010E, 0xFC0010F, 0xB400110,
-  0xFC00111, 0xB400112, 0xFC00113, 0xB400114, 0xFC00115, 0xB400116, 0xFC00117, 0xB400118, 0xFC00119,
-  0xB40011A, 0xFC0011B, 0xB40011C, 0xFC0011D, 0xB40011E, 0xFC0011F, 0xB400120, 0xFC00121, 0xB400122,
-  0xFC00123, 0xB400124, 0xFC00125, 0xB400126, 0xFC00127, 0xB400128, 0xFC00129, 0xB40012A, 0xFC0012B,
-  0xB40012C, 0xFC0012D, 0xB40012E, 0x1000012F, 0xB400130, 0xFC00131, 0xB400132, 0x8E00133,
-  0xB400134, 0xFC00135, 0xB400136, 0xFC00137, 0x6400138, 0xB400139, 0xFC0013A, 0xB40013B, 0xFC0013C,
-  0xB40013D, 0xFC0013E, 0xB40013F, 0x8E00140, 0xB400141, 0xFC00142, 0xB400143, 0xFC00144, 0xB400145,
-  0xFC00146, 0xB400147, 0xFC00148, 0xF200149, 0xB40014A, 0xFC0014B, 0xB40014C, 0xFC0014D, 0xB40014E,
-  0xFC0014F, 0xB400150, 0xFC00151, 0xB400152, 0xFC00153, 0xB400154, 0xFC00155, 0xB400156, 0xFC00157,
-  0xB400158, 0xFC00159, 0xB40015A, 0xFC0015B, 0xB40015C, 0xFC0015D, 0xB40015E, 0xFC0015F, 0xB400160,
-  0xFC00161, 0xB400162, 0xFC00163, 0xB400164, 0xFC00165, 0xB400166, 0xFC00167, 0xB400168, 0xFC00169,
-  0xB40016A, 0xFC0016B, 0xB40016C, 0xFC0016D, 0xB40016E, 0xFC0016F, 0xB400170, 0xFC00171, 0xB400172,
-  0xFC00173, 0xB400174, 0xFC00175, 0xB400176, 0xFC00177, 0xB400178, 0xFC0017A, 0xB40017B, 0xFC0017C,
-  0xB40017D, 0xFC0017E, 0x1440017F, 0xFC00180, 0xB400181, 0xFC00183, 0xB400184, 0xFC00185,
-  0xB400186, 0xFC00188, 0xB400189, 0xFC0018C, 0x640018D, 0xB40018E, 0xFC00192, 0xB400193, 0xFC00195,
-  0xB400196, 0xFC00199, 0x640019B, 0xB40019C, 0xFC0019E, 0xB40019F, 0xFC001A1, 0xB4001A2, 0xFC001A3,
-  0xB4001A4, 0xFC001A5, 0xB4001A6, 0xFC001A8, 0xB4001A9, 0x64001AA, 0xB4001AC, 0xFC001AD, 0xB4001AE,
-  0xFC001B0, 0xB4001B1, 0xFC001B4, 0xB4001B5, 0xFC001B6, 0xB4001B7, 0xFC001B9, 0x64001BA, 0x38001BB,
-  0xB4001BC, 0xFC001BD, 0x64001BE, 0xFC001BF, 0x38001C0, 0x10A001C4, 0x126001C5, 0x8E001C6,
-  0x10A001C7, 0x126001C8, 0x8E001C9, 0x10A001CA, 0x126001CB, 0x8E001CC, 0xB4001CD, 0xFC001CE,
-  0xB4001CF, 0xFC001D0, 0xB4001D1, 0xFC001D2, 0xB4001D3, 0xFC001D4, 0xB4001D5, 0xFC001D6, 0xB4001D7,
-  0xFC001D8, 0xB4001D9, 0xFC001DA, 0xB4001DB, 0xFC001DC, 0xB4001DE, 0xFC001DF, 0xB4001E0, 0xFC001E1,
-  0xB4001E2, 0xFC001E3, 0xB4001E4, 0xFC001E5, 0xB4001E6, 0xFC001E7, 0xB4001E8, 0xFC001E9, 0xB4001EA,
-  0xFC001EB, 0xB4001EC, 0xFC001ED, 0xB4001EE, 0xFC001EF, 0x10A001F1, 0x126001F2, 0x8E001F3,
-  0xB4001F4, 0xFC001F5, 0xB4001F6, 0xFC001F9, 0xB4001FA, 0xFC001FB, 0xB4001FC, 0xFC001FD, 0xB4001FE,
-  0xFC001FF, 0xB400200, 0xFC00201, 0xB400202, 0xFC00203, 0xB400204, 0xFC00205, 0xB400206, 0xFC00207,
-  0xB400208, 0xFC00209, 0xB40020A, 0xFC0020B, 0xB40020C, 0xFC0020D, 0xB40020E, 0xFC0020F, 0xB400210,
-  0xFC00211, 0xB400212, 0xFC00213, 0xB400214, 0xFC00215, 0xB400216, 0xFC00217, 0xB400218, 0xFC00219,
-  0xB40021A, 0xFC0021B, 0xB40021C, 0xFC0021D, 0xB40021E, 0xFC0021F, 0xB400220, 0x6400221, 0xB400222,
-  0xFC00223, 0xB400224, 0xFC00225, 0xB400226, 0xFC00227, 0xB400228, 0xFC00229, 0xB40022A, 0xFC0022B,
-  0xB40022C, 0xFC0022D, 0xB40022E, 0xFC0022F, 0xB400230, 0xFC00231, 0xB400232, 0xFC00233, 0x6400234,
-  0xB40023A, 0xFC0023C, 0xB40023D, 0xFC0023F, 0xB400241, 0xFC00242, 0xB400243, 0xFC00247, 0xB400248,
-  0x10000249, 0xB40024A, 0xFC0024B, 0xB40024C, 0xFC0024D, 0xB40024E, 0xFC0024F, 0x6400255,
-  0xFC00256, 0x6400258, 0xFC00259, 0x640025A, 0xFC0025B, 0x640025D, 0xFC00260, 0x6400262, 0xFC00263,
-  0x6400264, 0xFC00265, 0x6400267, 0x10000268, 0xFC00269, 0x640026D, 0xFC0026F, 0x6400270,
-  0xFC00271, 0x6400273, 0xFC00275, 0x6400276, 0xFC0027D, 0x640027E, 0xFC00280, 0x6400281, 0xFC00282,
-  0x6400284, 0xFC00287, 0x640028D, 0xFC00292, 0x6400293, 0x3800294, 0x6400295, 0x1000029D,
-  0xFC0029E, 0x640029F, 0xDE002B0, 0xE4002B2, 0xDE002B3, 0xCC002B9, 0x46002C0, 0xFE002C2, 0xCC002C6,
-  0x12A002D0, 0xFE002D2, 0x9C002D8, 0xFE002DE, 0xDE002E0, 0xFE002E5, 0xCC002EC, 0xFE002ED,
-  0xCC002EE, 0xFE002EF, 0x2800300, 0x200340, 0x2800342, 0x200343, 0x2400345, 0x2800346, 0x2A0034F,
-  0x2800350, 0xBA00358, 0x280035D, 0xBA00363, 0xB400370, 0xFC00371, 0xB400372, 0xFC00373, 0x6A00374,
-  0xFE00375, 0xB400376, 0xFC00377, 0xB000378, 0xB60037A, 0xFC0037B, 0x300037E, 0xB40037F, 0xB000380,
-  0x9C00384, 0xB400386, 0x400387, 0xB400388, 0xB00038B, 0xB40038C, 0xB00038D, 0xB40038E, 0xFC00390,
-  0xB400391, 0xB0003A2, 0xB4003A3, 0xFC003AC, 0x144003C2, 0xFC003C3, 0xB4003CF, 0x3D0, 0xA6003D2,
-  0x10003D3, 0x3D5, 0x144003D6, 0xFC003D7, 0xB4003D8, 0xFC003D9, 0xB4003DA, 0xFC003DB, 0xB4003DC,
-  0xFC003DD, 0xB4003DE, 0xFC003DF, 0xB4003E0, 0xFC003E1, 0xB4003E2, 0xFC003E3, 0xB4003E4, 0xFC003E5,
-  0xB4003E6, 0xFC003E7, 0xB4003E8, 0xFC003E9, 0xB4003EA, 0xFC003EB, 0xB4003EC, 0xFC003ED, 0xB4003EE,
-  0xFC003EF, 0x3F0, 0x8E003F2, 0x100003F3, 0x176003F4, 0x3F5, 0xC0003F6, 0xB4003F7, 0xFC003F8,
-  0xB4003F9, 0xFC003FB, 0x64003FC, 0xB4003FD, 0xFC00430, 0x10000456, 0xFC00457, 0x10000458,
-  0xFC00459, 0xB400460, 0xFC00461, 0xB400462, 0xFC00463, 0xB400464, 0xFC00465, 0xB400466, 0xFC00467,
-  0xB400468, 0xFC00469, 0xB40046A, 0xFC0046B, 0xB40046C, 0xFC0046D, 0xB40046E, 0xFC0046F, 0xB400470,
-  0xFC00471, 0xB400472, 0xFC00473, 0xB400474, 0xFC00475, 0xB400476, 0xFC00477, 0xB400478, 0xFC00479,
-  0xB40047A, 0xFC0047B, 0xB40047C, 0xFC0047D, 0xB40047E, 0xFC0047F, 0xB400480, 0xFC00481, 0x9E00482,
-  0x2800483, 0x13C00488, 0xB40048A, 0xFC0048B, 0xB40048C, 0xFC0048D, 0xB40048E, 0xFC0048F,
-  0xB400490, 0xFC00491, 0xB400492, 0xFC00493, 0xB400494, 0xFC00495, 0xB400496, 0xFC00497, 0xB400498,
-  0xFC00499, 0xB40049A, 0xFC0049B, 0xB40049C, 0xFC0049D, 0xB40049E, 0xFC0049F, 0xB4004A0, 0xFC004A1,
-  0xB4004A2, 0xFC004A3, 0xB4004A4, 0xFC004A5, 0xB4004A6, 0xFC004A7, 0xB4004A8, 0xFC004A9, 0xB4004AA,
-  0xFC004AB, 0xB4004AC, 0xFC004AD, 0xB4004AE, 0xFC004AF, 0xB4004B0, 0xFC004B1, 0xB4004B2, 0xFC004B3,
-  0xB4004B4, 0xFC004B5, 0xB4004B6, 0xFC004B7, 0xB4004B8, 0xFC004B9, 0xB4004BA, 0xFC004BB, 0xB4004BC,
-  0xFC004BD, 0xB4004BE, 0xFC004BF, 0xB4004C0, 0xFC004C2, 0xB4004C3, 0xFC004C4, 0xB4004C5, 0xFC004C6,
-  0xB4004C7, 0xFC004C8, 0xB4004C9, 0xFC004CA, 0xB4004CB, 0xFC004CC, 0xB4004CD, 0xFC004CE, 0xB4004D0,
-  0xFC004D1, 0xB4004D2, 0xFC004D3, 0xB4004D4, 0xFC004D5, 0xB4004D6, 0xFC004D7, 0xB4004D8, 0xFC004D9,
-  0xB4004DA, 0xFC004DB, 0xB4004DC, 0xFC004DD, 0xB4004DE, 0xFC004DF, 0xB4004E0, 0xFC004E1, 0xB4004E2,
-  0xFC004E3, 0xB4004E4, 0xFC004E5, 0xB4004E6, 0xFC004E7, 0xB4004E8, 0xFC004E9, 0xB4004EA, 0xFC004EB,
-  0xB4004EC, 0xFC004ED, 0xB4004EE, 0xFC004EF, 0xB4004F0, 0xFC004F1, 0xB4004F2, 0xFC004F3, 0xB4004F4,
-  0xFC004F5, 0xB4004F6, 0xFC004F7, 0xB4004F8, 0xFC004F9, 0xB4004FA, 0xFC004FB, 0xB4004FC, 0xFC004FD,
-  0xB4004FE, 0xFC004FF, 0xB400500, 0xFC00501, 0xB400502, 0xFC00503, 0xB400504, 0xFC00505, 0xB400506,
-  0xFC00507, 0xB400508, 0xFC00509, 0xB40050A, 0xFC0050B, 0xB40050C, 0xFC0050D, 0xB40050E, 0xFC0050F,
-  0xB400510, 0xFC00511, 0xB400512, 0xFC00513, 0xB400514, 0xFC00515, 0xB400516, 0xFC00517, 0xB400518,
-  0xFC00519, 0xB40051A, 0xFC0051B, 0xB40051C, 0xFC0051D, 0xB40051E, 0xFC0051F, 0xB400520, 0xFC00521,
-  0xB400522, 0xFC00523, 0xB400524, 0xFC00525, 0xB400526, 0xFC00527, 0xB400528, 0xFC00529, 0xB40052A,
-  0xFC0052B, 0xB40052C, 0xFC0052D, 0xB40052E, 0xFC0052F, 0xB000530, 0xB400531, 0xB000557, 0xCC00559,
-  0x9E0055A, 0x1040055F, 0x6400560, 0xFC00561, 0x14400587, 0x6400588, 0x9A00589, 0x1060058A,
-  0xB00058B, 0x9E0058D, 0xB000590, 0x2800591, 0xBA005A2, 0x28005A3, 0xE6005B0, 0x106005BE,
-  0xE6005BF, 0x9E005C0, 0xE6005C1, 0xE0005C3, 0xE6005C4, 0x7E005C5, 0x9E005C6, 0x7E005C7, 0xB0005C8,
-  0x38005D0, 0xB0005EB, 0x38005EF, 0x9E005F3, 0x104005F4, 0xB0005F5, 0xE200600, 0xC000606,
-  0x9E00609, 0xE00060C, 0x9E0060D, 0x7E00610, 0xE00061B, 0xB80061C, 0x9A0061D, 0x3800620, 0xCE00640,
-  0x3800641, 0xE60064B, 0x7E00653, 0xE600657, 0x2800658, 0x7E00659, 0x14200660, 0x9E0066A,
-  0x380066E, 0x7E00670, 0x3800671, 0x15000673, 0x3800674, 0x7C00675, 0x3800679, 0x9A006D4,
-  0x38006D5, 0x7E006D6, 0xE2006DD, 0x9E006DE, 0x28006DF, 0x7E006E1, 0xCC006E5, 0x7E006E7, 0x9E006E9,
-  0x28006EA, 0x7E006ED, 0x38006EE, 0x142006F0, 0x38006FA, 0x9E006FD, 0x38006FF, 0x9A00700,
-  0xE000703, 0x9E0070B, 0xE00070C, 0x9E0070D, 0xB00070E, 0xE20070F, 0x3800710, 0x7E00711, 0x3800712,
-  0xE600730, 0x2800740, 0xB00074B, 0x380074D, 0xE6007A6, 0x38007B1, 0xB0007B2, 0x142007C0,
-  0x38007CA, 0x28007EB, 0xCC007F4, 0x9E007F6, 0xE0007F8, 0x9A007F9, 0xCE007FA, 0xB0007FB, 0xBA007FD,
-  0x9E007FE, 0x3800800, 0x7E00816, 0x2800818, 0x2C0081A, 0x7E0081B, 0x2C00824, 0x7E00825, 0x2C00828,
-  0x7E00829, 0xBA0082D, 0xB00082E, 0xE000830, 0x9A00837, 0xE000838, 0x9A00839, 0xE00083A, 0x9A0083D,
-  0xB00083F, 0x3800840, 0xBA00859, 0xB00085C, 0xE00085E, 0xB00085F, 0x3800860, 0xB00086B, 0x3800870,
-  0x10400888, 0x3800889, 0xB00088F, 0xE200890, 0xB000892, 0x2800898, 0x38008A0, 0xCC008C9,
-  0x28008CA, 0xBA008D3, 0x7E008D4, 0xBA008E0, 0xE2008E2, 0xE6008E3, 0x28008EA, 0xE6008F0, 0x7E008FF,
-  0xF800903, 0x3800904, 0x7E0093A, 0xF80093B, 0x280093C, 0x380093D, 0xF80093E, 0x7E00941, 0xF800949,
-  0x280094D, 0xF80094E, 0x3800950, 0x2800951, 0x7E00955, 0x9200958, 0x3800960, 0x7E00962, 0x9A00964,
-  0x14200966, 0x9E00970, 0xCC00971, 0x3800972, 0x7E00981, 0xF800982, 0xB000984, 0x3800985,
-  0xB00098D, 0x380098F, 0xB000991, 0x3800993, 0xB0009A9, 0x38009AA, 0xB0009B1, 0x38009B2, 0xB0009B3,
-  0x38009B6, 0xB0009BA, 0x28009BC, 0x38009BD, 0x76009BE, 0xF8009BF, 0x7E009C1, 0xB0009C5, 0xF8009C7,
-  0xB0009C9, 0xF8009CB, 0x28009CD, 0x38009CE, 0xB0009CF, 0x76009D7, 0xB0009D8, 0x92009DC, 0xB0009DE,
-  0x92009DF, 0x38009E0, 0x7E009E2, 0xB0009E4, 0x142009E6, 0x38009F0, 0x9E009F2, 0x38009FC,
-  0x9E009FD, 0xBA009FE, 0xB0009FF, 0x7E00A01, 0xF800A03, 0xB000A04, 0x3800A05, 0xB000A0B, 0x3800A0F,
-  0xB000A11, 0x3800A13, 0xB000A29, 0x3800A2A, 0xB000A31, 0x3800A32, 0x9200A33, 0xB000A34, 0x3800A35,
-  0x9200A36, 0xB000A37, 0x3800A38, 0xB000A3A, 0x2800A3C, 0xB000A3D, 0xF800A3E, 0x7E00A41, 0xB000A43,
-  0x7E00A47, 0xB000A49, 0x7E00A4B, 0x2800A4D, 0xB000A4E, 0x7E00A51, 0xB000A52, 0x9200A59, 0x3800A5C,
-  0xB000A5D, 0x9200A5E, 0xB000A5F, 0x14200A66, 0x7E00A70, 0x3800A72, 0x7E00A75, 0x9E00A76,
-  0xB000A77, 0x7E00A81, 0xF800A83, 0xB000A84, 0x3800A85, 0xB000A8E, 0x3800A8F, 0xB000A92, 0x3800A93,
-  0xB000AA9, 0x3800AAA, 0xB000AB1, 0x3800AB2, 0xB000AB4, 0x3800AB5, 0xB000ABA, 0x2800ABC, 0x3800ABD,
-  0xF800ABE, 0x7E00AC1, 0xB000AC6, 0x7E00AC7, 0xF800AC9, 0xB000ACA, 0xF800ACB, 0x2800ACD, 0xB000ACE,
-  0x3800AD0, 0xB000AD1, 0x3800AE0, 0x7E00AE2, 0xB000AE4, 0x14200AE6, 0x9E00AF0, 0xB000AF2,
-  0x3800AF9, 0x7E00AFA, 0x2800AFD, 0xB000B00, 0x7E00B01, 0xF800B02, 0xB000B04, 0x3800B05, 0xB000B0D,
-  0x3800B0F, 0xB000B11, 0x3800B13, 0xB000B29, 0x3800B2A, 0xB000B31, 0x3800B32, 0xB000B34, 0x3800B35,
-  0xB000B3A, 0x2800B3C, 0x3800B3D, 0x7600B3E, 0x7E00B3F, 0xF800B40, 0x7E00B41, 0xB000B45, 0xF800B47,
-  0xB000B49, 0xF800B4B, 0x2800B4D, 0xB000B4E, 0x15600B55, 0x7E00B56, 0x7600B57, 0xB000B58,
-  0x9200B5C, 0xB000B5E, 0x3800B5F, 0x7E00B62, 0xB000B64, 0x14200B66, 0x9E00B70, 0x3800B71,
-  0x9E00B72, 0xB000B78, 0x7E00B82, 0x3800B83, 0xB000B84, 0x3800B85, 0xB000B8B, 0x3800B8E, 0xB000B91,
-  0x3800B92, 0xB000B96, 0x3800B99, 0xB000B9B, 0x3800B9C, 0xB000B9D, 0x3800B9E, 0xB000BA0, 0x3800BA3,
-  0xB000BA5, 0x3800BA8, 0xB000BAB, 0x3800BAE, 0xB000BBA, 0x7600BBE, 0xF800BBF, 0x7E00BC0, 0xF800BC1,
-  0xB000BC3, 0xF800BC6, 0xB000BC9, 0xF800BCA, 0x2800BCD, 0xB000BCE, 0x3800BD0, 0xB000BD1, 0x7600BD7,
-  0xB000BD8, 0x14200BE6, 0x9E00BF0, 0xB000BFB, 0x7E00C00, 0xF800C01, 0xBA00C04, 0x3800C05,
-  0xB000C0D, 0x3800C0E, 0xB000C11, 0x3800C12, 0xB000C29, 0x3800C2A, 0xB000C3A, 0x2800C3C, 0x3800C3D,
-  0x7E00C3E, 0xF800C41, 0xB000C45, 0x7E00C46, 0xB000C49, 0x7E00C4A, 0x2800C4D, 0xB000C4E, 0x7E00C55,
-  0xB000C57, 0x3800C58, 0xB000C5B, 0x3800C5D, 0xB000C5E, 0x3800C60, 0x7E00C62, 0xB000C64,
-  0x14200C66, 0xB000C70, 0x9E00C77, 0x3800C80, 0x7E00C81, 0xF800C82, 0x9E00C84, 0x3800C85,
-  0xB000C8D, 0x3800C8E, 0xB000C91, 0x3800C92, 0xB000CA9, 0x3800CAA, 0xB000CB4, 0x3800CB5, 0xB000CBA,
-  0x2800CBC, 0x3800CBD, 0xF800CBE, 0x7E00CBF, 0xF800CC0, 0x7600CC2, 0xF800CC3, 0xB000CC5, 0x7E00CC6,
-  0xF800CC7, 0xB000CC9, 0xF800CCA, 0x7E00CCC, 0x2800CCD, 0xB000CCE, 0x7600CD5, 0xB000CD7, 0x3800CDD,
-  0xB000CDF, 0x3800CE0, 0x7E00CE2, 0xB000CE4, 0x14200CE6, 0xB000CF0, 0x3800CF1, 0xB000CF3,
-  0x7E00D00, 0xF800D02, 0x3800D04, 0xB000D0D, 0x3800D0E, 0xB000D11, 0x3800D12, 0x2800D3B, 0x3800D3D,
-  0x7600D3E, 0xF800D3F, 0x7E00D41, 0xB000D45, 0xF800D46, 0xB000D49, 0xF800D4A, 0x2800D4D, 0x3800D4E,
-  0x9E00D4F, 0xB000D50, 0x3800D54, 0x7600D57, 0x9E00D58, 0x3800D5F, 0x7E00D62, 0xB000D64,
-  0x14200D66, 0x9E00D70, 0x3800D7A, 0xB000D80, 0x7E00D81, 0xF800D82, 0xB000D84, 0x3800D85,
-  0xB000D97, 0x3800D9A, 0xB000DB2, 0x3800DB3, 0xB000DBC, 0x3800DBD, 0xB000DBE, 0x3800DC0, 0xB000DC7,
-  0x2800DCA, 0xB000DCB, 0x7600DCF, 0xF800DD0, 0x7E00DD2, 0xB000DD5, 0x7E00DD6, 0xB000DD7, 0xF800DD8,
-  0x7600DDF, 0xB000DE0, 0x14200DE6, 0xB000DF0, 0xF800DF2, 0x9E00DF4, 0xB000DF5, 0x3800E01,
-  0x7E00E31, 0x3800E32, 0x14000E33, 0x7E00E34, 0xB000E3B, 0x9E00E3F, 0xDA00E40, 0x3800E45,
-  0xCE00E46, 0x2800E47, 0x7E00E4D, 0x2800E4E, 0x9E00E4F, 0x14200E50, 0xE000E5A, 0xB000E5C,
-  0x3800E81, 0xB000E83, 0x3800E84, 0xB000E85, 0x3800E86, 0xB000E8B, 0x3800E8C, 0xB000EA4, 0x3800EA5,
-  0xB000EA6, 0x3800EA7, 0x7E00EB1, 0x3800EB2, 0x14000EB3, 0x7E00EB4, 0x2800EBA, 0x7E00EBB,
-  0x3800EBD, 0xB000EBE, 0xDA00EC0, 0xB000EC5, 0xCE00EC6, 0xB000EC7, 0x2800EC8, 0x7E00ECD, 0xB000ECE,
-  0x14200ED0, 0xB000EDA, 0x7C00EDC, 0x3800EDE, 0xB000EE0, 0x3800F00, 0x9E00F01, 0xE000F08,
-  0x9E00F09, 0x6C00F0C, 0xE000F0D, 0x9E00F13, 0x2800F18, 0x9E00F1A, 0x14200F20, 0x9E00F2A,
-  0x2800F35, 0x9E00F36, 0x2800F37, 0x9E00F38, 0x2800F39, 0x6600F3A, 0xA00F3E, 0x3800F40, 0x9200F43,
-  0x3800F44, 0xB000F48, 0x3800F49, 0x9200F4D, 0x3800F4E, 0x9200F52, 0x3800F53, 0x9200F57, 0x3800F58,
-  0x9200F5C, 0x3800F5D, 0x9200F69, 0x3800F6A, 0xB000F6D, 0x7E00F71, 0x15C00F73, 0x7E00F74,
-  0x15C00F75, 0x15E00F77, 0x15C00F78, 0x15E00F79, 0x7E00F7A, 0xF800F7F, 0x7E00F80, 0x15C00F81,
-  0x2800F82, 0x9E00F85, 0x2800F86, 0x3800F88, 0x7E00F8D, 0x15C00F93, 0x7E00F94, 0xB000F98,
-  0x7E00F99, 0x15C00F9D, 0x7E00F9E, 0x15C00FA2, 0x7E00FA3, 0x15C00FA7, 0x7E00FA8, 0x15C00FAC,
-  0x7E00FAD, 0x15C00FB9, 0x7E00FBA, 0xB000FBD, 0x9E00FBE, 0x2800FC6, 0x9E00FC7, 0xB000FCD,
-  0x9E00FCE, 0xB000FDB, 0x3801000, 0xF80102B, 0x7E0102D, 0xF801031, 0x7E01032, 0x2801037, 0xF801038,
-  0x2801039, 0xF80103B, 0x7E0103D, 0x380103F, 0x14201040, 0x9A0104A, 0x9E0104C, 0x3801050,
-  0xF801056, 0x7E01058, 0x380105A, 0x7E0105E, 0x3801061, 0xF801062, 0x2201063, 0x3801065, 0xF801067,
-  0x2201069, 0x380106E, 0x7E01071, 0x3801075, 0x7E01082, 0xF801083, 0x7E01085, 0x2201087, 0xE60108D,
-  0x380108E, 0x220108F, 0x14201090, 0x220109A, 0xF80109C, 0x7E0109D, 0x9E0109E, 0xB4010A0,
-  0xB0010C6, 0xB4010C7, 0xB0010C8, 0xB4010CD, 0xB0010CE, 0x136010D0, 0x9E010FB, 0x132010FC,
-  0x136010FD, 0x3801100, 0xC60115F, 0x3801161, 0xB001249, 0x380124A, 0xB00124E, 0x3801250,
-  0xB001257, 0x3801258, 0xB001259, 0x380125A, 0xB00125E, 0x3801260, 0xB001289, 0x380128A, 0xB00128E,
-  0x3801290, 0xB0012B1, 0x38012B2, 0xB0012B6, 0x38012B8, 0xB0012BF, 0x38012C0, 0xB0012C1, 0x38012C2,
-  0xB0012C6, 0x38012C8, 0xB0012D7, 0x38012D8, 0xB001311, 0x3801312, 0xB001316, 0x3801318, 0xB00135B,
-  0x280135D, 0x9E01360, 0xE001361, 0x9A01362, 0xE001363, 0x9A01367, 0x14201369, 0x9E01372,
-  0xB00137D, 0x3801380, 0x9E01390, 0xB00139A, 0x60013A0, 0xB0013F6, 0x144013F8, 0xB0013FE,
-  0x10601400, 0x3801401, 0x9E0166D, 0x9A0166E, 0x380166F, 0x16401680, 0x3801681, 0x660169B,
-  0xB00169D, 0x38016A0, 0xE0016EB, 0x38016EE, 0xB0016F9, 0x3801700, 0x7E01712, 0x2801714, 0xA01715,
-  0xB001716, 0x380171F, 0x7E01732, 0x14201734, 0x9A01735, 0xB001737, 0x3801740, 0x7E01752,
-  0xB001754, 0x3801760, 0xB00176D, 0x380176E, 0xB001771, 0x7E01772, 0xB001774, 0x3801780,
-  0x150017A3, 0x38017A5, 0x2A017B4, 0xF8017B6, 0x7E017B7, 0xF8017BE, 0x7E017C6, 0xF8017C7,
-  0x28017C9, 0xE0017D4, 0x2C017D7, 0x9E017D8, 0xE0017DA, 0x9E017DB, 0x38017DC, 0x28017DD, 0xB0017DE,
-  0x142017E0, 0xB0017EA, 0x9E017F0, 0xB0017FA, 0x9E01800, 0xE001802, 0x9A01803, 0xE001804,
-  0x10601806, 0x9E01807, 0xE001808, 0x9A01809, 0x740180A, 0x1A0180B, 0x12C0180E, 0x1A0180F,
-  0x14201810, 0xB00181A, 0x3801820, 0xCE01843, 0x3801844, 0xB001879, 0x3801880, 0x9801885,
-  0x3801887, 0x7E018A9, 0x38018AA, 0xB0018AB, 0x38018B0, 0xB0018F6, 0x3801900, 0xB00191F, 0x7E01920,
-  0xF801923, 0x7E01927, 0xF801929, 0xB00192C, 0xF801930, 0x7E01932, 0xF801933, 0x2801939, 0xB00193C,
-  0x9E01940, 0xB001941, 0x9A01944, 0x14201946, 0x3801950, 0xB00196E, 0x3801970, 0xB001975,
-  0x3801980, 0xB0019AC, 0x38019B0, 0xDA019B5, 0x38019B8, 0xDA019BA, 0x38019BB, 0xB0019CA,
-  0x142019D0, 0xB0019DB, 0x9E019DE, 0x3801A00, 0x7E01A17, 0xF801A19, 0x7E01A1B, 0xB001A1C,
-  0x9E01A1E, 0x3801A20, 0xF801A55, 0x7E01A56, 0xF801A57, 0x7E01A58, 0xB001A5F, 0xBA01A60, 0xF801A61,
-  0x7E01A62, 0xF801A63, 0x7E01A65, 0xF801A6D, 0x7E01A73, 0x2801A75, 0xB001A7D, 0x2801A7F,
-  0x14201A80, 0xB001A8A, 0x14201A90, 0xB001A9A, 0x9E01AA0, 0xCE01AA7, 0x9A01AA8, 0x9E01AAC,
-  0xB001AAE, 0x2801AB0, 0x14601ABE, 0x7E01ABF, 0x2801AC1, 0x7E01ACC, 0xB001ACF, 0x7E01B00,
-  0xF801B04, 0x3801B05, 0x2801B34, 0x7601B35, 0x7E01B36, 0xF801B3B, 0x7E01B3C, 0xF801B3D, 0x7E01B42,
-  0xF801B43, 0xA01B44, 0x3801B45, 0xB001B4D, 0x14201B50, 0x9A01B5A, 0x9E01B5C, 0xE001B5D, 0x9A01B5E,
-  0x9E01B60, 0x2801B6B, 0x9E01B74, 0x9A01B7D, 0xB001B7F, 0x7E01B80, 0xF801B82, 0x3801B83, 0xF801BA1,
-  0x7E01BA2, 0xF801BA6, 0x7E01BA8, 0xA01BAA, 0x2801BAB, 0x7E01BAC, 0x3801BAE, 0x14201BB0, 0x3801BBA,
-  0xBA01BE6, 0xF801BE7, 0x7E01BE8, 0xF801BEA, 0x7E01BED, 0xF801BEE, 0x7E01BEF, 0x14201BF2,
-  0xB001BF4, 0x9E01BFC, 0x3801C00, 0xF801C24, 0x7E01C2C, 0xF801C34, 0x17201C36, 0x2801C37,
-  0xB001C38, 0x9A01C3B, 0xE001C3D, 0x14201C40, 0xB001C4A, 0x3801C4D, 0x14201C50, 0x3801C5A,
-  0xCC01C78, 0x12A01C7B, 0xCC01C7C, 0x9A01C7E, 0x14401C80, 0xB001C89, 0xB401C90, 0xB001CBB,
-  0xB401CBD, 0x9E01CC0, 0xB001CC8, 0x2801CD0, 0x13A01CD3, 0x2801CD4, 0xA01CE1, 0x2801CE2, 0x3801CE9,
-  0x2801CED, 0x3801CEE, 0x2801CF4, 0x3801CF5, 0xA01CF7, 0x2801CF8, 0x3801CFA, 0xB001CFB, 0x6401D00,
-  0xDE01D2C, 0x4601D2F, 0xDE01D30, 0x4601D3B, 0xDE01D3C, 0x4601D4E, 0xDE01D4F, 0xE401D62, 0xDE01D63,
-  0x6401D6B, 0x16E01D78, 0xFC01D79, 0x6401D7A, 0xFC01D7D, 0x6401D7E, 0xFC01D8E, 0x6401D8F,
-  0xAA01D96, 0x6401D97, 0x16E01D9B, 0x13401DA4, 0x16E01DA5, 0x13401DA8, 0x16E01DA9, 0xBA01DC0,
-  0x2801DC4, 0xBA01DD0, 0x7E01DE7, 0x2801DF5, 0xB401E00, 0xFC01E01, 0xB401E02, 0xFC01E03, 0xB401E04,
-  0xFC01E05, 0xB401E06, 0xFC01E07, 0xB401E08, 0xFC01E09, 0xB401E0A, 0xFC01E0B, 0xB401E0C, 0xFC01E0D,
-  0xB401E0E, 0xFC01E0F, 0xB401E10, 0xFC01E11, 0xB401E12, 0xFC01E13, 0xB401E14, 0xFC01E15, 0xB401E16,
-  0xFC01E17, 0xB401E18, 0xFC01E19, 0xB401E1A, 0xFC01E1B, 0xB401E1C, 0xFC01E1D, 0xB401E1E, 0xFC01E1F,
-  0xB401E20, 0xFC01E21, 0xB401E22, 0xFC01E23, 0xB401E24, 0xFC01E25, 0xB401E26, 0xFC01E27, 0xB401E28,
-  0xFC01E29, 0xB401E2A, 0xFC01E2B, 0xB401E2C, 0x10001E2D, 0xB401E2E, 0xFC01E2F, 0xB401E30,
-  0xFC01E31, 0xB401E32, 0xFC01E33, 0xB401E34, 0xFC01E35, 0xB401E36, 0xFC01E37, 0xB401E38, 0xFC01E39,
-  0xB401E3A, 0xFC01E3B, 0xB401E3C, 0xFC01E3D, 0xB401E3E, 0xFC01E3F, 0xB401E40, 0xFC01E41, 0xB401E42,
-  0xFC01E43, 0xB401E44, 0xFC01E45, 0xB401E46, 0xFC01E47, 0xB401E48, 0xFC01E49, 0xB401E4A, 0xFC01E4B,
-  0xB401E4C, 0xFC01E4D, 0xB401E4E, 0xFC01E4F, 0xB401E50, 0xFC01E51, 0xB401E52, 0xFC01E53, 0xB401E54,
-  0xFC01E55, 0xB401E56, 0xFC01E57, 0xB401E58, 0xFC01E59, 0xB401E5A, 0xFC01E5B, 0xB401E5C, 0xFC01E5D,
-  0xB401E5E, 0xFC01E5F, 0xB401E60, 0xFC01E61, 0xB401E62, 0xFC01E63, 0xB401E64, 0xFC01E65, 0xB401E66,
-  0xFC01E67, 0xB401E68, 0xFC01E69, 0xB401E6A, 0xFC01E6B, 0xB401E6C, 0xFC01E6D, 0xB401E6E, 0xFC01E6F,
-  0xB401E70, 0xFC01E71, 0xB401E72, 0xFC01E73, 0xB401E74, 0xFC01E75, 0xB401E76, 0xFC01E77, 0xB401E78,
-  0xFC01E79, 0xB401E7A, 0xFC01E7B, 0xB401E7C, 0xFC01E7D, 0xB401E7E, 0xFC01E7F, 0xB401E80, 0xFC01E81,
-  0xB401E82, 0xFC01E83, 0xB401E84, 0xFC01E85, 0xB401E86, 0xFC01E87, 0xB401E88, 0xFC01E89, 0xB401E8A,
-  0xFC01E8B, 0xB401E8C, 0xFC01E8D, 0xB401E8E, 0xFC01E8F, 0xB401E90, 0xFC01E91, 0xB401E92, 0xFC01E93,
-  0xB401E94, 0xFC01E95, 0x14401E9A, 0x6401E9C, 0xB401E9E, 0x6401E9F, 0xB401EA0, 0xFC01EA1,
-  0xB401EA2, 0xFC01EA3, 0xB401EA4, 0xFC01EA5, 0xB401EA6, 0xFC01EA7, 0xB401EA8, 0xFC01EA9, 0xB401EAA,
-  0xFC01EAB, 0xB401EAC, 0xFC01EAD, 0xB401EAE, 0xFC01EAF, 0xB401EB0, 0xFC01EB1, 0xB401EB2, 0xFC01EB3,
-  0xB401EB4, 0xFC01EB5, 0xB401EB6, 0xFC01EB7, 0xB401EB8, 0xFC01EB9, 0xB401EBA, 0xFC01EBB, 0xB401EBC,
-  0xFC01EBD, 0xB401EBE, 0xFC01EBF, 0xB401EC0, 0xFC01EC1, 0xB401EC2, 0xFC01EC3, 0xB401EC4, 0xFC01EC5,
-  0xB401EC6, 0xFC01EC7, 0xB401EC8, 0xFC01EC9, 0xB401ECA, 0x10001ECB, 0xB401ECC, 0xFC01ECD,
-  0xB401ECE, 0xFC01ECF, 0xB401ED0, 0xFC01ED1, 0xB401ED2, 0xFC01ED3, 0xB401ED4, 0xFC01ED5, 0xB401ED6,
-  0xFC01ED7, 0xB401ED8, 0xFC01ED9, 0xB401EDA, 0xFC01EDB, 0xB401EDC, 0xFC01EDD, 0xB401EDE, 0xFC01EDF,
-  0xB401EE0, 0xFC01EE1, 0xB401EE2, 0xFC01EE3, 0xB401EE4, 0xFC01EE5, 0xB401EE6, 0xFC01EE7, 0xB401EE8,
-  0xFC01EE9, 0xB401EEA, 0xFC01EEB, 0xB401EEC, 0xFC01EED, 0xB401EEE, 0xFC01EEF, 0xB401EF0, 0xFC01EF1,
-  0xB401EF2, 0xFC01EF3, 0xB401EF4, 0xFC01EF5, 0xB401EF6, 0xFC01EF7, 0xB401EF8, 0xFC01EF9, 0xB401EFA,
-  0xFC01EFB, 0xB401EFC, 0xFC01EFD, 0xB401EFE, 0xFC01EFF, 0xB401F08, 0xFC01F10, 0xB001F16, 0xB401F18,
-  0xB001F1E, 0xFC01F20, 0xB401F28, 0xFC01F30, 0xB401F38, 0xFC01F40, 0xB001F46, 0xB401F48, 0xB001F4E,
-  0xFC01F50, 0xB001F58, 0xB401F59, 0xB001F5A, 0xB401F5B, 0xB001F5C, 0xB401F5D, 0xB001F5E, 0xB401F5F,
-  0xFC01F60, 0xB401F68, 0xFC01F70, 0x3C01F71, 0xFC01F72, 0x3C01F73, 0xFC01F74, 0x3C01F75, 0xFC01F76,
-  0x3C01F77, 0xFC01F78, 0x3C01F79, 0xFC01F7A, 0x3C01F7B, 0xFC01F7C, 0x3C01F7D, 0xB001F7E,
-  0x14401F80, 0x12601F88, 0x14401F90, 0x12601F98, 0x14401FA0, 0x12601FA8, 0xFC01FB0, 0x14401FB2,
-  0xB001FB5, 0xFC01FB6, 0x14401FB7, 0xB401FB8, 0x3E01FBB, 0x12601FBC, 0x9C01FBD, 0x3C01FBE,
-  0x9C01FBF, 0x14401FC2, 0xB001FC5, 0xFC01FC6, 0x14401FC7, 0xB401FC8, 0x3E01FC9, 0xB401FCA,
-  0x3E01FCB, 0x12601FCC, 0x9C01FCD, 0xFC01FD0, 0x3C01FD3, 0xB001FD4, 0xFC01FD6, 0xB401FD8,
-  0x3E01FDB, 0xB001FDC, 0x9C01FDD, 0xFC01FE0, 0x3C01FE3, 0xFC01FE4, 0xB401FE8, 0x3E01FEB, 0xB401FEC,
-  0x9C01FED, 0x6E01FEE, 0xB001FF0, 0x14401FF2, 0xB001FF5, 0xFC01FF6, 0x14401FF7, 0xB401FF8,
-  0x3E01FF9, 0xB401FFA, 0x3E01FFB, 0x12601FFC, 0x6E01FFD, 0x9C01FFE, 0xB001FFF, 0x17402000,
-  0x14E02002, 0x12C0200B, 0xA80200C, 0x1700200D, 0x940200E, 0x16C02010, 0x11C02011, 0x16C02012,
-  0x13E02016, 0x2002017, 0x8A02018, 0xAE0201A, 0x4E02020, 0xA402024, 0x2002025, 0x802027, 0x1402028,
-  0xB80202A, 0x14E0202F, 0x4E02030, 0x13E02032, 0x11202033, 0x4E02035, 0x2002036, 0x4E02038,
-  0x8802039, 0x4E0203B, 0x1160203C, 0x12E0203D, 0x200203E, 0x1420203F, 0x4402040, 0x4E02041,
-  0x13E02044, 0x7202045, 0x15202047, 0x11602049, 0x4E0204A, 0x13E02052, 0x16C02053, 0x14202054,
-  0x4E02055, 0x2002057, 0x4E02058, 0x14E0205F, 0x12C02060, 0x16602061, 0x12202065, 0xB802066,
-  0x360206A, 0x6C02070, 0x13402071, 0xB002072, 0x6C02074, 0x860207A, 0x260207B, 0x860207C,
-  0x680207D, 0x16E0207F, 0x6C02080, 0x860208A, 0x260208B, 0x860208C, 0x680208D, 0xB00208F,
-  0x16E02090, 0xB00209D, 0x9E020A0, 0x6C020A8, 0x9E020A9, 0xB0020C1, 0x14C020D0, 0x13C020DD,
-  0x14C020E1, 0x13C020E2, 0x14C020E5, 0xBA020E7, 0x14C020EB, 0xBA020F0, 0xB0020F1, 0x6C02100,
-  0xA602102, 0x6C02103, 0x9E02104, 0x6C02105, 0xA602107, 0x9E02108, 0x6C02109, 0x11A0210A,
-  0xA60210B, 0x11A0210E, 0xA602110, 0x11A02113, 0x9E02114, 0xA602115, 0x6C02116, 0x9E02117,
-  0x12802118, 0xA602119, 0x9E0211E, 0x6C02120, 0x16002122, 0x9E02123, 0xA602124, 0x9E02125,
-  0x3E02126, 0x9E02127, 0xA602128, 0xC002129, 0x3E0212A, 0xA60212C, 0xE80212E, 0x11A0212F,
-  0xA602130, 0xB402132, 0xA602133, 0x11A02134, 0xEE02135, 0x4802139, 0x9E0213A, 0x6C0213B,
-  0x11A0213C, 0xA60213E, 0x6802140, 0xC002141, 0xA602145, 0x11A02146, 0xC402148, 0x9E0214A,
-  0xC00214B, 0x9E0214C, 0xFC0214E, 0x9E0214F, 0x6C02150, 0xB402160, 0x8E02170, 0x3802180, 0xB402183,
-  0xFC02184, 0x3802185, 0x6C02189, 0x9E0218A, 0xB00218C, 0x13E02190, 0xBC02194, 0x13E0219A,
-  0x4E021A8, 0xBC021A9, 0x13E021AB, 0x4E021AF, 0x13E021B0, 0x4E021B2, 0x13E021B6, 0x4E021B8,
-  0x13E021BC, 0x4E021DC, 0x13E021DD, 0x4E021DE, 0x13E021E4, 0x4E021E6, 0x13E021F4, 0x4202201,
-  0x13E02205, 0x4202208, 0x13E0220E, 0x4202211, 0x14802212, 0x13E02213, 0x4202215, 0x13E02217,
-  0x420221A, 0x13E0221E, 0x420221F, 0x13E02223, 0x4202224, 0x13E02225, 0x4202226, 0x13E02227,
-  0x420222B, 0x1240222C, 0x420222E, 0x1240222F, 0x4202231, 0x13E02234, 0x4202239, 0x13E0223A,
-  0x420223B, 0x13E0224D, 0x4202252, 0x13E02256, 0x420225F, 0x13E02261, 0x4202262, 0x13E02263,
-  0x4202264, 0x13E0226C, 0x420226E, 0x13E0228D, 0x420228F, 0x13E02293, 0x4202298, 0x13E02299,
-  0x42022A2, 0x13E022A4, 0x42022A6, 0x13E022B9, 0x42022BE, 0x13E022C0, 0x42022C9, 0x13E022CE,
-  0x42022D0, 0x13E022D2, 0x42022D6, 0x13E022EE, 0x42022F0, 0x4E02300, 0x4202308, 0x4E0230C,
-  0xD80231A, 0x4E0231C, 0x4202320, 0x4E02322, 0x16A02328, 0x1E02329, 0x4E0232B, 0x13E0237C,
-  0x4E0237D, 0x13E0239B, 0x4E023B6, 0x13E023B7, 0x4E023B8, 0x16A023CF, 0x13E023D0, 0x4E023D1,
-  0x13E023DC, 0x4E023E3, 0xD8023E9, 0x16A023ED, 0xD8023F0, 0x16A023F1, 0xD8023F3, 0x4E023F4,
-  0x16A023F8, 0x4E023FB, 0xFA02427, 0x4E02440, 0xFA0244B, 0x6C02460, 0x4A024B6, 0xA0024C2,
-  0x4A024C3, 0x4C024D0, 0x6C024EA, 0x9E024EB, 0x4E02500, 0x13E025A0, 0x4E025A2, 0x16A025AA,
-  0x4E025AC, 0x13E025AE, 0xBC025B6, 0x13E025B7, 0x4E025B8, 0x13E025BC, 0xBC025C0, 0x13E025C1,
-  0x4E025C2, 0x13E025C6, 0x4E025C8, 0x13E025CA, 0x4E025CC, 0x13E025CF, 0x4E025D4, 0x13E025E2,
-  0x4E025E3, 0x13E025E4, 0x4E025E5, 0x13E025E7, 0x4E025ED, 0x13E025F8, 0xBC025FB, 0x114025FD,
-  0x13E025FF, 0x16A02600, 0x13E02605, 0x4E02607, 0x16A0260E, 0x4E0260F, 0x16A02611, 0x4E02612,
-  0xD802614, 0x4E02616, 0x16A02618, 0x4E02619, 0x60261D, 0x4E0261E, 0x16A02620, 0x4E02621,
-  0x16A02622, 0x4E02624, 0x16A02626, 0x4E02627, 0x16A0262A, 0x4E0262B, 0x16A0262E, 0x4E02630,
-  0x16A02638, 0x4E0263B, 0xBC02640, 0x4E02641, 0xBC02642, 0x4E02643, 0xD802648, 0x4E02654,
-  0x16A0265F, 0xBC02660, 0x13E02661, 0xBC02663, 0x4E02664, 0x16A02665, 0x4E02667, 0x16A02668,
-  0x4E02669, 0x13E0266D, 0x4E02670, 0x16A0267B, 0x4E0267C, 0x16A0267E, 0xD80267F, 0x4E02680,
-  0x16A02692, 0xD802693, 0x16A02694, 0x4E02698, 0x16A02699, 0x4E0269A, 0x16A0269B, 0x4E0269D,
-  0x16A026A0, 0xD8026A1, 0x4E026A2, 0x16A026A7, 0x4E026A8, 0xD8026AA, 0x4E026AC, 0x16A026B0,
-  0x4E026B2, 0xD8026BD, 0x4E026BF, 0xD8026C4, 0x4E026C6, 0x16A026C8, 0x4E026C9, 0xD8026CE,
-  0x16A026CF, 0x4E026D0, 0x16A026D1, 0x4E026D2, 0x16A026D3, 0xD8026D4, 0x4E026D5, 0x16A026E9,
-  0xD8026EA, 0x4E026EB, 0x16A026F0, 0xD8026F2, 0x16A026F4, 0xD8026F5, 0x4E026F6, 0x16A026F7,
-  0x6026F9, 0xD8026FA, 0x4E026FB, 0xD8026FD, 0x4E026FE, 0x16A02702, 0x4E02703, 0xD802705, 0x4E02706,
-  0x16A02708, 0xD40270A, 0x60270C, 0x4E0270E, 0x16A0270F, 0x4E02710, 0x16A02712, 0x4E02713,
-  0x16A02714, 0x4E02715, 0x16A02716, 0x4E02717, 0x16A0271D, 0x4E0271E, 0x16A02721, 0x4E02722,
-  0xD802728, 0x4E02729, 0x16A02733, 0x4E02735, 0x16A02744, 0x4E02745, 0x16A02747, 0x4E02748,
-  0xD80274C, 0x4E0274D, 0xD80274E, 0x4E0274F, 0xD802753, 0x4E02756, 0xD802757, 0x4E02758,
-  0x16A02763, 0x4E02765, 0x7202768, 0x9E02776, 0x4E02794, 0xD802795, 0x4E02798, 0x16A027A1,
-  0x4E027A2, 0xD8027B0, 0x4E027B1, 0xD8027BF, 0x42027C0, 0x13E027C1, 0x42027C3, 0x13E027C7,
-  0x42027C8, 0x13E027CA, 0x42027CB, 0x13E027CE, 0x42027D3, 0x13E027D7, 0x42027DC, 0x13E027DF,
-  0x42027E2, 0x13E027F0, 0x4E02800, 0x13E02900, 0xBC02934, 0x13E02936, 0x4202983, 0x13E02999,
-  0x420299B, 0x13E029A1, 0x42029A2, 0x13E029B0, 0x42029B8, 0x13E029B9, 0x42029C0, 0x13E029C6,
-  0x42029C9, 0x13E029CA, 0x42029CE, 0x13E029D3, 0x42029D4, 0x13E029D6, 0x42029D8, 0x13E029DD,
-  0x42029E1, 0x13E029E2, 0x42029E3, 0x13E029E6, 0x42029E8, 0x13E029EA, 0x42029F4, 0x13E029FA,
-  0x42029FC, 0x13E029FE, 0x4202A0A, 0x12402A0C, 0x4202A0D, 0x13E02A1D, 0x4202A1E, 0x13E02A22,
-  0x4202A24, 0x13E02A25, 0x4202A26, 0x13E02A27, 0x4202A29, 0x13E02A2A, 0x4202A2B, 0x13E02A2F,
-  0x4202A34, 0x13E02A36, 0x4202A3C, 0x13E02A3F, 0x4202A57, 0x13E02A59, 0x4202A64, 0x13E02A66,
-  0x4202A6A, 0x13E02A6E, 0x4202A6F, 0x13E02A71, 0x4202A73, 0x12402A74, 0x11202A75, 0x13E02A77,
-  0x4202A79, 0x13E02AA4, 0x4202AA6, 0x13E02AAE, 0x4202AAF, 0x13E02AD7, 0x1C02ADC, 0x13E02ADD,
-  0x4202ADE, 0x13E02ADF, 0x4202AE2, 0x13E02AE7, 0x4202AEC, 0x13E02AEF, 0x4202AF3, 0x13E02AF4,
-  0x4202AF7, 0x13E02AFC, 0x4202AFD, 0x13E02AFE, 0x4E02B00, 0x16A02B05, 0x4E02B08, 0xD802B1B,
-  0x4E02B1D, 0x13E02B30, 0x4E02B45, 0x13E02B47, 0x4E02B4D, 0xD802B50, 0x4E02B51, 0xD802B55,
-  0x4E02B56, 0xFA02B74, 0x4E02B76, 0xFA02B96, 0x4E02B97, 0x7202BFE, 0x4E02BFF, 0xB402C00, 0xFC02C30,
-  0xB402C60, 0xFC02C61, 0xB402C62, 0xFC02C65, 0xB402C67, 0xFC02C68, 0xB402C69, 0xFC02C6A, 0xB402C6B,
-  0xFC02C6C, 0xB402C6D, 0x6402C71, 0xB402C72, 0xFC02C73, 0x6402C74, 0xB402C75, 0xFC02C76, 0x6402C77,
-  0x13402C7C, 0x16E02C7D, 0xB402C7E, 0xFC02C81, 0xB402C82, 0xFC02C83, 0xB402C84, 0xFC02C85,
-  0xB402C86, 0xFC02C87, 0xB402C88, 0xFC02C89, 0xB402C8A, 0xFC02C8B, 0xB402C8C, 0xFC02C8D, 0xB402C8E,
-  0xFC02C8F, 0xB402C90, 0xFC02C91, 0xB402C92, 0xFC02C93, 0xB402C94, 0xFC02C95, 0xB402C96, 0xFC02C97,
-  0xB402C98, 0xFC02C99, 0xB402C9A, 0xFC02C9B, 0xB402C9C, 0xFC02C9D, 0xB402C9E, 0xFC02C9F, 0xB402CA0,
-  0xFC02CA1, 0xB402CA2, 0xFC02CA3, 0xB402CA4, 0xFC02CA5, 0xB402CA6, 0xFC02CA7, 0xB402CA8, 0xFC02CA9,
-  0xB402CAA, 0xFC02CAB, 0xB402CAC, 0xFC02CAD, 0xB402CAE, 0xFC02CAF, 0xB402CB0, 0xFC02CB1, 0xB402CB2,
-  0xFC02CB3, 0xB402CB4, 0xFC02CB5, 0xB402CB6, 0xFC02CB7, 0xB402CB8, 0xFC02CB9, 0xB402CBA, 0xFC02CBB,
-  0xB402CBC, 0xFC02CBD, 0xB402CBE, 0xFC02CBF, 0xB402CC0, 0xFC02CC1, 0xB402CC2, 0xFC02CC3, 0xB402CC4,
-  0xFC02CC5, 0xB402CC6, 0xFC02CC7, 0xB402CC8, 0xFC02CC9, 0xB402CCA, 0xFC02CCB, 0xB402CCC, 0xFC02CCD,
-  0xB402CCE, 0xFC02CCF, 0xB402CD0, 0xFC02CD1, 0xB402CD2, 0xFC02CD3, 0xB402CD4, 0xFC02CD5, 0xB402CD6,
-  0xFC02CD7, 0xB402CD8, 0xFC02CD9, 0xB402CDA, 0xFC02CDB, 0xB402CDC, 0xFC02CDD, 0xB402CDE, 0xFC02CDF,
-  0xB402CE0, 0xFC02CE1, 0xB402CE2, 0xFC02CE3, 0x6402CE4, 0x9E02CE5, 0xB402CEB, 0xFC02CEC, 0xB402CED,
-  0xFC02CEE, 0x2802CEF, 0xB402CF2, 0xFC02CF3, 0xB002CF4, 0x9E02CF9, 0xFC02D00, 0xB002D26, 0xFC02D27,
-  0xB002D28, 0xFC02D2D, 0xB002D2E, 0x3802D30, 0xB002D68, 0x13202D6F, 0x9E02D70, 0xB002D71,
-  0xBA02D7F, 0x3802D80, 0xB002D97, 0x3802DA0, 0xB002DA7, 0x3802DA8, 0xB002DAF, 0x3802DB0, 0xB002DB7,
-  0x3802DB8, 0xB002DBF, 0x3802DC0, 0xB002DC7, 0x3802DC8, 0xB002DCF, 0x3802DD0, 0xB002DD7, 0x3802DD8,
-  0xB002DDF, 0x7E02DE0, 0x4E02E00, 0x7202E02, 0x4E02E06, 0x7202E09, 0x4E02E0B, 0x7202E0C, 0x4E02E0E,
-  0x16C02E17, 0x4E02E18, 0x16C02E1A, 0x4E02E1B, 0x7202E1C, 0x4E02E1E, 0x7202E20, 0x4E02E2A,
-  0x12E02E2E, 0x10802E2F, 0x4E02E30, 0x16C02E3A, 0x12E02E3C, 0x4E02E3D, 0x16C02E40, 0x7002E41,
-  0xAE02E42, 0x4E02E43, 0x7002E4C, 0x4E02E4D, 0x7002E4E, 0x4E02E50, 0x12E02E53, 0x7202E55,
-  0x16C02E5D, 0xFA02E5E, 0xDC02E80, 0xB002E9A, 0xDC02E9B, 0xB202E9F, 0xDC02EA0, 0xB202EF3,
-  0xB002EF4, 0xB202F00, 0xB002FD6, 0x5C02FF0, 0x8002FF2, 0x5C02FF4, 0xB002FFC, 0x14E03000,
-  0x7003001, 0x12E03002, 0x4E03003, 0x9E03004, 0xCE03005, 0x5E03006, 0x7203008, 0x880300C,
-  0x7203010, 0x4E03012, 0x7203014, 0x16C0301C, 0xAE0301D, 0x4E03020, 0x5E03021, 0x280302A,
-  0x520302E, 0x5003030, 0xCE03031, 0x6C03036, 0x9E03037, 0x10C03038, 0x2C0303B, 0x380303C,
-  0xC80303D, 0x9E0303E, 0xB003040, 0x3803041, 0xB003097, 0x2803099, 0xF40309B, 0xCE0309D, 0x7C0309F,
-  0x106030A0, 0x38030A1, 0x9E030FB, 0x12A030FC, 0xCE030FD, 0x7C030FF, 0xB003100, 0x3803105,
-  0xB003130, 0x7C03131, 0xC603164, 0x7C03165, 0xB00318F, 0x9E03190, 0x6C03192, 0x38031A0, 0x9E031C0,
-  0xB0031E4, 0x38031F0, 0x6C03200, 0xB00321F, 0x6C03220, 0x9E03248, 0x6C03250, 0x9E0327F, 0x6C03280,
-  0x16003297, 0x6C03298, 0x16003299, 0x6C0329A, 0x4003400, 0x9E04DC0, 0x4004E00, 0x380A000,
-  0xCE0A015, 0x380A016, 0xB00A48D, 0x9E0A490, 0xB00A4C7, 0x380A4D0, 0x2C0A4F8, 0xE00A4FE, 0x9A0A4FF,
-  0x380A500, 0xCE0A60C, 0xE00A60D, 0x9A0A60E, 0x380A610, 0x1420A620, 0x380A62A, 0xB00A62C,
-  0xB40A640, 0xFC0A641, 0xB40A642, 0xFC0A643, 0xB40A644, 0xFC0A645, 0xB40A646, 0xFC0A647, 0xB40A648,
-  0xFC0A649, 0xB40A64A, 0xFC0A64B, 0xB40A64C, 0xFC0A64D, 0xB40A64E, 0xFC0A64F, 0xB40A650, 0xFC0A651,
-  0xB40A652, 0xFC0A653, 0xB40A654, 0xFC0A655, 0xB40A656, 0xFC0A657, 0xB40A658, 0xFC0A659, 0xB40A65A,
-  0xFC0A65B, 0xB40A65C, 0xFC0A65D, 0xB40A65E, 0xFC0A65F, 0xB40A660, 0xFC0A661, 0xB40A662, 0xFC0A663,
-  0xB40A664, 0xFC0A665, 0xB40A666, 0xFC0A667, 0xB40A668, 0xFC0A669, 0xB40A66A, 0xFC0A66B, 0xB40A66C,
-  0xFC0A66D, 0x380A66E, 0x280A66F, 0x13C0A670, 0x9E0A673, 0x7E0A674, 0x280A67C, 0x9E0A67E,
-  0xCC0A67F, 0xB40A680, 0xFC0A681, 0xB40A682, 0xFC0A683, 0xB40A684, 0xFC0A685, 0xB40A686, 0xFC0A687,
-  0xB40A688, 0xFC0A689, 0xB40A68A, 0xFC0A68B, 0xB40A68C, 0xFC0A68D, 0xB40A68E, 0xFC0A68F, 0xB40A690,
-  0xFC0A691, 0xB40A692, 0xFC0A693, 0xB40A694, 0xFC0A695, 0xB40A696, 0xFC0A697, 0xB40A698, 0xFC0A699,
-  0xB40A69A, 0xFC0A69B, 0xDE0A69C, 0x7E0A69E, 0x380A6A0, 0x280A6F0, 0x9E0A6F2, 0x9A0A6F3, 0xE00A6F4,
-  0x9A0A6F7, 0xB00A6F8, 0xFE0A700, 0xCC0A717, 0xFE0A720, 0xB40A722, 0xFC0A723, 0xB40A724, 0xFC0A725,
-  0xB40A726, 0xFC0A727, 0xB40A728, 0xFC0A729, 0xB40A72A, 0xFC0A72B, 0xB40A72C, 0xFC0A72D, 0xB40A72E,
-  0xFC0A72F, 0x640A730, 0xB40A732, 0xFC0A733, 0xB40A734, 0xFC0A735, 0xB40A736, 0xFC0A737, 0xB40A738,
-  0xFC0A739, 0xB40A73A, 0xFC0A73B, 0xB40A73C, 0xFC0A73D, 0xB40A73E, 0xFC0A73F, 0xB40A740, 0xFC0A741,
-  0xB40A742, 0xFC0A743, 0xB40A744, 0xFC0A745, 0xB40A746, 0xFC0A747, 0xB40A748, 0xFC0A749, 0xB40A74A,
-  0xFC0A74B, 0xB40A74C, 0xFC0A74D, 0xB40A74E, 0xFC0A74F, 0xB40A750, 0xFC0A751, 0xB40A752, 0xFC0A753,
-  0xB40A754, 0xFC0A755, 0xB40A756, 0xFC0A757, 0xB40A758, 0xFC0A759, 0xB40A75A, 0xFC0A75B, 0xB40A75C,
-  0xFC0A75D, 0xB40A75E, 0xFC0A75F, 0xB40A760, 0xFC0A761, 0xB40A762, 0xFC0A763, 0xB40A764, 0xFC0A765,
-  0xB40A766, 0xFC0A767, 0xB40A768, 0xFC0A769, 0xB40A76A, 0xFC0A76B, 0xB40A76C, 0xFC0A76D, 0xB40A76E,
-  0xFC0A76F, 0x16E0A770, 0x640A771, 0xB40A779, 0xFC0A77A, 0xB40A77B, 0xFC0A77C, 0xB40A77D,
-  0xFC0A77F, 0xB40A780, 0xFC0A781, 0xB40A782, 0xFC0A783, 0xB40A784, 0xFC0A785, 0xB40A786, 0xFC0A787,
-  0xCC0A788, 0xFE0A789, 0xB40A78B, 0xFC0A78C, 0xB40A78D, 0x640A78E, 0x380A78F, 0xB40A790, 0xFC0A791,
-  0xB40A792, 0xFC0A793, 0x640A795, 0xB40A796, 0xFC0A797, 0xB40A798, 0xFC0A799, 0xB40A79A, 0xFC0A79B,
-  0xB40A79C, 0xFC0A79D, 0xB40A79E, 0xFC0A79F, 0xB40A7A0, 0xFC0A7A1, 0xB40A7A2, 0xFC0A7A3, 0xB40A7A4,
-  0xFC0A7A5, 0xB40A7A6, 0xFC0A7A7, 0xB40A7A8, 0xFC0A7A9, 0xB40A7AA, 0x640A7AF, 0xB40A7B0, 0xFC0A7B5,
-  0xB40A7B6, 0xFC0A7B7, 0xB40A7B8, 0xFC0A7B9, 0xB40A7BA, 0xFC0A7BB, 0xB40A7BC, 0xFC0A7BD, 0xB40A7BE,
-  0xFC0A7BF, 0xB40A7C0, 0xFC0A7C1, 0xB40A7C2, 0xFC0A7C3, 0xB40A7C4, 0xFC0A7C8, 0xB40A7C9, 0xFC0A7CA,
-  0xB00A7CB, 0xB40A7D0, 0xFC0A7D1, 0xB00A7D2, 0x640A7D3, 0xB00A7D4, 0x640A7D5, 0xB40A7D6, 0xFC0A7D7,
-  0xB40A7D8, 0xFC0A7D9, 0xB00A7DA, 0x1320A7F2, 0xB40A7F5, 0xFC0A7F6, 0x380A7F7, 0xDE0A7F8,
-  0x640A7FA, 0x380A7FB, 0x7E0A802, 0x380A803, 0xBA0A806, 0x380A807, 0x7E0A80B, 0x380A80C, 0xF80A823,
-  0x7E0A825, 0xF80A827, 0x9E0A828, 0xBA0A82C, 0xB00A82D, 0x9E0A830, 0xB00A83A, 0x380A840, 0x9E0A874,
-  0x9A0A876, 0xB00A878, 0xF80A880, 0x380A882, 0xF80A8B4, 0x280A8C4, 0x7E0A8C5, 0xB00A8C6, 0x9A0A8CE,
-  0x1420A8D0, 0xB00A8DA, 0x280A8E0, 0x380A8F2, 0x9E0A8F8, 0x380A8FB, 0x9E0A8FC, 0x380A8FD,
-  0x7E0A8FF, 0x1420A900, 0x380A90A, 0x7E0A926, 0x280A92B, 0x13A0A92E, 0x9A0A92F, 0x380A930,
-  0x7E0A947, 0xF80A952, 0xA0A953, 0xB00A954, 0x9E0A95F, 0x380A960, 0xB00A97D, 0x7E0A980, 0xF80A983,
-  0x380A984, 0x280A9B3, 0xF80A9B4, 0x7E0A9B6, 0xF80A9BA, 0x7E0A9BC, 0xF80A9BE, 0xA0A9C0, 0x9E0A9C1,
-  0xE00A9C7, 0x9A0A9C8, 0x9E0A9CA, 0xB00A9CE, 0xCE0A9CF, 0x1420A9D0, 0xB00A9DA, 0x9E0A9DE,
-  0x380A9E0, 0xE60A9E5, 0xCE0A9E6, 0x380A9E7, 0x1420A9F0, 0x380A9FA, 0xB00A9FF, 0x380AA00,
-  0x7E0AA29, 0xF80AA2F, 0x7E0AA31, 0xF80AA33, 0x7E0AA35, 0xB00AA37, 0x380AA40, 0x7E0AA43, 0x380AA44,
-  0x7E0AA4C, 0xF80AA4D, 0xB00AA4E, 0x1420AA50, 0xB00AA5A, 0x9E0AA5C, 0x9A0AA5D, 0x380AA60,
-  0xCE0AA70, 0x380AA71, 0x9E0AA77, 0x380AA7A, 0x220AA7B, 0xE60AA7C, 0x220AA7D, 0x380AA7E, 0x7E0AAB0,
-  0x380AAB1, 0x7E0AAB2, 0xDA0AAB5, 0x7E0AAB7, 0xDA0AAB9, 0x380AABA, 0xDA0AABB, 0x380AABD, 0x7E0AABE,
-  0x280AABF, 0xEC0AAC0, 0x280AAC1, 0xEC0AAC2, 0xB00AAC3, 0x380AADB, 0xCE0AADD, 0x9E0AADE, 0xE00AADF,
-  0x380AAE0, 0xF80AAEB, 0x7E0AAEC, 0xF80AAEE, 0x9A0AAF0, 0x380AAF2, 0xCE0AAF3, 0xF80AAF5, 0x280AAF6,
-  0xB00AAF7, 0x380AB01, 0xB00AB07, 0x380AB09, 0xB00AB0F, 0x380AB11, 0xB00AB17, 0x380AB20, 0xB00AB27,
-  0x380AB28, 0xB00AB2F, 0x640AB30, 0xFC0AB53, 0x640AB54, 0xFE0AB5B, 0xDE0AB5C, 0x640AB60, 0x580AB69,
-  0xFE0AB6A, 0xB00AB6C, 0x1440AB70, 0x380ABC0, 0xF80ABE3, 0x7E0ABE5, 0xF80ABE6, 0x7E0ABE8,
-  0xF80ABE9, 0x9A0ABEB, 0xA0ABEC, 0x280ABED, 0xB00ABEE, 0x1420ABF0, 0xB00ABFA, 0x380AC00, 0xB00D7A4,
-  0x380D7B0, 0xB00D7C7, 0x380D7CB, 0xB00D7FC, 0xB00E000, 0x560F900, 0x400FA0E, 0x560FA10, 0x400FA11,
-  0x560FA12, 0x400FA13, 0x560FA15, 0x400FA1F, 0x560FA20, 0x400FA21, 0x560FA22, 0x400FA23, 0x560FA25,
-  0x400FA27, 0x560FA2A, 0xB00FA6E, 0x560FA70, 0xB00FADA, 0x1440FB00, 0xB00FB07, 0x1440FB13,
-  0xB00FB18, 0x920FB1D, 0xE60FB1E, 0x920FB1F, 0x7C0FB20, 0x860FB29, 0x920FB2A, 0xB00FB37, 0x920FB38,
-  0xB00FB3D, 0x920FB3E, 0xB00FB3F, 0x920FB40, 0xB00FB42, 0x920FB43, 0xB00FB45, 0x920FB46, 0x7C0FB4F,
-  0x1040FBB2, 0xB00FBC3, 0x7C0FBD3, 0xF00FC5E, 0x7C0FC64, 0x4E0FD3E, 0x9E0FD40, 0x7C0FD50,
-  0xB00FD90, 0x7C0FD92, 0xB00FDC8, 0x9E0FDCF, 0x120FDD0, 0x7C0FDF0, 0xF00FDFA, 0x6C0FDFC, 0x9E0FDFD,
-  0x1A0FE00, 0x6C0FE10, 0xD60FE13, 0x6C0FE14, 0xB00FE1A, 0x280FE20, 0x6C0FE30, 0x780FE31, 0x840FE33,
-  0x6C0FE35, 0x1200FE41, 0x4E0FE45, 0x6C0FE47, 0x840FE4D, 0xC0FE50, 0x320FE52, 0xB00FE53, 0xC0FE54,
-  0xF60FE55, 0x1580FE56, 0x780FE58, 0x1100FE59, 0x6C0FE5F, 0x860FE61, 0x260FE63, 0x680FE64,
-  0x860FE66, 0xB00FE67, 0x860FE68, 0x6C0FE69, 0xB00FE6C, 0xF00FE70, 0x7C0FE71, 0xF00FE72, 0x380FE73,
-  0xF00FE74, 0xB00FE75, 0xF00FE76, 0x7C0FE77, 0xF00FE78, 0x7C0FE79, 0xF00FE7A, 0x7C0FE7B, 0xF00FE7C,
-  0x7C0FE7D, 0xF00FE7E, 0x7C0FE7F, 0xB00FEFD, 0x12C0FEFF, 0xB00FF00, 0x1580FF01, 0x1200FF02,
-  0x6C0FF03, 0x3A0FF07, 0x1100FF08, 0x6C0FF0A, 0x860FF0B, 0xC0FF0C, 0x780FF0D, 0x320FF0E, 0x6C0FF0F,
-  0xCA0FF10, 0xF60FF1A, 0xC0FF1B, 0x680FF1C, 0x860FF1D, 0x680FF1E, 0x1580FF1F, 0x6C0FF20, 0xEA0FF21,
-  0xB40FF27, 0x1100FF3B, 0x860FF3C, 0x1100FF3D, 0x1300FF3E, 0x840FF3F, 0x9C0FF40, 0x900FF41,
-  0x8E0FF47, 0x1100FF5B, 0x860FF5C, 0x1100FF5D, 0x860FF5E, 0x1100FF5F, 0x1580FF61, 0x540FF62,
-  0xC0FF64, 0x6C0FF65, 0x7C0FF66, 0xD20FF70, 0x7C0FF71, 0xBE0FF9E, 0xC60FFA0, 0x7C0FFA1, 0xB00FFBF,
-  0x7C0FFC2, 0xB00FFC8, 0x7C0FFCA, 0xB00FFD0, 0x7C0FFD2, 0xB00FFD8, 0x7C0FFDA, 0xB00FFDD, 0x6C0FFE0,
-  0x860FFE2, 0x9C0FFE3, 0x6C0FFE4, 0xB00FFE7, 0x6C0FFE8, 0x860FFE9, 0x6C0FFED, 0xB00FFEF,
-  0x1220FFF0, 0xE20FFF9, 0x9E0FFFC, 0x120FFFE, 0x3810000, 0xB01000C, 0x381000D, 0xB010027,
-  0x3810028, 0xB01003B, 0x381003C, 0xB01003E, 0x381003F, 0xB01004E, 0x3810050, 0xB01005E, 0x3810080,
-  0xB0100FB, 0x9E10100, 0xB010103, 0x9E10107, 0xB010134, 0x9E10137, 0x3810140, 0x9E10175, 0xB01018F,
-  0x9E10190, 0xB01019D, 0x9E101A0, 0xB0101A1, 0x9E101D0, 0xBA101FD, 0xB0101FE, 0x3810280, 0xB01029D,
-  0x38102A0, 0xB0102D1, 0x28102E0, 0x9E102E1, 0xB0102FC, 0x3810300, 0x9E10320, 0xB010324, 0x381032D,
-  0xB01034B, 0x3810350, 0x7E10376, 0xB01037B, 0x3810380, 0xB01039E, 0xE01039F, 0x38103A0, 0xB0103C4,
-  0x38103C8, 0xE0103D0, 0x38103D1, 0xB0103D6, 0xB410400, 0xFC10428, 0x3810450, 0xB01049E,
-  0x142104A0, 0xB0104AA, 0xB4104B0, 0xB0104D4, 0xFC104D8, 0xB0104FC, 0x3810500, 0xB010528,
-  0x3810530, 0xB010564, 0x9E1056F, 0xB410570, 0xB01057B, 0xB41057C, 0xB01058B, 0xB41058C, 0xB010593,
-  0xB410594, 0xB010596, 0xFC10597, 0xB0105A2, 0xFC105A3, 0xB0105B2, 0xFC105B3, 0xB0105BA, 0xFC105BB,
-  0xB0105BD, 0x3810600, 0xB010737, 0x3810740, 0xB010756, 0x3810760, 0xB010768, 0x4610780, 0xD210781,
-  0xDE10783, 0xB010786, 0xDE10787, 0xB0107B1, 0xDE107B2, 0xB0107BB, 0x3810800, 0xB010806, 0x3810808,
-  0xB010809, 0x381080A, 0xB010836, 0x3810837, 0xB010839, 0x381083C, 0xB01083D, 0x381083F, 0xB010856,
-  0xE010857, 0x9E10858, 0x3810860, 0x9E10877, 0x3810880, 0xB01089F, 0x9E108A7, 0xB0108B0, 0x38108E0,
-  0xB0108F3, 0x38108F4, 0xB0108F6, 0x9E108FB, 0x3810900, 0x9E10916, 0xB01091C, 0xE01091F, 0x3810920,
-  0xB01093A, 0x9E1093F, 0xB010940, 0x3810980, 0xB0109B8, 0x9E109BC, 0x38109BE, 0x9E109C0, 0xB0109D0,
-  0x9E109D2, 0x3810A00, 0x7E10A01, 0xB010A04, 0x7E10A05, 0xB010A07, 0x7E10A0C, 0x3810A10, 0xB010A14,
-  0x3810A15, 0xB010A18, 0x3810A19, 0xB010A36, 0xBA10A38, 0xB010A3B, 0xBA10A3F, 0x9E10A40, 0xB010A49,
-  0x9E10A50, 0x9A10A56, 0x9E10A58, 0xB010A59, 0x3810A60, 0x9E10A7D, 0x3810A80, 0x9E10A9D, 0xB010AA0,
-  0x3810AC0, 0x9E10AC8, 0x3810AC9, 0x2810AE5, 0xB010AE7, 0x9E10AEB, 0xE010AF0, 0x9E10AF6, 0xB010AF7,
-  0x3810B00, 0xB010B36, 0x9E10B39, 0xE010B3A, 0x3810B40, 0xB010B56, 0x9E10B58, 0x3810B60, 0xB010B73,
-  0x9E10B78, 0x3810B80, 0xB010B92, 0xE010B99, 0xB010B9D, 0x9E10BA9, 0xB010BB0, 0x3810C00, 0xB010C49,
-  0xB410C80, 0xB010CB3, 0xFC10CC0, 0xB010CF3, 0x9E10CFA, 0x3810D00, 0xEC10D22, 0xE610D24, 0xB010D28,
-  0x14210D30, 0xB010D3A, 0x9E10E60, 0xB010E7F, 0x3810E80, 0xB010EAA, 0x7E10EAB, 0x10610EAD,
-  0xB010EAE, 0x3810EB0, 0xB010EB2, 0x3810F00, 0x9E10F1D, 0x3810F27, 0xB010F28, 0x3810F30, 0x2810F46,
-  0x9E10F51, 0x9A10F55, 0xB010F5A, 0x3810F70, 0x2810F82, 0x9A10F86, 0xB010F8A, 0x3810FB0, 0x9E10FC5,
-  0xB010FCC, 0x3810FE0, 0xB010FF7, 0xF811000, 0x7E11001, 0xF811002, 0x3811003, 0x7E11038, 0x2811046,
-  0x9A11047, 0xE011049, 0xB01104E, 0x9E11052, 0x14211066, 0x2811070, 0x3811071, 0x7E11073,
-  0x3811075, 0xB011076, 0xBA1107F, 0xF811082, 0x3811083, 0xF8110B0, 0x7E110B3, 0xF8110B7, 0x28110B9,
-  0x9E110BB, 0xE2110BD, 0x9A110BE, 0x7E110C2, 0xB0110C3, 0xE2110CD, 0xB0110CE, 0x38110D0, 0xB0110E9,
-  0x142110F0, 0xB0110FA, 0x7E11100, 0x3811103, 0x7E11127, 0xF81112C, 0x7E1112D, 0x2811133,
-  0xB011135, 0x14211136, 0x9E11140, 0x9A11141, 0x3811144, 0xF811145, 0x3811147, 0xB011148,
-  0x3811150, 0x2811173, 0x9E11174, 0x3811176, 0xB011177, 0x7E11180, 0xF811182, 0x3811183, 0xF8111B3,
-  0x7E111B6, 0xF8111BF, 0xA111C0, 0x38111C1, 0x9A111C5, 0x9E111C7, 0xBA111C9, 0x28111CA, 0x9A111CD,
-  0xF8111CE, 0x7E111CF, 0x142111D0, 0x38111DA, 0x9E111DB, 0x38111DC, 0x9E111DD, 0x9A111DE,
-  0xB0111E0, 0x9E111E1, 0xB0111F5, 0x3811200, 0xB011212, 0x3811213, 0xF81122C, 0x7E1122F, 0xF811232,
-  0x7E11234, 0xA11235, 0x2811236, 0x7E11237, 0x9A11238, 0xE01123A, 0x9A1123B, 0x9E1123D, 0x7E1123E,
-  0xB01123F, 0x3811280, 0xB011287, 0x3811288, 0xB011289, 0x381128A, 0xB01128E, 0x381128F, 0xB01129E,
-  0x381129F, 0x9A112A9, 0xB0112AA, 0x38112B0, 0x7E112DF, 0xF8112E0, 0x7E112E3, 0x28112E9, 0xB0112EB,
-  0x142112F0, 0xB0112FA, 0x7E11300, 0xF811302, 0xB011304, 0x3811305, 0xB01130D, 0x381130F,
-  0xB011311, 0x3811313, 0xB011329, 0x381132A, 0xB011331, 0x3811332, 0xB011334, 0x3811335, 0xB01133A,
-  0xBA1133B, 0x281133C, 0x381133D, 0x761133E, 0xF81133F, 0x7E11340, 0xF811341, 0xB011345, 0xF811347,
-  0xB011349, 0xF81134B, 0xA1134D, 0xB01134E, 0x3811350, 0xB011351, 0x7611357, 0xB011358, 0xE1135D,
-  0x381135E, 0xF811362, 0xB011364, 0x2811366, 0xB01136D, 0x2811370, 0xB011375, 0x3811400, 0xF811435,
-  0x7E11438, 0xF811440, 0x2811442, 0x7E11443, 0xF811445, 0x2811446, 0x3811447, 0x9A1144B, 0xE01144D,
-  0x9E1144E, 0x14211450, 0xE01145A, 0xB01145C, 0x9E1145D, 0xBA1145E, 0x381145F, 0xB011462,
-  0x3811480, 0x76114B0, 0xF8114B1, 0x7E114B3, 0xF8114B9, 0x7E114BA, 0xF8114BB, 0x76114BD, 0xF8114BE,
-  0x7E114BF, 0xF8114C1, 0x28114C2, 0x38114C4, 0x9E114C6, 0x38114C7, 0xB0114C8, 0x142114D0,
-  0xB0114DA, 0x3811580, 0x76115AF, 0xF8115B0, 0x7E115B2, 0xB0115B6, 0xF8115B8, 0x7E115BC, 0xF8115BE,
-  0x28115BF, 0x9E115C1, 0x9A115C2, 0xE0115C4, 0x74115C6, 0x9A115C9, 0x38115D8, 0x7E115DC, 0xB0115DE,
-  0x3811600, 0xF811630, 0x7E11633, 0xF81163B, 0x7E1163D, 0xF81163E, 0x281163F, 0x7E11640, 0x9A11641,
-  0x9E11643, 0x3811644, 0xB011645, 0x14211650, 0xB01165A, 0x9E11660, 0xB01166D, 0x3811680,
-  0x7E116AB, 0xF8116AC, 0x7E116AD, 0xF8116AE, 0x7E116B0, 0xA116B6, 0x28116B7, 0x38116B8, 0x9E116B9,
-  0xB0116BA, 0x142116C0, 0xB0116CA, 0x3811700, 0xB01171B, 0x7E1171D, 0xF811720, 0x7E11722,
-  0xF811726, 0x7E11727, 0x281172B, 0xB01172C, 0x14211730, 0x9E1173A, 0x9A1173C, 0x9E1173F,
-  0x3811740, 0xB011747, 0x3811800, 0xF81182C, 0x7E1182F, 0xF811838, 0x2811839, 0x9E1183B, 0xB01183C,
-  0xB4118A0, 0xFC118C0, 0x142118E0, 0x9E118EA, 0xB0118F3, 0x38118FF, 0xB011907, 0x3811909,
-  0xB01190A, 0x381190C, 0xB011914, 0x3811915, 0xB011917, 0x3811918, 0x7611930, 0xF811931, 0xB011936,
-  0xF811937, 0xB011939, 0x7E1193B, 0xA1193D, 0x281193E, 0x381193F, 0xF811940, 0x3811941, 0xF811942,
-  0x2811943, 0x9A11944, 0x9E11945, 0x9A11946, 0xB011947, 0x14211950, 0xB01195A, 0x38119A0,
-  0xB0119A8, 0x38119AA, 0xF8119D1, 0x7E119D4, 0xB0119D8, 0x7E119DA, 0xF8119DC, 0x28119E0, 0x38119E1,
-  0x9E119E2, 0x38119E3, 0xF8119E4, 0xB0119E5, 0x3811A00, 0x7E11A01, 0x3811A0B, 0xBA11A33, 0x2811A34,
-  0x7E11A35, 0xF811A39, 0x3811A3A, 0x7E11A3B, 0x9E11A3F, 0x9A11A42, 0x9E11A44, 0x2811A47, 0xB011A48,
-  0x3811A50, 0x7E11A51, 0xF811A57, 0x7E11A59, 0x3811A5C, 0x7E11A8A, 0xF811A97, 0x6211A98, 0x2811A99,
-  0x9E11A9A, 0x9A11A9B, 0x3811A9D, 0x9E11A9E, 0xE011AA1, 0xB011AA3, 0x3811AB0, 0xB011AF9, 0x3811C00,
-  0xB011C09, 0x3811C0A, 0xF811C2F, 0x7E11C30, 0xB011C37, 0x7E11C38, 0xF811C3E, 0x2811C3F, 0x3811C40,
-  0x9A11C41, 0xE011C43, 0x9E11C44, 0xB011C46, 0x14211C50, 0x9E11C5A, 0xB011C6D, 0x9E11C70,
-  0xE011C71, 0x3811C72, 0xB011C90, 0x7E11C92, 0xB011CA8, 0xF811CA9, 0x7E11CAA, 0xF811CB1, 0x7E11CB2,
-  0xF811CB4, 0x7E11CB5, 0xB011CB7, 0x3811D00, 0xB011D07, 0x3811D08, 0xB011D0A, 0x3811D0B, 0x7E11D31,
-  0xB011D37, 0x7E11D3A, 0xB011D3B, 0x7E11D3C, 0xB011D3E, 0x7E11D3F, 0x2811D42, 0x7E11D43, 0x2811D44,
-  0x3811D46, 0x7E11D47, 0xB011D48, 0x14211D50, 0xB011D5A, 0x3811D60, 0xB011D66, 0x3811D67,
-  0xB011D69, 0x3811D6A, 0xF811D8A, 0xB011D8F, 0x7E11D90, 0xB011D92, 0xF811D93, 0x7E11D95, 0xF811D96,
-  0x2811D97, 0x3811D98, 0xB011D99, 0x14211DA0, 0xB011DAA, 0x3811EE0, 0x7E11EF3, 0xF811EF5,
-  0x9A11EF7, 0xB011EF9, 0x3811FB0, 0xB011FB1, 0x9E11FC0, 0xB011FF2, 0x9E11FFF, 0x3812000, 0xB01239A,
-  0x3812400, 0xB01246F, 0xE012470, 0xB012475, 0x3812480, 0xB012544, 0x3812F90, 0x9E12FF1, 0xB012FF3,
-  0x3813000, 0xB01342F, 0xE213430, 0xB013439, 0x3814400, 0xB014647, 0x3816800, 0xB016A39, 0x3816A40,
-  0xB016A5F, 0x14216A60, 0xB016A6A, 0x9A16A6E, 0x3816A70, 0xB016ABF, 0x14216AC0, 0xB016ACA,
-  0x3816AD0, 0xB016AEE, 0x2816AF0, 0x9A16AF5, 0xB016AF6, 0x3816B00, 0x2816B30, 0x9A16B37, 0xE016B39,
-  0x9E16B3A, 0x2C16B40, 0xCE16B42, 0x9A16B44, 0x9E16B45, 0xB016B46, 0x14216B50, 0xB016B5A,
-  0x9E16B5B, 0xB016B62, 0x3816B63, 0xB016B78, 0x3816B7D, 0xB016B90, 0xB416E40, 0xFC16E60, 0x9E16E80,
-  0xE016E97, 0x9A16E98, 0x9E16E99, 0xB016E9B, 0x3816F00, 0xB016F4B, 0x7E16F4F, 0x3816F50, 0xF816F51,
-  0xB016F88, 0xE616F8F, 0xCC16F93, 0xB016FA0, 0xCE16FE0, 0x9E16FE2, 0xCE16FE3, 0x11E16FE4,
-  0xB016FE5, 0x2216FF0, 0xB016FF2, 0x5E17000, 0xB0187F8, 0x5E18800, 0xB018CD6, 0x5E18D00, 0xB018D09,
-  0xCC1AFF0, 0xB01AFF4, 0xCC1AFF5, 0xB01AFFC, 0xCC1AFFD, 0xB01AFFF, 0x381B000, 0xB01B123, 0x381B150,
-  0xB01B153, 0x381B164, 0xB01B168, 0x5E1B170, 0xB01B2FC, 0x381BC00, 0xB01BC6B, 0x381BC70, 0xB01BC7D,
-  0x381BC80, 0xB01BC89, 0x381BC90, 0xB01BC9A, 0x9E1BC9C, 0xBA1BC9D, 0x7E1BC9E, 0x9A1BC9F,
-  0x12C1BCA0, 0xB01BCA4, 0x281CF00, 0xB01CF2E, 0x281CF30, 0xB01CF47, 0x9E1CF50, 0xB01CFC4,
-  0x9E1D000, 0xB01D0F6, 0x9E1D100, 0xB01D127, 0x9E1D129, 0x821D15E, 0x15A1D165, 0x1421D166,
-  0x281D167, 0x9E1D16A, 0xA1D16D, 0x521D16E, 0x12C1D173, 0x281D17B, 0x9E1D183, 0x281D185, 0x9E1D18C,
-  0x281D1AA, 0x9E1D1AE, 0x821D1BB, 0x9E1D1C1, 0xB01D1EB, 0x9E1D200, 0xBA1D242, 0x9E1D245, 0xB01D246,
-  0x9E1D2E0, 0xB01D2F4, 0x9E1D300, 0xB01D357, 0x9E1D360, 0xB01D379, 0xA61D400, 0x11A1D41A,
-  0xC41D422, 0x11A1D424, 0xA61D434, 0x11A1D44E, 0xB01D455, 0xC41D456, 0x11A1D458, 0xA61D468,
-  0x11A1D482, 0xC41D48A, 0x11A1D48C, 0xA61D49C, 0xB01D49D, 0xA61D49E, 0xB01D4A0, 0xA61D4A2,
-  0xB01D4A3, 0xA61D4A5, 0xB01D4A7, 0xA61D4A9, 0xB01D4AD, 0xA61D4AE, 0x11A1D4B6, 0xB01D4BA,
-  0x11A1D4BB, 0xB01D4BC, 0x11A1D4BD, 0xC41D4BE, 0x11A1D4C0, 0xB01D4C4, 0x11A1D4C5, 0xA61D4D0,
-  0x11A1D4EA, 0xC41D4F2, 0x11A1D4F4, 0xA61D504, 0xB01D506, 0xA61D507, 0xB01D50B, 0xA61D50D,
-  0xB01D515, 0xA61D516, 0xB01D51D, 0x11A1D51E, 0xC41D526, 0x11A1D528, 0xA61D538, 0xB01D53A,
-  0xA61D53B, 0xB01D53F, 0xA61D540, 0xB01D545, 0xA61D546, 0xB01D547, 0xA61D54A, 0xB01D551,
-  0x11A1D552, 0xC41D55A, 0x11A1D55C, 0xA61D56C, 0x11A1D586, 0xC41D58E, 0x11A1D590, 0xA61D5A0,
-  0x11A1D5BA, 0xC41D5C2, 0x11A1D5C4, 0xA61D5D4, 0x11A1D5EE, 0xC41D5F6, 0x11A1D5F8, 0xA61D608,
-  0x11A1D622, 0xC41D62A, 0x11A1D62C, 0xA61D63C, 0x11A1D656, 0xC41D65E, 0x11A1D660, 0xA61D670,
-  0x11A1D68A, 0xC41D692, 0x11A1D694, 0xB01D6A6, 0xA61D6A8, 0x861D6C1, 0x11A1D6C2, 0x681D6DB,
-  0x11A1D6DC, 0xA61D6E2, 0x861D6FB, 0x11A1D6FC, 0x681D715, 0x11A1D716, 0xA61D71C, 0x861D735,
-  0x11A1D736, 0x681D74F, 0x11A1D750, 0xA61D756, 0x861D76F, 0x11A1D770, 0x681D789, 0x11A1D78A,
-  0xA61D790, 0x861D7A9, 0x11A1D7AA, 0x681D7C3, 0x11A1D7C4, 0xA61D7CA, 0x11A1D7CB, 0xB01D7CC,
-  0x341D7CE, 0x9E1D800, 0xBA1DA00, 0x9E1DA37, 0xBA1DA3B, 0x9E1DA6D, 0xBA1DA75, 0x9E1DA76, 0xBA1DA84,
-  0x9E1DA85, 0xE01DA87, 0x9A1DA88, 0xE01DA89, 0x9E1DA8B, 0xB01DA8C, 0xBA1DA9B, 0xB01DAA0, 0xBA1DAA1,
-  0xB01DAB0, 0x641DF00, 0x381DF0A, 0x641DF0B, 0xAA1DF1A, 0x641DF1B, 0xB01DF1F, 0x7E1E000, 0xB01E007,
-  0x7E1E008, 0xB01E019, 0x7E1E01B, 0xB01E022, 0x7E1E023, 0xB01E025, 0x7E1E026, 0xB01E02B, 0x381E100,
-  0xB01E12D, 0x281E130, 0x2C1E137, 0xCE1E13C, 0xB01E13E, 0x1421E140, 0xB01E14A, 0x381E14E,
-  0x9E1E14F, 0xB01E150, 0x381E290, 0x281E2AE, 0xB01E2AF, 0x381E2C0, 0x281E2EC, 0x1421E2F0,
-  0xB01E2FA, 0x9E1E2FF, 0xB01E300, 0x381E7E0, 0xB01E7E7, 0x381E7E8, 0xB01E7EC, 0x381E7ED, 0xB01E7EF,
-  0x381E7F0, 0xB01E7FF, 0x381E800, 0xB01E8C5, 0x9E1E8C7, 0x281E8D0, 0xB01E8D7, 0xB41E900, 0xFC1E922,
-  0x1561E944, 0x7E1E947, 0x281E948, 0x2C1E94B, 0xB01E94C, 0x1421E950, 0xB01E95A, 0x9E1E95E,
-  0xB01E960, 0x9E1EC71, 0xB01ECB5, 0x9E1ED01, 0xB01ED3E, 0xEE1EE00, 0xB01EE04, 0xEE1EE05, 0xB01EE20,
-  0xEE1EE21, 0xB01EE23, 0xEE1EE24, 0xB01EE25, 0xEE1EE27, 0xB01EE28, 0xEE1EE29, 0xB01EE33, 0xEE1EE34,
-  0xB01EE38, 0xEE1EE39, 0xB01EE3A, 0xEE1EE3B, 0xB01EE3C, 0xEE1EE42, 0xB01EE43, 0xEE1EE47, 0xB01EE48,
-  0xEE1EE49, 0xB01EE4A, 0xEE1EE4B, 0xB01EE4C, 0xEE1EE4D, 0xB01EE50, 0xEE1EE51, 0xB01EE53, 0xEE1EE54,
-  0xB01EE55, 0xEE1EE57, 0xB01EE58, 0xEE1EE59, 0xB01EE5A, 0xEE1EE5B, 0xB01EE5C, 0xEE1EE5D, 0xB01EE5E,
-  0xEE1EE5F, 0xB01EE60, 0xEE1EE61, 0xB01EE63, 0xEE1EE64, 0xB01EE65, 0xEE1EE67, 0xB01EE6B, 0xEE1EE6C,
-  0xB01EE73, 0xEE1EE74, 0xB01EE78, 0xEE1EE79, 0xB01EE7D, 0xEE1EE7E, 0xB01EE7F, 0xEE1EE80, 0xB01EE8A,
-  0xEE1EE8B, 0xB01EE9C, 0xEE1EEA1, 0xB01EEA4, 0xEE1EEA5, 0xB01EEAA, 0xEE1EEAB, 0xB01EEBC, 0xC01EEF0,
-  0xB01EEF2, 0x9E1F000, 0x961F004, 0x9E1F005, 0xB01F02C, 0x9E1F030, 0xB01F094, 0x9E1F0A0, 0xB01F0AF,
-  0x9E1F0B1, 0xB01F0C0, 0x9E1F0C1, 0x961F0CF, 0xB01F0D0, 0x9E1F0D1, 0xB01F0F6, 0x6C1F100, 0x9E1F10B,
-  0x6C1F110, 0x9E1F12F, 0x7A1F130, 0x6C1F14A, 0x161F150, 0x6C1F16A, 0x9E1F16D, 0x1021F170,
-  0x161F172, 0x1021F17E, 0x161F180, 0x9E1F18A, 0x961F18E, 0x9E1F18F, 0x6C1F190, 0x961F191,
-  0x9E1F19B, 0xB01F1AE, 0x961F1E6, 0x6C1F200, 0x1681F201, 0x1601F202, 0xB01F203, 0x6C1F210,
-  0x1681F21A, 0x6C1F21B, 0x1681F22F, 0x6C1F230, 0x1681F232, 0x1601F237, 0x1681F238, 0x6C1F23B,
-  0xB01F23C, 0x6C1F240, 0xB01F249, 0x1681F250, 0xB01F252, 0x9E1F260, 0xB01F266, 0x961F300,
-  0xC81F321, 0x9E1F322, 0xC81F324, 0x961F32D, 0xC81F336, 0x961F337, 0xC81F37D, 0x961F37E,
-  0x1541F385, 0x961F386, 0x9E1F394, 0xC81F396, 0x9E1F398, 0xC81F399, 0x9E1F39C, 0xC81F39E,
-  0x961F3A0, 0x1541F3C2, 0x961F3C5, 0x1541F3C7, 0x961F3C8, 0x1541F3CA, 0xAC1F3CB, 0xC81F3CD,
-  0x961F3CF, 0xC81F3D4, 0x961F3E0, 0x9E1F3F1, 0xC81F3F3, 0x961F3F4, 0xC81F3F5, 0x9E1F3F6, 0xC81F3F7,
-  0x961F3F8, 0x1181F3FB, 0x961F400, 0xC81F43F, 0x961F440, 0xC81F441, 0x1541F442, 0x961F444,
-  0x1541F446, 0x961F451, 0x1541F466, 0x961F479, 0x1541F47C, 0x961F47D, 0x1541F481, 0x961F484,
-  0x1541F485, 0x961F488, 0x1541F48F, 0x961F490, 0x1541F491, 0x961F492, 0x1541F4AA, 0x961F4AB,
-  0xC81F4FD, 0x9E1F4FE, 0x961F4FF, 0x9E1F53E, 0xC81F549, 0x961F54B, 0x9E1F54F, 0x961F550, 0x9E1F568,
-  0xC81F56F, 0x9E1F571, 0xC81F573, 0xAC1F574, 0xC81F576, 0x1541F57A, 0x9E1F57B, 0xC81F587,
-  0x9E1F588, 0xC81F58A, 0x9E1F58E, 0xAC1F590, 0x9E1F591, 0x1541F595, 0x9E1F597, 0x961F5A4,
-  0xC81F5A5, 0x9E1F5A6, 0xC81F5A8, 0x9E1F5A9, 0xC81F5B1, 0x9E1F5B3, 0xC81F5BC, 0x9E1F5BD, 0xC81F5C2,
-  0x9E1F5C5, 0xC81F5D1, 0x9E1F5D4, 0xC81F5DC, 0x9E1F5DF, 0xC81F5E1, 0x9E1F5E2, 0xC81F5E3, 0x9E1F5E4,
-  0xC81F5E8, 0x9E1F5E9, 0xC81F5EF, 0x9E1F5F0, 0xC81F5F3, 0x9E1F5F4, 0xC81F5FA, 0x961F5FB,
-  0x1541F645, 0x961F648, 0x1541F64B, 0x9E1F650, 0x961F680, 0x1541F6A3, 0x961F6A4, 0x1541F6B4,
-  0x961F6B7, 0x1541F6C0, 0x961F6C1, 0x9E1F6C6, 0xC81F6CB, 0x1541F6CC, 0xC81F6CD, 0x961F6D0,
-  0x9E1F6D3, 0x961F6D5, 0xB01F6D8, 0x961F6DD, 0xC81F6E0, 0x9E1F6E6, 0xC81F6E9, 0x9E1F6EA, 0x961F6EB,
-  0xB01F6ED, 0xC81F6F0, 0x9E1F6F1, 0xC81F6F3, 0x961F6F4, 0xB01F6FD, 0x9E1F700, 0xB01F774, 0x9E1F780,
-  0xB01F7D9, 0x961F7E0, 0xB01F7EC, 0x961F7F0, 0xB01F7F1, 0x9E1F800, 0xB01F80C, 0x9E1F810, 0xB01F848,
-  0x9E1F850, 0xB01F85A, 0x9E1F860, 0xB01F888, 0x9E1F890, 0xB01F8AE, 0x9E1F8B0, 0xB01F8B2, 0x9E1F900,
-  0x1541F90C, 0x961F90D, 0x1541F90F, 0x961F910, 0x1541F918, 0x961F920, 0x1541F926, 0x961F927,
-  0x1541F930, 0x961F93A, 0x9E1F93B, 0x1541F93C, 0x961F93F, 0x9E1F946, 0x961F947, 0x1541F977,
-  0x961F978, 0x1541F9B5, 0x961F9B7, 0x1541F9B8, 0x961F9BA, 0x1541F9BB, 0x961F9BC, 0x1541F9CD,
-  0x961F9D0, 0x1541F9D1, 0x961F9DE, 0x9E1FA00, 0xB01FA54, 0x9E1FA60, 0xB01FA6E, 0x961FA70,
-  0xB01FA75, 0x961FA78, 0xB01FA7D, 0x961FA80, 0xB01FA87, 0x961FA90, 0xB01FAAD, 0x961FAB0, 0xB01FABB,
-  0x961FAC0, 0x1541FAC3, 0xB01FAC6, 0x961FAD0, 0xB01FADA, 0x961FAE0, 0xB01FAE8, 0x1541FAF0,
-  0xB01FAF7, 0x9E1FB00, 0xB01FB93, 0x9E1FB94, 0xB01FBCB, 0x841FBF0, 0xB01FBFA, 0x121FFFE, 0x4020000,
-  0xB02A6E0, 0x402A700, 0xB02B739, 0x402B740, 0xB02B81E, 0x402B820, 0xB02CEA2, 0x402CEB0, 0xB02EBE1,
-  0x562F800, 0xB02FA1E, 0x122FFFE, 0x4030000, 0xB03134B, 0x123FFFE, 0xB040000, 0x124FFFE, 0xB050000,
-  0x125FFFE, 0xB060000, 0x126FFFE, 0xB070000, 0x127FFFE, 0xB080000, 0x128FFFE, 0xB090000, 0x129FFFE,
-  0xB0A0000, 0x12AFFFE, 0xB0B0000, 0x12BFFFE, 0xB0C0000, 0x12CFFFE, 0xB0D0000, 0x12DFFFE,
-  0x122E0000, 0x36E0001, 0x122E0002, 0x162E0020, 0x122E0080, 0x1AE0100, 0x122E01F0, 0xB0E1000,
-  0x12EFFFE, 0xB0F0000, 0x12FFFFE, 0xB100000, 0x130FFFE,
-};
+#include <limits>
 
 SWIFT_RUNTIME_STDLIB_INTERNAL
 __swift_uint64_t _swift_stdlib_getBinaryProperties(__swift_uint32_t scalar) {
@@ -672,3 +68,306 @@ __swift_uint64_t _swift_stdlib_getBinaryProperties(__swift_uint32_t scalar) {
   // return 0 to indicate no properties.
   return 0;
 }
+
+SWIFT_RUNTIME_STDLIB_INTERNAL
+__swift_uint8_t _swift_stdlib_getNumericType(__swift_uint32_t scalar) {
+  auto lowerBoundIndex = 0;
+  auto endIndex = 233;
+  auto upperBoundIndex = endIndex - 1;
+
+  while (upperBoundIndex >= lowerBoundIndex) {
+    auto idx = lowerBoundIndex + (upperBoundIndex - lowerBoundIndex) / 2;
+
+    auto entry = _swift_stdlib_numeric_type[idx];
+
+    auto lowerBoundScalar = (entry << 11) >> 11;
+    auto rangeCount = (entry << 3) >> 24;
+    auto upperBoundScalar = lowerBoundScalar + rangeCount;
+
+    auto numericType = (__swift_uint8_t)(entry >> 29);
+
+    if (scalar >= lowerBoundScalar && scalar <= upperBoundScalar) {
+      return numericType;
+    }
+
+    if (scalar > upperBoundScalar) {
+      lowerBoundIndex = idx + 1;
+      continue;
+    }
+
+    if (scalar < lowerBoundScalar) {
+      upperBoundIndex = idx - 1;
+      continue;
+    }
+  }
+
+  // If we made it out here, then our scalar was not found in the composition
+  // array.
+  // Return the max here to indicate that we couldn't find one.
+  return std::numeric_limits<__swift_uint8_t>::max();
+}
+
+SWIFT_RUNTIME_STDLIB_INTERNAL
+double _swift_stdlib_getNumericValue(__swift_uint32_t scalar) {
+  __swift_intptr_t scalarIdx = _swift_stdlib_getMphIdx(scalar, 11,
+                                                  _swift_stdlib_numeric_values_keys,
+                                                  _swift_stdlib_numeric_values_ranks,
+                                                  _swift_stdlib_numeric_values_sizes);
+
+  auto valueIdx = _swift_stdlib_numeric_values_indices[scalarIdx];
+  return _swift_stdlib_numeric_values[valueIdx];
+}
+
+SWIFT_RUNTIME_STDLIB_INTERNAL
+const char *_swift_stdlib_getNameAlias(__swift_uint32_t scalar) {
+  auto dataIdx = _swift_stdlib_getScalarBitArrayIdx(scalar,
+                                                    _swift_stdlib_nameAlias,
+                                                  _swift_stdlib_nameAlias_ranks);
+
+  if (dataIdx == std::numeric_limits<__swift_intptr_t>::max()) {
+    return nullptr;
+  }
+
+  return _swift_stdlib_nameAlias_data[dataIdx];
+}
+
+SWIFT_RUNTIME_STDLIB_INTERNAL
+__swift_int32_t _swift_stdlib_getMapping(__swift_uint32_t scalar,
+                                         __swift_uint8_t mapping) {
+  auto dataIdx = _swift_stdlib_getScalarBitArrayIdx(scalar,
+                                                    _swift_stdlib_mappings,
+                                                  _swift_stdlib_mappings_ranks);
+
+  if (dataIdx == std::numeric_limits<__swift_intptr_t>::max()) {
+    return 0;
+  }
+
+  auto mappings = _swift_stdlib_mappings_data_indices[dataIdx];
+
+  __swift_uint8_t mappingIdx;
+
+  switch (mapping) {
+    // Uppercase
+    case 0:
+      mappingIdx = mappings & 0xFF;
+      break;
+
+    // Lowercase
+    case 1:
+      mappingIdx = (mappings & 0xFF00) >> 8;
+      break;
+
+    // Titlecase
+    case 2:
+      mappingIdx = (mappings & 0xFF0000) >> 16;
+      break;
+
+    // Unknown mapping
+    default:
+      return 0;
+  }
+
+  if (mappingIdx == 0xFF) {
+    return 0;
+  }
+
+  return _swift_stdlib_mappings_data[mappingIdx];
+}
+
+SWIFT_RUNTIME_STDLIB_INTERNAL
+const __swift_uint8_t *_swift_stdlib_getSpecialMapping(__swift_uint32_t scalar,
+                                                       __swift_uint8_t mapping,
+                                                     __swift_intptr_t *length) {
+  auto dataIdx = _swift_stdlib_getScalarBitArrayIdx(scalar,
+                                                 _swift_stdlib_special_mappings,
+                                          _swift_stdlib_special_mappings_ranks);
+
+  if (dataIdx == std::numeric_limits<__swift_intptr_t>::max()) {
+    return nullptr;
+  }
+
+  auto index = _swift_stdlib_special_mappings_data_indices[dataIdx];
+
+  auto uppercase = _swift_stdlib_special_mappings_data + index;
+  auto lowercase = uppercase + 1 + *uppercase;
+  auto titlecase = lowercase + 1 + *lowercase;
+
+  switch (mapping) {
+    // Uppercase
+    case 0:
+      *length = *uppercase;
+      return uppercase + 1;
+
+    // Lowercase
+    case 1:
+      *length = *lowercase;
+      return lowercase + 1;
+
+    // Titlecase
+    case 2:
+      *length = *titlecase;
+      return titlecase + 1;
+
+    // Unknown mapping.
+    default:
+      return nullptr;
+  }
+}
+
+SWIFT_RUNTIME_STDLIB_INTERNAL
+__swift_intptr_t _swift_stdlib_getScalarName(__swift_uint32_t scalar,
+                                             __swift_uint8_t *buffer,
+                                             __swift_intptr_t capacity) {
+  auto setOffset = _swift_stdlib_names_scalar_sets[scalar >> 7];
+
+  if (setOffset == std::numeric_limits<__swift_uint16_t>::max()) {
+    return 0;
+  }
+
+  auto scalarIndex = (setOffset << 7) + (scalar & ((1 << 7) - 1));
+  auto scalarOffset = _swift_stdlib_names_scalars[scalarIndex];
+
+  if (scalarOffset == 0) {
+    return 0;
+  }
+
+  __swift_uint32_t nextScalarOffset = 0;
+  int i = 1;
+
+  // Look for the next scalar who has a name and their position in the names
+  // array. This tells us exactly how many bytes our name takes up.
+  while (nextScalarOffset == 0) {
+    nextScalarOffset = _swift_stdlib_names_scalars[scalarIndex + i];
+    i += 1;
+  }
+
+  auto nameSize = nextScalarOffset - scalarOffset;
+
+  // The total number of initialized bytes in the name string.
+  int c = 0;
+
+  for (__swift_uint32_t i = 0; i < nameSize; i += 1) {
+    __swift_uint16_t wordIndex = (__swift_uint16_t) _swift_stdlib_names[
+      scalarOffset + i
+    ];
+
+    // If our word index is 0xFF, then it means our word index is larger than a
+    // byte, so the next two bytes will compose the 16 bit index.
+    if (wordIndex == 0xFF) {
+      i += 1;
+      auto firstPart = _swift_stdlib_names[scalarOffset + i];
+      wordIndex = firstPart;
+
+      i += 1;
+      auto secondPart = _swift_stdlib_names[scalarOffset + i];
+      wordIndex |= secondPart << 8;
+    }
+
+    auto wordOffset = _swift_stdlib_word_indices[wordIndex];
+
+    auto word = _swift_stdlib_words + wordOffset;
+
+    // The last character in a word has the 7th bit set.
+    while (*word < 0x80) {
+      if (c >= capacity) {
+        return c;
+      }
+
+      buffer[c++] = *word++;
+    }
+
+    if (c >= capacity) {
+      return c;
+    }
+
+    buffer[c++] = *word & 0x7F;
+
+    if (c >= capacity) {
+      return c;
+    }
+
+    buffer[c++] = ' ';
+  }
+
+  // Remove the trailing space.
+  c -= 1;
+
+  // The return value is the number of initialized bytes.
+  return c;
+}
+
+SWIFT_RUNTIME_STDLIB_INTERNAL
+__swift_uint16_t _swift_stdlib_getAge(__swift_uint32_t scalar) {
+  auto lowerBoundIndex = 0;
+  auto endIndex = 1659;
+  auto upperBoundIndex = endIndex - 1;
+
+  while (upperBoundIndex >= lowerBoundIndex) {
+    auto idx = lowerBoundIndex + (upperBoundIndex - lowerBoundIndex) / 2;
+
+    auto entry = _swift_stdlib_ages[idx];
+
+    auto lowerBoundScalar = (entry << 43) >> 43;
+    auto rangeCount = entry >> 32;
+    auto upperBoundScalar = lowerBoundScalar + rangeCount;
+
+    auto ageIdx = (__swift_uint8_t)((entry << 32) >> 32 >> 21);
+
+    if (scalar >= lowerBoundScalar && scalar <= upperBoundScalar) {
+      return _swift_stdlib_ages_data[ageIdx];
+    }
+
+    if (scalar > upperBoundScalar) {
+      lowerBoundIndex = idx + 1;
+      continue;
+    }
+
+    if (scalar < lowerBoundScalar) {
+      upperBoundIndex = idx - 1;
+      continue;
+    }
+  }
+
+  // If we made it out here, then our scalar was not found in the composition
+  // array.
+  // Return the max here to indicate that we couldn't find one.
+  return std::numeric_limits<__swift_uint16_t>::max();
+}
+
+SWIFT_RUNTIME_STDLIB_INTERNAL
+__swift_uint8_t _swift_stdlib_getGeneralCategory(__swift_uint32_t scalar) {
+  auto lowerBoundIndex = 0;
+  auto endIndex = 3968;
+  auto upperBoundIndex = endIndex - 1;
+
+  while (upperBoundIndex >= lowerBoundIndex) {
+    auto idx = lowerBoundIndex + (upperBoundIndex - lowerBoundIndex) / 2;
+
+    auto entry = _swift_stdlib_generalCategory[idx];
+
+    auto lowerBoundScalar = (entry << 43) >> 43;
+    auto rangeCount = entry >> 32;
+    auto upperBoundScalar = lowerBoundScalar + rangeCount;
+
+    auto generalCategory = (__swift_uint8_t)((entry << 32) >> 32 >> 21);
+
+    if (scalar >= lowerBoundScalar && scalar <= upperBoundScalar) {
+      return generalCategory;
+    }
+
+    if (scalar > upperBoundScalar) {
+      lowerBoundIndex = idx + 1;
+      continue;
+    }
+
+    if (scalar < lowerBoundScalar) {
+      upperBoundIndex = idx - 1;
+      continue;
+    }
+  }
+
+  // If we made it out here, then our scalar was not found in the composition
+  // array.
+  // Return the max here to indicate that we couldn't find one.
+  return std::numeric_limits<__swift_uint8_t>::max();
+}

stdlib/public/stubs/UnicodeShims.cpp

@@ -34,18 +34,6 @@ typedef __swift_stdlib_UProperty UProperty;
 
 #define U_MAX_VERSION_LENGTH 4
 typedef uint8_t UVersionInfo[U_MAX_VERSION_LENGTH];
-
-// Comparison and character property APIs
-void u_charAge(UChar32, UVersionInfo);
-int32_t u_getIntPropertyValue(UChar32, UProperty);
-int32_t u_charName(UChar32, UCharNameChoice, char *, int32_t, UErrorCode *);
-int32_t u_strToLower(UChar *, int32_t, const UChar *, int32_t, const char *,
-                     UErrorCode *);
-int32_t u_strToTitle(UChar *, int32_t, const UChar *, int32_t,
-                     UBreakIterator *, const char *, UErrorCode *);
-int32_t u_strToUpper(UChar *, int32_t, const UChar *, int32_t, const char *,
-                     UErrorCode *);
-double u_getNumericValue(UChar32);
 }
 
 #else
@@ -66,122 +54,6 @@ double u_getNumericValue(UChar32);
 
 #endif
 
-#if !defined(__APPLE__)
-#include "swift/Basic/Lazy.h"
-#include "swift/Runtime/Config.h"
-#include "swift/Runtime/Debug.h"
-
-#include <algorithm>
-#include <mutex>
-#include <assert.h>
-
-/// Convert the unicode string to uppercase. This function will return the
-/// required buffer length as a result. If this length does not match the
-/// 'DestinationCapacity' this function must be called again with a buffer of
-/// the required length to get an uppercase version of the string.
-int32_t
-_swift_stdlib_unicode_strToUpper(uint16_t *Destination,
-                                        int32_t DestinationCapacity,
-                                        const uint16_t *Source,
-                                        int32_t SourceLength) {
-  UErrorCode ErrorCode = U_ZERO_ERROR;
-  uint32_t OutputLength = u_strToUpper(reinterpret_cast<UChar *>(Destination),
-                                       DestinationCapacity,
-                                       reinterpret_cast<const UChar *>(Source),
-                                       SourceLength,
-                                       "", &ErrorCode);
-  if (U_FAILURE(ErrorCode) && ErrorCode != U_BUFFER_OVERFLOW_ERROR) {
-    swift::crash("u_strToUpper: Unexpected error uppercasing unicode string.");
-  }
-  return OutputLength;
-}
-
-/// Convert the unicode string to lowercase. This function will return the
-/// required buffer length as a result. If this length does not match the
-/// 'DestinationCapacity' this function must be called again with a buffer of
-/// the required length to get a lowercase version of the string.
-int32_t
-_swift_stdlib_unicode_strToLower(uint16_t *Destination,
-                                        int32_t DestinationCapacity,
-                                        const uint16_t *Source,
-                                        int32_t SourceLength) {
-  UErrorCode ErrorCode = U_ZERO_ERROR;
-  uint32_t OutputLength = u_strToLower(reinterpret_cast<UChar *>(Destination),
-                                       DestinationCapacity,
-                                       reinterpret_cast<const UChar *>(Source),
-                                       SourceLength,
-                                       "", &ErrorCode);
-  if (U_FAILURE(ErrorCode) && ErrorCode != U_BUFFER_OVERFLOW_ERROR) {
-    swift::crash("u_strToLower: Unexpected error lowercasing unicode string.");
-  }
-  return OutputLength;
-}
-#endif
-
-namespace {
-template <typename T, typename U> T *ptr_cast(U *p) {
-  return static_cast<T *>(static_cast<void *>(p));
-}
-template <typename T, typename U> const T *ptr_cast(const U *p) {
-  return static_cast<const T *>(static_cast<const void *>(p));
-}
-}
-
-void
-__swift_stdlib_u_charAge(__swift_stdlib_UChar32 c,
-                                __swift_stdlib_UVersionInfo versionInfo) {
-  return u_charAge(c, versionInfo);
-}
-
-__swift_int32_t
-__swift_stdlib_u_getIntPropertyValue(__swift_stdlib_UChar32 c,
-                                            __swift_stdlib_UProperty p) {
-  return u_getIntPropertyValue(c, static_cast<UProperty>(p));
-}
-
-__swift_int32_t __swift_stdlib_u_charName(
-    __swift_stdlib_UChar32 code, __swift_stdlib_UCharNameChoice nameChoice,
-    char *buffer, __swift_int32_t bufferLength,
-    __swift_stdlib_UErrorCode *pErrorCode) {
-  return u_charName(code, static_cast<UCharNameChoice>(nameChoice),
-                    buffer, bufferLength,
-                    ptr_cast<UErrorCode>(pErrorCode));
-}
-
-__swift_int32_t __swift_stdlib_u_strToLower(
-    __swift_stdlib_UChar *dest, __swift_int32_t destCapacity,
-    const __swift_stdlib_UChar *src, __swift_int32_t srcLength,
-    const char *locale, __swift_stdlib_UErrorCode *pErrorCode) {
-  return u_strToLower(ptr_cast<UChar>(dest), destCapacity,
-                      ptr_cast<UChar>(src), srcLength,
-                      locale, ptr_cast<UErrorCode>(pErrorCode));
-}
-
-__swift_int32_t __swift_stdlib_u_strToTitle(
-    __swift_stdlib_UChar *dest, __swift_int32_t destCapacity,
-    const __swift_stdlib_UChar *src, __swift_int32_t srcLength,
-    __swift_stdlib_UBreakIterator *titleIter, const char *locale,
-    __swift_stdlib_UErrorCode *pErrorCode) {
-  return u_strToTitle(ptr_cast<UChar>(dest), destCapacity,
-                      ptr_cast<UChar>(src), srcLength,
-                      ptr_cast<UBreakIterator>(titleIter), locale,
-                      ptr_cast<UErrorCode>(pErrorCode));
-}
-
-__swift_int32_t __swift_stdlib_u_strToUpper(
-    __swift_stdlib_UChar *dest, __swift_int32_t destCapacity,
-    const __swift_stdlib_UChar *src, __swift_int32_t srcLength,
-    const char *locale, __swift_stdlib_UErrorCode *pErrorCode) {
-  return u_strToUpper(ptr_cast<UChar>(dest), destCapacity,
-                      ptr_cast<UChar>(src), srcLength,
-                      locale, ptr_cast<UErrorCode>(pErrorCode));
-}
-
-double __swift_stdlib_u_getNumericValue(__swift_stdlib_UChar32 c) {
-  return u_getNumericValue(c);
-}
-
-
 // Force an autolink with ICU
 #if defined(__MACH__)
 asm(".linker_option \"-licucore\"\n");

utils/gen-unicode-data/Data/DerivedNumericType.txt

@@ -0,0 +1,278 @@
+# DerivedNumericType-14.0.0.txt
+# Date: 2021-03-08, 06:22:31 GMT
+# © 2021 Unicode®, Inc.
+# Unicode and the Unicode Logo are registered trademarks of Unicode, Inc. in the U.S. and other countries.
+# For terms of use, see http://www.unicode.org/terms_of_use.html
+#
+# Unicode Character Database
+#   For documentation, see http://www.unicode.org/reports/tr44/
+
+# ================================================
+
+# Derived Property:   Numeric_Type
+#  The values are based on fields 6-8 of UnicodeData.txt, plus the fields
+#  kAccountingNumeric, kOtherNumeric, kPrimaryNumeric in the Unicode Han Database (Unihan).
+#  The derivations for these values are as follows.
+#   Numeric_Type=Decimal: When there is a value in field 6.
+#   Numeric_Type=Digit:   When there is a value in field 7, but not in field 6.
+#   Numeric_Type=Numeric: When there are values for kAccountingNumeric, kOtherNumeric, kPrimaryNumeric,
+#                         or there is a value in field 8, but not in field 7.
+#   Numeric_Type=None:    Otherwise
+
+#  All code points not explicitly listed for Numeric_Type
+#  have the value None.
+
+# @missing: 0000..10FFFF; None
+
+# ================================================
+
+00BC..00BE    ; Numeric # No   [3] VULGAR FRACTION ONE QUARTER..VULGAR FRACTION THREE QUARTERS
+09F4..09F9    ; Numeric # No   [6] BENGALI CURRENCY NUMERATOR ONE..BENGALI CURRENCY DENOMINATOR SIXTEEN
+0B72..0B77    ; Numeric # No   [6] ORIYA FRACTION ONE QUARTER..ORIYA FRACTION THREE SIXTEENTHS
+0BF0..0BF2    ; Numeric # No   [3] TAMIL NUMBER TEN..TAMIL NUMBER ONE THOUSAND
+0C78..0C7E    ; Numeric # No   [7] TELUGU FRACTION DIGIT ZERO FOR ODD POWERS OF FOUR..TELUGU FRACTION DIGIT THREE FOR EVEN POWERS OF FOUR
+0D58..0D5E    ; Numeric # No   [7] MALAYALAM FRACTION ONE ONE-HUNDRED-AND-SIXTIETH..MALAYALAM FRACTION ONE FIFTH
+0D70..0D78    ; Numeric # No   [9] MALAYALAM NUMBER TEN..MALAYALAM FRACTION THREE SIXTEENTHS
+0F2A..0F33    ; Numeric # No  [10] TIBETAN DIGIT HALF ONE..TIBETAN DIGIT HALF ZERO
+1372..137C    ; Numeric # No  [11] ETHIOPIC NUMBER TEN..ETHIOPIC NUMBER TEN THOUSAND
+16EE..16F0    ; Numeric # Nl   [3] RUNIC ARLAUG SYMBOL..RUNIC BELGTHOR SYMBOL
+17F0..17F9    ; Numeric # No  [10] KHMER SYMBOL LEK ATTAK SON..KHMER SYMBOL LEK ATTAK PRAM-BUON
+2150..215F    ; Numeric # No  [16] VULGAR FRACTION ONE SEVENTH..FRACTION NUMERATOR ONE
+2160..2182    ; Numeric # Nl  [35] ROMAN NUMERAL ONE..ROMAN NUMERAL TEN THOUSAND
+2185..2188    ; Numeric # Nl   [4] ROMAN NUMERAL SIX LATE FORM..ROMAN NUMERAL ONE HUNDRED THOUSAND
+2189          ; Numeric # No       VULGAR FRACTION ZERO THIRDS
+2469..2473    ; Numeric # No  [11] CIRCLED NUMBER TEN..CIRCLED NUMBER TWENTY
+247D..2487    ; Numeric # No  [11] PARENTHESIZED NUMBER TEN..PARENTHESIZED NUMBER TWENTY
+2491..249B    ; Numeric # No  [11] NUMBER TEN FULL STOP..NUMBER TWENTY FULL STOP
+24EB..24F4    ; Numeric # No  [10] NEGATIVE CIRCLED NUMBER ELEVEN..NEGATIVE CIRCLED NUMBER TWENTY
+24FE          ; Numeric # No       DOUBLE CIRCLED NUMBER TEN
+277F          ; Numeric # No       DINGBAT NEGATIVE CIRCLED NUMBER TEN
+2789          ; Numeric # No       DINGBAT CIRCLED SANS-SERIF NUMBER TEN
+2793          ; Numeric # No       DINGBAT NEGATIVE CIRCLED SANS-SERIF NUMBER TEN
+2CFD          ; Numeric # No       COPTIC FRACTION ONE HALF
+3007          ; Numeric # Nl       IDEOGRAPHIC NUMBER ZERO
+3021..3029    ; Numeric # Nl   [9] HANGZHOU NUMERAL ONE..HANGZHOU NUMERAL NINE
+3038..303A    ; Numeric # Nl   [3] HANGZHOU NUMERAL TEN..HANGZHOU NUMERAL THIRTY
+3192..3195    ; Numeric # No   [4] IDEOGRAPHIC ANNOTATION ONE MARK..IDEOGRAPHIC ANNOTATION FOUR MARK
+3220..3229    ; Numeric # No  [10] PARENTHESIZED IDEOGRAPH ONE..PARENTHESIZED IDEOGRAPH TEN
+3248..324F    ; Numeric # No   [8] CIRCLED NUMBER TEN ON BLACK SQUARE..CIRCLED NUMBER EIGHTY ON BLACK SQUARE
+3251..325F    ; Numeric # No  [15] CIRCLED NUMBER TWENTY ONE..CIRCLED NUMBER THIRTY FIVE
+3280..3289    ; Numeric # No  [10] CIRCLED IDEOGRAPH ONE..CIRCLED IDEOGRAPH TEN
+32B1..32BF    ; Numeric # No  [15] CIRCLED NUMBER THIRTY SIX..CIRCLED NUMBER FIFTY
+3405          ; Numeric # Lo       CJK UNIFIED IDEOGRAPH-3405
+3483          ; Numeric # Lo       CJK UNIFIED IDEOGRAPH-3483
+382A          ; Numeric # Lo       CJK UNIFIED IDEOGRAPH-382A
+3B4D          ; Numeric # Lo       CJK UNIFIED IDEOGRAPH-3B4D
+4E00          ; Numeric # Lo       CJK UNIFIED IDEOGRAPH-4E00
+4E03          ; Numeric # Lo       CJK UNIFIED IDEOGRAPH-4E03
+4E07          ; Numeric # Lo       CJK UNIFIED IDEOGRAPH-4E07
+4E09          ; Numeric # Lo       CJK UNIFIED IDEOGRAPH-4E09
+4E5D          ; Numeric # Lo       CJK UNIFIED IDEOGRAPH-4E5D
+4E8C          ; Numeric # Lo       CJK UNIFIED IDEOGRAPH-4E8C
+4E94          ; Numeric # Lo       CJK UNIFIED IDEOGRAPH-4E94
+4E96          ; Numeric # Lo       CJK UNIFIED IDEOGRAPH-4E96
+4EBF..4EC0    ; Numeric # Lo   [2] CJK UNIFIED IDEOGRAPH-4EBF..CJK UNIFIED IDEOGRAPH-4EC0
+4EDF          ; Numeric # Lo       CJK UNIFIED IDEOGRAPH-4EDF
+4EE8          ; Numeric # Lo       CJK UNIFIED IDEOGRAPH-4EE8
+4F0D          ; Numeric # Lo       CJK UNIFIED IDEOGRAPH-4F0D
+4F70          ; Numeric # Lo       CJK UNIFIED IDEOGRAPH-4F70
+5104          ; Numeric # Lo       CJK UNIFIED IDEOGRAPH-5104
+5146          ; Numeric # Lo       CJK UNIFIED IDEOGRAPH-5146
+5169          ; Numeric # Lo       CJK UNIFIED IDEOGRAPH-5169
+516B          ; Numeric # Lo       CJK UNIFIED IDEOGRAPH-516B
+516D          ; Numeric # Lo       CJK UNIFIED IDEOGRAPH-516D
+5341          ; Numeric # Lo       CJK UNIFIED IDEOGRAPH-5341
+5343..5345    ; Numeric # Lo   [3] CJK UNIFIED IDEOGRAPH-5343..CJK UNIFIED IDEOGRAPH-5345
+534C          ; Numeric # Lo       CJK UNIFIED IDEOGRAPH-534C
+53C1..53C4    ; Numeric # Lo   [4] CJK UNIFIED IDEOGRAPH-53C1..CJK UNIFIED IDEOGRAPH-53C4
+56DB          ; Numeric # Lo       CJK UNIFIED IDEOGRAPH-56DB
+58F1          ; Numeric # Lo       CJK UNIFIED IDEOGRAPH-58F1
+58F9          ; Numeric # Lo       CJK UNIFIED IDEOGRAPH-58F9
+5E7A          ; Numeric # Lo       CJK UNIFIED IDEOGRAPH-5E7A
+5EFE..5EFF    ; Numeric # Lo   [2] CJK UNIFIED IDEOGRAPH-5EFE..CJK UNIFIED IDEOGRAPH-5EFF
+5F0C..5F0E    ; Numeric # Lo   [3] CJK UNIFIED IDEOGRAPH-5F0C..CJK UNIFIED IDEOGRAPH-5F0E
+5F10          ; Numeric # Lo       CJK UNIFIED IDEOGRAPH-5F10
+62FE          ; Numeric # Lo       CJK UNIFIED IDEOGRAPH-62FE
+634C          ; Numeric # Lo       CJK UNIFIED IDEOGRAPH-634C
+67D2          ; Numeric # Lo       CJK UNIFIED IDEOGRAPH-67D2
+6F06          ; Numeric # Lo       CJK UNIFIED IDEOGRAPH-6F06
+7396          ; Numeric # Lo       CJK UNIFIED IDEOGRAPH-7396
+767E          ; Numeric # Lo       CJK UNIFIED IDEOGRAPH-767E
+8086          ; Numeric # Lo       CJK UNIFIED IDEOGRAPH-8086
+842C          ; Numeric # Lo       CJK UNIFIED IDEOGRAPH-842C
+8CAE          ; Numeric # Lo       CJK UNIFIED IDEOGRAPH-8CAE
+8CB3          ; Numeric # Lo       CJK UNIFIED IDEOGRAPH-8CB3
+8D30          ; Numeric # Lo       CJK UNIFIED IDEOGRAPH-8D30
+9621          ; Numeric # Lo       CJK UNIFIED IDEOGRAPH-9621
+9646          ; Numeric # Lo       CJK UNIFIED IDEOGRAPH-9646
+964C          ; Numeric # Lo       CJK UNIFIED IDEOGRAPH-964C
+9678          ; Numeric # Lo       CJK UNIFIED IDEOGRAPH-9678
+96F6          ; Numeric # Lo       CJK UNIFIED IDEOGRAPH-96F6
+A6E6..A6EF    ; Numeric # Nl  [10] BAMUM LETTER MO..BAMUM LETTER KOGHOM
+A830..A835    ; Numeric # No   [6] NORTH INDIC FRACTION ONE QUARTER..NORTH INDIC FRACTION THREE SIXTEENTHS
+F96B          ; Numeric # Lo       CJK COMPATIBILITY IDEOGRAPH-F96B
+F973          ; Numeric # Lo       CJK COMPATIBILITY IDEOGRAPH-F973
+F978          ; Numeric # Lo       CJK COMPATIBILITY IDEOGRAPH-F978
+F9B2          ; Numeric # Lo       CJK COMPATIBILITY IDEOGRAPH-F9B2
+F9D1          ; Numeric # Lo       CJK COMPATIBILITY IDEOGRAPH-F9D1
+F9D3          ; Numeric # Lo       CJK COMPATIBILITY IDEOGRAPH-F9D3
+F9FD          ; Numeric # Lo       CJK COMPATIBILITY IDEOGRAPH-F9FD
+10107..10133  ; Numeric # No  [45] AEGEAN NUMBER ONE..AEGEAN NUMBER NINETY THOUSAND
+10140..10174  ; Numeric # Nl  [53] GREEK ACROPHONIC ATTIC ONE QUARTER..GREEK ACROPHONIC STRATIAN FIFTY MNAS
+10175..10178  ; Numeric # No   [4] GREEK ONE HALF SIGN..GREEK THREE QUARTERS SIGN
+1018A..1018B  ; Numeric # No   [2] GREEK ZERO SIGN..GREEK ONE QUARTER SIGN
+102E1..102FB  ; Numeric # No  [27] COPTIC EPACT DIGIT ONE..COPTIC EPACT NUMBER NINE HUNDRED
+10320..10323  ; Numeric # No   [4] OLD ITALIC NUMERAL ONE..OLD ITALIC NUMERAL FIFTY
+10341         ; Numeric # Nl       GOTHIC LETTER NINETY
+1034A         ; Numeric # Nl       GOTHIC LETTER NINE HUNDRED
+103D1..103D5  ; Numeric # Nl   [5] OLD PERSIAN NUMBER ONE..OLD PERSIAN NUMBER HUNDRED
+10858..1085F  ; Numeric # No   [8] IMPERIAL ARAMAIC NUMBER ONE..IMPERIAL ARAMAIC NUMBER TEN THOUSAND
+10879..1087F  ; Numeric # No   [7] PALMYRENE NUMBER ONE..PALMYRENE NUMBER TWENTY
+108A7..108AF  ; Numeric # No   [9] NABATAEAN NUMBER ONE..NABATAEAN NUMBER ONE HUNDRED
+108FB..108FF  ; Numeric # No   [5] HATRAN NUMBER ONE..HATRAN NUMBER ONE HUNDRED
+10916..1091B  ; Numeric # No   [6] PHOENICIAN NUMBER ONE..PHOENICIAN NUMBER THREE
+109BC..109BD  ; Numeric # No   [2] MEROITIC CURSIVE FRACTION ELEVEN TWELFTHS..MEROITIC CURSIVE FRACTION ONE HALF
+109C0..109CF  ; Numeric # No  [16] MEROITIC CURSIVE NUMBER ONE..MEROITIC CURSIVE NUMBER SEVENTY
+109D2..109FF  ; Numeric # No  [46] MEROITIC CURSIVE NUMBER ONE HUNDRED..MEROITIC CURSIVE FRACTION TEN TWELFTHS
+10A44..10A48  ; Numeric # No   [5] KHAROSHTHI NUMBER TEN..KHAROSHTHI FRACTION ONE HALF
+10A7D..10A7E  ; Numeric # No   [2] OLD SOUTH ARABIAN NUMBER ONE..OLD SOUTH ARABIAN NUMBER FIFTY
+10A9D..10A9F  ; Numeric # No   [3] OLD NORTH ARABIAN NUMBER ONE..OLD NORTH ARABIAN NUMBER TWENTY
+10AEB..10AEF  ; Numeric # No   [5] MANICHAEAN NUMBER ONE..MANICHAEAN NUMBER ONE HUNDRED
+10B58..10B5F  ; Numeric # No   [8] INSCRIPTIONAL PARTHIAN NUMBER ONE..INSCRIPTIONAL PARTHIAN NUMBER ONE THOUSAND
+10B78..10B7F  ; Numeric # No   [8] INSCRIPTIONAL PAHLAVI NUMBER ONE..INSCRIPTIONAL PAHLAVI NUMBER ONE THOUSAND
+10BA9..10BAF  ; Numeric # No   [7] PSALTER PAHLAVI NUMBER ONE..PSALTER PAHLAVI NUMBER ONE HUNDRED
+10CFA..10CFF  ; Numeric # No   [6] OLD HUNGARIAN NUMBER ONE..OLD HUNGARIAN NUMBER ONE THOUSAND
+10E69..10E7E  ; Numeric # No  [22] RUMI NUMBER TEN..RUMI FRACTION TWO THIRDS
+10F1D..10F26  ; Numeric # No  [10] OLD SOGDIAN NUMBER ONE..OLD SOGDIAN FRACTION ONE HALF
+10F51..10F54  ; Numeric # No   [4] SOGDIAN NUMBER ONE..SOGDIAN NUMBER ONE HUNDRED
+10FC5..10FCB  ; Numeric # No   [7] CHORASMIAN NUMBER ONE..CHORASMIAN NUMBER ONE HUNDRED
+1105B..11065  ; Numeric # No  [11] BRAHMI NUMBER TEN..BRAHMI NUMBER ONE THOUSAND
+111E1..111F4  ; Numeric # No  [20] SINHALA ARCHAIC DIGIT ONE..SINHALA ARCHAIC NUMBER ONE THOUSAND
+1173A..1173B  ; Numeric # No   [2] AHOM NUMBER TEN..AHOM NUMBER TWENTY
+118EA..118F2  ; Numeric # No   [9] WARANG CITI NUMBER TEN..WARANG CITI NUMBER NINETY
+11C5A..11C6C  ; Numeric # No  [19] BHAIKSUKI NUMBER ONE..BHAIKSUKI HUNDREDS UNIT MARK
+11FC0..11FD4  ; Numeric # No  [21] TAMIL FRACTION ONE THREE-HUNDRED-AND-TWENTIETH..TAMIL FRACTION DOWNSCALING FACTOR KIIZH
+12400..1246E  ; Numeric # Nl [111] CUNEIFORM NUMERIC SIGN TWO ASH..CUNEIFORM NUMERIC SIGN NINE U VARIANT FORM
+16B5B..16B61  ; Numeric # No   [7] PAHAWH HMONG NUMBER TENS..PAHAWH HMONG NUMBER TRILLIONS
+16E80..16E96  ; Numeric # No  [23] MEDEFAIDRIN DIGIT ZERO..MEDEFAIDRIN DIGIT THREE ALTERNATE FORM
+1D2E0..1D2F3  ; Numeric # No  [20] MAYAN NUMERAL ZERO..MAYAN NUMERAL NINETEEN
+1D360..1D378  ; Numeric # No  [25] COUNTING ROD UNIT DIGIT ONE..TALLY MARK FIVE
+1E8C7..1E8CF  ; Numeric # No   [9] MENDE KIKAKUI DIGIT ONE..MENDE KIKAKUI DIGIT NINE
+1EC71..1ECAB  ; Numeric # No  [59] INDIC SIYAQ NUMBER ONE..INDIC SIYAQ NUMBER PREFIXED NINE
+1ECAD..1ECAF  ; Numeric # No   [3] INDIC SIYAQ FRACTION ONE QUARTER..INDIC SIYAQ FRACTION THREE QUARTERS
+1ECB1..1ECB4  ; Numeric # No   [4] INDIC SIYAQ NUMBER ALTERNATE ONE..INDIC SIYAQ ALTERNATE LAKH MARK
+1ED01..1ED2D  ; Numeric # No  [45] OTTOMAN SIYAQ NUMBER ONE..OTTOMAN SIYAQ NUMBER NINETY THOUSAND
+1ED2F..1ED3D  ; Numeric # No  [15] OTTOMAN SIYAQ ALTERNATE NUMBER TWO..OTTOMAN SIYAQ FRACTION ONE SIXTH
+1F10B..1F10C  ; Numeric # No   [2] DINGBAT CIRCLED SANS-SERIF DIGIT ZERO..DINGBAT NEGATIVE CIRCLED SANS-SERIF DIGIT ZERO
+20001         ; Numeric # Lo       CJK UNIFIED IDEOGRAPH-20001
+20064         ; Numeric # Lo       CJK UNIFIED IDEOGRAPH-20064
+200E2         ; Numeric # Lo       CJK UNIFIED IDEOGRAPH-200E2
+20121         ; Numeric # Lo       CJK UNIFIED IDEOGRAPH-20121
+2092A         ; Numeric # Lo       CJK UNIFIED IDEOGRAPH-2092A
+20983         ; Numeric # Lo       CJK UNIFIED IDEOGRAPH-20983
+2098C         ; Numeric # Lo       CJK UNIFIED IDEOGRAPH-2098C
+2099C         ; Numeric # Lo       CJK UNIFIED IDEOGRAPH-2099C
+20AEA         ; Numeric # Lo       CJK UNIFIED IDEOGRAPH-20AEA
+20AFD         ; Numeric # Lo       CJK UNIFIED IDEOGRAPH-20AFD
+20B19         ; Numeric # Lo       CJK UNIFIED IDEOGRAPH-20B19
+22390         ; Numeric # Lo       CJK UNIFIED IDEOGRAPH-22390
+22998         ; Numeric # Lo       CJK UNIFIED IDEOGRAPH-22998
+23B1B         ; Numeric # Lo       CJK UNIFIED IDEOGRAPH-23B1B
+2626D         ; Numeric # Lo       CJK UNIFIED IDEOGRAPH-2626D
+2F890         ; Numeric # Lo       CJK COMPATIBILITY IDEOGRAPH-2F890
+
+# Total code points: 1084
+
+# ================================================
+
+00B2..00B3    ; Digit # No   [2] SUPERSCRIPT TWO..SUPERSCRIPT THREE
+00B9          ; Digit # No       SUPERSCRIPT ONE
+1369..1371    ; Digit # No   [9] ETHIOPIC DIGIT ONE..ETHIOPIC DIGIT NINE
+19DA          ; Digit # No       NEW TAI LUE THAM DIGIT ONE
+2070          ; Digit # No       SUPERSCRIPT ZERO
+2074..2079    ; Digit # No   [6] SUPERSCRIPT FOUR..SUPERSCRIPT NINE
+2080..2089    ; Digit # No  [10] SUBSCRIPT ZERO..SUBSCRIPT NINE
+2460..2468    ; Digit # No   [9] CIRCLED DIGIT ONE..CIRCLED DIGIT NINE
+2474..247C    ; Digit # No   [9] PARENTHESIZED DIGIT ONE..PARENTHESIZED DIGIT NINE
+2488..2490    ; Digit # No   [9] DIGIT ONE FULL STOP..DIGIT NINE FULL STOP
+24EA          ; Digit # No       CIRCLED DIGIT ZERO
+24F5..24FD    ; Digit # No   [9] DOUBLE CIRCLED DIGIT ONE..DOUBLE CIRCLED DIGIT NINE
+24FF          ; Digit # No       NEGATIVE CIRCLED DIGIT ZERO
+2776..277E    ; Digit # No   [9] DINGBAT NEGATIVE CIRCLED DIGIT ONE..DINGBAT NEGATIVE CIRCLED DIGIT NINE
+2780..2788    ; Digit # No   [9] DINGBAT CIRCLED SANS-SERIF DIGIT ONE..DINGBAT CIRCLED SANS-SERIF DIGIT NINE
+278A..2792    ; Digit # No   [9] DINGBAT NEGATIVE CIRCLED SANS-SERIF DIGIT ONE..DINGBAT NEGATIVE CIRCLED SANS-SERIF DIGIT NINE
+10A40..10A43  ; Digit # No   [4] KHAROSHTHI DIGIT ONE..KHAROSHTHI DIGIT FOUR
+10E60..10E68  ; Digit # No   [9] RUMI DIGIT ONE..RUMI DIGIT NINE
+11052..1105A  ; Digit # No   [9] BRAHMI NUMBER ONE..BRAHMI NUMBER NINE
+1F100..1F10A  ; Digit # No  [11] DIGIT ZERO FULL STOP..DIGIT NINE COMMA
+
+# Total code points: 128
+
+# ================================================
+
+0030..0039    ; Decimal # Nd  [10] DIGIT ZERO..DIGIT NINE
+0660..0669    ; Decimal # Nd  [10] ARABIC-INDIC DIGIT ZERO..ARABIC-INDIC DIGIT NINE
+06F0..06F9    ; Decimal # Nd  [10] EXTENDED ARABIC-INDIC DIGIT ZERO..EXTENDED ARABIC-INDIC DIGIT NINE
+07C0..07C9    ; Decimal # Nd  [10] NKO DIGIT ZERO..NKO DIGIT NINE
+0966..096F    ; Decimal # Nd  [10] DEVANAGARI DIGIT ZERO..DEVANAGARI DIGIT NINE
+09E6..09EF    ; Decimal # Nd  [10] BENGALI DIGIT ZERO..BENGALI DIGIT NINE
+0A66..0A6F    ; Decimal # Nd  [10] GURMUKHI DIGIT ZERO..GURMUKHI DIGIT NINE
+0AE6..0AEF    ; Decimal # Nd  [10] GUJARATI DIGIT ZERO..GUJARATI DIGIT NINE
+0B66..0B6F    ; Decimal # Nd  [10] ORIYA DIGIT ZERO..ORIYA DIGIT NINE
+0BE6..0BEF    ; Decimal # Nd  [10] TAMIL DIGIT ZERO..TAMIL DIGIT NINE
+0C66..0C6F    ; Decimal # Nd  [10] TELUGU DIGIT ZERO..TELUGU DIGIT NINE
+0CE6..0CEF    ; Decimal # Nd  [10] KANNADA DIGIT ZERO..KANNADA DIGIT NINE
+0D66..0D6F    ; Decimal # Nd  [10] MALAYALAM DIGIT ZERO..MALAYALAM DIGIT NINE
+0DE6..0DEF    ; Decimal # Nd  [10] SINHALA LITH DIGIT ZERO..SINHALA LITH DIGIT NINE
+0E50..0E59    ; Decimal # Nd  [10] THAI DIGIT ZERO..THAI DIGIT NINE
+0ED0..0ED9    ; Decimal # Nd  [10] LAO DIGIT ZERO..LAO DIGIT NINE
+0F20..0F29    ; Decimal # Nd  [10] TIBETAN DIGIT ZERO..TIBETAN DIGIT NINE
+1040..1049    ; Decimal # Nd  [10] MYANMAR DIGIT ZERO..MYANMAR DIGIT NINE
+1090..1099    ; Decimal # Nd  [10] MYANMAR SHAN DIGIT ZERO..MYANMAR SHAN DIGIT NINE
+17E0..17E9    ; Decimal # Nd  [10] KHMER DIGIT ZERO..KHMER DIGIT NINE
+1810..1819    ; Decimal # Nd  [10] MONGOLIAN DIGIT ZERO..MONGOLIAN DIGIT NINE
+1946..194F    ; Decimal # Nd  [10] LIMBU DIGIT ZERO..LIMBU DIGIT NINE
+19D0..19D9    ; Decimal # Nd  [10] NEW TAI LUE DIGIT ZERO..NEW TAI LUE DIGIT NINE
+1A80..1A89    ; Decimal # Nd  [10] TAI THAM HORA DIGIT ZERO..TAI THAM HORA DIGIT NINE
+1A90..1A99    ; Decimal # Nd  [10] TAI THAM THAM DIGIT ZERO..TAI THAM THAM DIGIT NINE
+1B50..1B59    ; Decimal # Nd  [10] BALINESE DIGIT ZERO..BALINESE DIGIT NINE
+1BB0..1BB9    ; Decimal # Nd  [10] SUNDANESE DIGIT ZERO..SUNDANESE DIGIT NINE
+1C40..1C49    ; Decimal # Nd  [10] LEPCHA DIGIT ZERO..LEPCHA DIGIT NINE
+1C50..1C59    ; Decimal # Nd  [10] OL CHIKI DIGIT ZERO..OL CHIKI DIGIT NINE
+A620..A629    ; Decimal # Nd  [10] VAI DIGIT ZERO..VAI DIGIT NINE
+A8D0..A8D9    ; Decimal # Nd  [10] SAURASHTRA DIGIT ZERO..SAURASHTRA DIGIT NINE
+A900..A909    ; Decimal # Nd  [10] KAYAH LI DIGIT ZERO..KAYAH LI DIGIT NINE
+A9D0..A9D9    ; Decimal # Nd  [10] JAVANESE DIGIT ZERO..JAVANESE DIGIT NINE
+A9F0..A9F9    ; Decimal # Nd  [10] MYANMAR TAI LAING DIGIT ZERO..MYANMAR TAI LAING DIGIT NINE
+AA50..AA59    ; Decimal # Nd  [10] CHAM DIGIT ZERO..CHAM DIGIT NINE
+ABF0..ABF9    ; Decimal # Nd  [10] MEETEI MAYEK DIGIT ZERO..MEETEI MAYEK DIGIT NINE
+FF10..FF19    ; Decimal # Nd  [10] FULLWIDTH DIGIT ZERO..FULLWIDTH DIGIT NINE
+104A0..104A9  ; Decimal # Nd  [10] OSMANYA DIGIT ZERO..OSMANYA DIGIT NINE
+10D30..10D39  ; Decimal # Nd  [10] HANIFI ROHINGYA DIGIT ZERO..HANIFI ROHINGYA DIGIT NINE
+11066..1106F  ; Decimal # Nd  [10] BRAHMI DIGIT ZERO..BRAHMI DIGIT NINE
+110F0..110F9  ; Decimal # Nd  [10] SORA SOMPENG DIGIT ZERO..SORA SOMPENG DIGIT NINE
+11136..1113F  ; Decimal # Nd  [10] CHAKMA DIGIT ZERO..CHAKMA DIGIT NINE
+111D0..111D9  ; Decimal # Nd  [10] SHARADA DIGIT ZERO..SHARADA DIGIT NINE
+112F0..112F9  ; Decimal # Nd  [10] KHUDAWADI DIGIT ZERO..KHUDAWADI DIGIT NINE
+11450..11459  ; Decimal # Nd  [10] NEWA DIGIT ZERO..NEWA DIGIT NINE
+114D0..114D9  ; Decimal # Nd  [10] TIRHUTA DIGIT ZERO..TIRHUTA DIGIT NINE
+11650..11659  ; Decimal # Nd  [10] MODI DIGIT ZERO..MODI DIGIT NINE
+116C0..116C9  ; Decimal # Nd  [10] TAKRI DIGIT ZERO..TAKRI DIGIT NINE
+11730..11739  ; Decimal # Nd  [10] AHOM DIGIT ZERO..AHOM DIGIT NINE
+118E0..118E9  ; Decimal # Nd  [10] WARANG CITI DIGIT ZERO..WARANG CITI DIGIT NINE
+11950..11959  ; Decimal # Nd  [10] DIVES AKURU DIGIT ZERO..DIVES AKURU DIGIT NINE
+11C50..11C59  ; Decimal # Nd  [10] BHAIKSUKI DIGIT ZERO..BHAIKSUKI DIGIT NINE
+11D50..11D59  ; Decimal # Nd  [10] MASARAM GONDI DIGIT ZERO..MASARAM GONDI DIGIT NINE
+11DA0..11DA9  ; Decimal # Nd  [10] GUNJALA GONDI DIGIT ZERO..GUNJALA GONDI DIGIT NINE
+16A60..16A69  ; Decimal # Nd  [10] MRO DIGIT ZERO..MRO DIGIT NINE
+16AC0..16AC9  ; Decimal # Nd  [10] TANGSA DIGIT ZERO..TANGSA DIGIT NINE
+16B50..16B59  ; Decimal # Nd  [10] PAHAWH HMONG DIGIT ZERO..PAHAWH HMONG DIGIT NINE
+1D7CE..1D7FF  ; Decimal # Nd  [50] MATHEMATICAL BOLD DIGIT ZERO..MATHEMATICAL MONOSPACE DIGIT NINE
+1E140..1E149  ; Decimal # Nd  [10] NYIAKENG PUACHUE HMONG DIGIT ZERO..NYIAKENG PUACHUE HMONG DIGIT NINE
+1E2F0..1E2F9  ; Decimal # Nd  [10] WANCHO DIGIT ZERO..WANCHO DIGIT NINE
+1E950..1E959  ; Decimal # Nd  [10] ADLAM DIGIT ZERO..ADLAM DIGIT NINE
+1FBF0..1FBF9  ; Decimal # Nd  [10] SEGMENTED DIGIT ZERO..SEGMENTED DIGIT NINE
+
+# Total code points: 660
+
+# EOF

utils/gen-unicode-data/Data/NameAliases.txt

@@ -0,0 +1,567 @@
+# NameAliases-14.0.0.txt
+# Date: 2020-10-21, 22:28:00 GMT [KW, LI]
+# © 2020 Unicode®, Inc.
+# For terms of use, see http://www.unicode.org/terms_of_use.html
+#
+# Unicode Character Database
+# For documentation, see http://www.unicode.org/reports/tr44/
+#
+# This file is a normative contributory data file in the
+# Unicode Character Database.
+#
+# This file defines the formal name aliases for Unicode characters.
+#
+# For informative aliases, see NamesList.txt
+#
+# The formal name aliases are divided into five types, each with a distinct label.
+#
+# Type Labels:
+#
+# 1. correction
+#      Corrections for serious problems in the character names
+# 2. control
+#      ISO 6429 names for C0 and C1 control functions, and other
+#      commonly occurring names for control codes
+# 3. alternate
+#      A few widely used alternate names for format characters
+# 4. figment
+#      Several documented labels for C1 control code points which
+#      were never actually approved in any standard
+# 5. abbreviation
+#      Commonly occurring abbreviations (or acronyms) for control codes,
+#      format characters, spaces, and variation selectors
+#
+# The formal name aliases are part of the Unicode character namespace, which
+# includes the character names and the names of named character sequences.
+# The inclusion of ISO 6429 names and other commonly occurring names and
+# abbreviations for control codes and format characters as formal name aliases
+# is to help avoid name collisions between Unicode character names and the
+# labels which commonly appear in text and/or in implementations such as regex, for
+# control codes (which for historical reasons have no Unicode character name)
+# or for format characters.
+#
+# For documentation, see NamesList.html and http://www.unicode.org/reports/tr44/
+#
+# FORMAT
+#
+# Each line has three fields, as described here:
+#
+# First field:  Code point
+# Second field: Alias
+# Third field:  Type
+#
+# The type labels used are defined above. As for property values, comparisons
+# of type labels should ignore case.
+#
+# The type labels can be mapped to other strings for display, if desired.
+#
+# In case multiple aliases are assigned, additional aliases
+# are provided on separate lines. Parsers of this data file should
+# take note that the same code point can (and does) occur more than once.
+#
+# Note that currently the only instances of multiple aliases of the same
+# type for a single code point are either of type "control" or "abbreviation".
+# An alias of type "abbreviation" can, in principle, be added for any code
+# point, although currently aliases of type "correction" do not have
+# any additional aliases of type "abbreviation". Such relationships
+# are not enforced by stability policies.
+#
+#-----------------------------------------------------------------
+
+0000;NULL;control
+0000;NUL;abbreviation
+0001;START OF HEADING;control
+0001;SOH;abbreviation
+0002;START OF TEXT;control
+0002;STX;abbreviation
+0003;END OF TEXT;control
+0003;ETX;abbreviation
+0004;END OF TRANSMISSION;control
+0004;EOT;abbreviation
+0005;ENQUIRY;control
+0005;ENQ;abbreviation
+0006;ACKNOWLEDGE;control
+0006;ACK;abbreviation
+
+# Note that no formal name alias for the ISO 6429 "BELL" is
+# provided for U+0007, because of the existing name collision
+# with U+1F514 BELL.
+
+0007;ALERT;control
+0007;BEL;abbreviation
+
+0008;BACKSPACE;control
+0008;BS;abbreviation
+0009;CHARACTER TABULATION;control
+0009;HORIZONTAL TABULATION;control
+0009;HT;abbreviation
+0009;TAB;abbreviation
+000A;LINE FEED;control
+000A;NEW LINE;control
+000A;END OF LINE;control
+000A;LF;abbreviation
+000A;NL;abbreviation
+000A;EOL;abbreviation
+000B;LINE TABULATION;control
+000B;VERTICAL TABULATION;control
+000B;VT;abbreviation
+000C;FORM FEED;control
+000C;FF;abbreviation
+000D;CARRIAGE RETURN;control
+000D;CR;abbreviation
+000E;SHIFT OUT;control
+000E;LOCKING-SHIFT ONE;control
+000E;SO;abbreviation
+000F;SHIFT IN;control
+000F;LOCKING-SHIFT ZERO;control
+000F;SI;abbreviation
+0010;DATA LINK ESCAPE;control
+0010;DLE;abbreviation
+0011;DEVICE CONTROL ONE;control
+0011;DC1;abbreviation
+0012;DEVICE CONTROL TWO;control
+0012;DC2;abbreviation
+0013;DEVICE CONTROL THREE;control
+0013;DC3;abbreviation
+0014;DEVICE CONTROL FOUR;control
+0014;DC4;abbreviation
+0015;NEGATIVE ACKNOWLEDGE;control
+0015;NAK;abbreviation
+0016;SYNCHRONOUS IDLE;control
+0016;SYN;abbreviation
+0017;END OF TRANSMISSION BLOCK;control
+0017;ETB;abbreviation
+0018;CANCEL;control
+0018;CAN;abbreviation
+0019;END OF MEDIUM;control
+0019;EOM;abbreviation
+001A;SUBSTITUTE;control
+001A;SUB;abbreviation
+001B;ESCAPE;control
+001B;ESC;abbreviation
+001C;INFORMATION SEPARATOR FOUR;control
+001C;FILE SEPARATOR;control
+001C;FS;abbreviation
+001D;INFORMATION SEPARATOR THREE;control
+001D;GROUP SEPARATOR;control
+001D;GS;abbreviation
+001E;INFORMATION SEPARATOR TWO;control
+001E;RECORD SEPARATOR;control
+001E;RS;abbreviation
+001F;INFORMATION SEPARATOR ONE;control
+001F;UNIT SEPARATOR;control
+001F;US;abbreviation
+0020;SP;abbreviation
+007F;DELETE;control
+007F;DEL;abbreviation
+
+# PADDING CHARACTER and HIGH OCTET PRESET represent
+# architectural concepts initially proposed for early
+# drafts of ISO/IEC 10646-1. They were never actually
+# approved or standardized: hence their designation
+# here as the "figment" type. Formal name aliases
+# (and corresponding abbreviations) for these code
+# points are included here because these names leaked
+# out from the draft documents and were published in
+# at least one RFC whose names for code points was
+# implemented in Perl regex expressions.
+
+0080;PADDING CHARACTER;figment
+0080;PAD;abbreviation
+0081;HIGH OCTET PRESET;figment
+0081;HOP;abbreviation
+
+0082;BREAK PERMITTED HERE;control
+0082;BPH;abbreviation
+0083;NO BREAK HERE;control
+0083;NBH;abbreviation
+0084;INDEX;control
+0084;IND;abbreviation
+0085;NEXT LINE;control
+0085;NEL;abbreviation
+0086;START OF SELECTED AREA;control
+0086;SSA;abbreviation
+0087;END OF SELECTED AREA;control
+0087;ESA;abbreviation
+0088;CHARACTER TABULATION SET;control
+0088;HORIZONTAL TABULATION SET;control
+0088;HTS;abbreviation
+0089;CHARACTER TABULATION WITH JUSTIFICATION;control
+0089;HORIZONTAL TABULATION WITH JUSTIFICATION;control
+0089;HTJ;abbreviation
+008A;LINE TABULATION SET;control
+008A;VERTICAL TABULATION SET;control
+008A;VTS;abbreviation
+008B;PARTIAL LINE FORWARD;control
+008B;PARTIAL LINE DOWN;control
+008B;PLD;abbreviation
+008C;PARTIAL LINE BACKWARD;control
+008C;PARTIAL LINE UP;control
+008C;PLU;abbreviation
+008D;REVERSE LINE FEED;control
+008D;REVERSE INDEX;control
+008D;RI;abbreviation
+008E;SINGLE SHIFT TWO;control
+008E;SINGLE-SHIFT-2;control
+008E;SS2;abbreviation
+008F;SINGLE SHIFT THREE;control
+008F;SINGLE-SHIFT-3;control
+008F;SS3;abbreviation
+0090;DEVICE CONTROL STRING;control
+0090;DCS;abbreviation
+0091;PRIVATE USE ONE;control
+0091;PRIVATE USE-1;control
+0091;PU1;abbreviation
+0092;PRIVATE USE TWO;control
+0092;PRIVATE USE-2;control
+0092;PU2;abbreviation
+0093;SET TRANSMIT STATE;control
+0093;STS;abbreviation
+0094;CANCEL CHARACTER;control
+0094;CCH;abbreviation
+0095;MESSAGE WAITING;control
+0095;MW;abbreviation
+0096;START OF GUARDED AREA;control
+0096;START OF PROTECTED AREA;control
+0096;SPA;abbreviation
+0097;END OF GUARDED AREA;control
+0097;END OF PROTECTED AREA;control
+0097;EPA;abbreviation
+0098;START OF STRING;control
+0098;SOS;abbreviation
+
+# SINGLE GRAPHIC CHARACTER INTRODUCER is another
+# architectural concept from early drafts of ISO/IEC 10646-1
+# which was never approved and standardized.
+
+0099;SINGLE GRAPHIC CHARACTER INTRODUCER;figment
+0099;SGC;abbreviation
+
+009A;SINGLE CHARACTER INTRODUCER;control
+009A;SCI;abbreviation
+009B;CONTROL SEQUENCE INTRODUCER;control
+009B;CSI;abbreviation
+009C;STRING TERMINATOR;control
+009C;ST;abbreviation
+009D;OPERATING SYSTEM COMMAND;control
+009D;OSC;abbreviation
+009E;PRIVACY MESSAGE;control
+009E;PM;abbreviation
+009F;APPLICATION PROGRAM COMMAND;control
+009F;APC;abbreviation
+00A0;NBSP;abbreviation
+00AD;SHY;abbreviation
+01A2;LATIN CAPITAL LETTER GHA;correction
+01A3;LATIN SMALL LETTER GHA;correction
+034F;CGJ;abbreviation
+061C;ALM;abbreviation
+0709;SYRIAC SUBLINEAR COLON SKEWED LEFT;correction
+0CDE;KANNADA LETTER LLLA;correction
+0E9D;LAO LETTER FO FON;correction
+0E9F;LAO LETTER FO FAY;correction
+0EA3;LAO LETTER RO;correction
+0EA5;LAO LETTER LO;correction
+0FD0;TIBETAN MARK BKA- SHOG GI MGO RGYAN;correction
+11EC;HANGUL JONGSEONG YESIEUNG-KIYEOK;correction
+11ED;HANGUL JONGSEONG YESIEUNG-SSANGKIYEOK;correction
+11EE;HANGUL JONGSEONG SSANGYESIEUNG;correction
+11EF;HANGUL JONGSEONG YESIEUNG-KHIEUKH;correction
+180B;FVS1;abbreviation
+180C;FVS2;abbreviation
+180D;FVS3;abbreviation
+180E;MVS;abbreviation
+180F;FVS4;abbreviation
+200B;ZWSP;abbreviation
+200C;ZWNJ;abbreviation
+200D;ZWJ;abbreviation
+200E;LRM;abbreviation
+200F;RLM;abbreviation
+202A;LRE;abbreviation
+202B;RLE;abbreviation
+202C;PDF;abbreviation
+202D;LRO;abbreviation
+202E;RLO;abbreviation
+202F;NNBSP;abbreviation
+205F;MMSP;abbreviation
+2060;WJ;abbreviation
+2066;LRI;abbreviation
+2067;RLI;abbreviation
+2068;FSI;abbreviation
+2069;PDI;abbreviation
+2118;WEIERSTRASS ELLIPTIC FUNCTION;correction
+2448;MICR ON US SYMBOL;correction
+2449;MICR DASH SYMBOL;correction
+2B7A;LEFTWARDS TRIANGLE-HEADED ARROW WITH DOUBLE VERTICAL STROKE;correction
+2B7C;RIGHTWARDS TRIANGLE-HEADED ARROW WITH DOUBLE VERTICAL STROKE;correction
+A015;YI SYLLABLE ITERATION MARK;correction
+AA6E;MYANMAR LETTER KHAMTI LLA;correction
+FE00;VS1;abbreviation
+FE01;VS2;abbreviation
+FE02;VS3;abbreviation
+FE03;VS4;abbreviation
+FE04;VS5;abbreviation
+FE05;VS6;abbreviation
+FE06;VS7;abbreviation
+FE07;VS8;abbreviation
+FE08;VS9;abbreviation
+FE09;VS10;abbreviation
+FE0A;VS11;abbreviation
+FE0B;VS12;abbreviation
+FE0C;VS13;abbreviation
+FE0D;VS14;abbreviation
+FE0E;VS15;abbreviation
+FE0F;VS16;abbreviation
+FE18;PRESENTATION FORM FOR VERTICAL RIGHT WHITE LENTICULAR BRACKET;correction
+FEFF;BYTE ORDER MARK;alternate
+FEFF;BOM;abbreviation
+FEFF;ZWNBSP;abbreviation
+122D4;CUNEIFORM SIGN NU11 TENU;correction
+122D5;CUNEIFORM SIGN NU11 OVER NU11 BUR OVER BUR;correction
+16E56;MEDEFAIDRIN CAPITAL LETTER H;correction
+16E57;MEDEFAIDRIN CAPITAL LETTER NG;correction
+16E76;MEDEFAIDRIN SMALL LETTER H;correction
+16E77;MEDEFAIDRIN SMALL LETTER NG;correction
+1B001;HENTAIGANA LETTER E-1;correction
+1D0C5;BYZANTINE MUSICAL SYMBOL FTHORA SKLIRON CHROMA VASIS;correction
+E0100;VS17;abbreviation
+E0101;VS18;abbreviation
+E0102;VS19;abbreviation
+E0103;VS20;abbreviation
+E0104;VS21;abbreviation
+E0105;VS22;abbreviation
+E0106;VS23;abbreviation
+E0107;VS24;abbreviation
+E0108;VS25;abbreviation
+E0109;VS26;abbreviation
+E010A;VS27;abbreviation
+E010B;VS28;abbreviation
+E010C;VS29;abbreviation
+E010D;VS30;abbreviation
+E010E;VS31;abbreviation
+E010F;VS32;abbreviation
+E0110;VS33;abbreviation
+E0111;VS34;abbreviation
+E0112;VS35;abbreviation
+E0113;VS36;abbreviation
+E0114;VS37;abbreviation
+E0115;VS38;abbreviation
+E0116;VS39;abbreviation
+E0117;VS40;abbreviation
+E0118;VS41;abbreviation
+E0119;VS42;abbreviation
+E011A;VS43;abbreviation
+E011B;VS44;abbreviation
+E011C;VS45;abbreviation
+E011D;VS46;abbreviation
+E011E;VS47;abbreviation
+E011F;VS48;abbreviation
+E0120;VS49;abbreviation
+E0121;VS50;abbreviation
+E0122;VS51;abbreviation
+E0123;VS52;abbreviation
+E0124;VS53;abbreviation
+E0125;VS54;abbreviation
+E0126;VS55;abbreviation
+E0127;VS56;abbreviation
+E0128;VS57;abbreviation
+E0129;VS58;abbreviation
+E012A;VS59;abbreviation
+E012B;VS60;abbreviation
+E012C;VS61;abbreviation
+E012D;VS62;abbreviation
+E012E;VS63;abbreviation
+E012F;VS64;abbreviation
+E0130;VS65;abbreviation
+E0131;VS66;abbreviation
+E0132;VS67;abbreviation
+E0133;VS68;abbreviation
+E0134;VS69;abbreviation
+E0135;VS70;abbreviation
+E0136;VS71;abbreviation
+E0137;VS72;abbreviation
+E0138;VS73;abbreviation
+E0139;VS74;abbreviation
+E013A;VS75;abbreviation
+E013B;VS76;abbreviation
+E013C;VS77;abbreviation
+E013D;VS78;abbreviation
+E013E;VS79;abbreviation
+E013F;VS80;abbreviation
+E0140;VS81;abbreviation
+E0141;VS82;abbreviation
+E0142;VS83;abbreviation
+E0143;VS84;abbreviation
+E0144;VS85;abbreviation
+E0145;VS86;abbreviation
+E0146;VS87;abbreviation
+E0147;VS88;abbreviation
+E0148;VS89;abbreviation
+E0149;VS90;abbreviation
+E014A;VS91;abbreviation
+E014B;VS92;abbreviation
+E014C;VS93;abbreviation
+E014D;VS94;abbreviation
+E014E;VS95;abbreviation
+E014F;VS96;abbreviation
+E0150;VS97;abbreviation
+E0151;VS98;abbreviation
+E0152;VS99;abbreviation
+E0153;VS100;abbreviation
+E0154;VS101;abbreviation
+E0155;VS102;abbreviation
+E0156;VS103;abbreviation
+E0157;VS104;abbreviation
+E0158;VS105;abbreviation
+E0159;VS106;abbreviation
+E015A;VS107;abbreviation
+E015B;VS108;abbreviation
+E015C;VS109;abbreviation
+E015D;VS110;abbreviation
+E015E;VS111;abbreviation
+E015F;VS112;abbreviation
+E0160;VS113;abbreviation
+E0161;VS114;abbreviation
+E0162;VS115;abbreviation
+E0163;VS116;abbreviation
+E0164;VS117;abbreviation
+E0165;VS118;abbreviation
+E0166;VS119;abbreviation
+E0167;VS120;abbreviation
+E0168;VS121;abbreviation
+E0169;VS122;abbreviation
+E016A;VS123;abbreviation
+E016B;VS124;abbreviation
+E016C;VS125;abbreviation
+E016D;VS126;abbreviation
+E016E;VS127;abbreviation
+E016F;VS128;abbreviation
+E0170;VS129;abbreviation
+E0171;VS130;abbreviation
+E0172;VS131;abbreviation
+E0173;VS132;abbreviation
+E0174;VS133;abbreviation
+E0175;VS134;abbreviation
+E0176;VS135;abbreviation
+E0177;VS136;abbreviation
+E0178;VS137;abbreviation
+E0179;VS138;abbreviation
+E017A;VS139;abbreviation
+E017B;VS140;abbreviation
+E017C;VS141;abbreviation
+E017D;VS142;abbreviation
+E017E;VS143;abbreviation
+E017F;VS144;abbreviation
+E0180;VS145;abbreviation
+E0181;VS146;abbreviation
+E0182;VS147;abbreviation
+E0183;VS148;abbreviation
+E0184;VS149;abbreviation
+E0185;VS150;abbreviation
+E0186;VS151;abbreviation
+E0187;VS152;abbreviation
+E0188;VS153;abbreviation
+E0189;VS154;abbreviation
+E018A;VS155;abbreviation
+E018B;VS156;abbreviation
+E018C;VS157;abbreviation
+E018D;VS158;abbreviation
+E018E;VS159;abbreviation
+E018F;VS160;abbreviation
+E0190;VS161;abbreviation
+E0191;VS162;abbreviation
+E0192;VS163;abbreviation
+E0193;VS164;abbreviation
+E0194;VS165;abbreviation
+E0195;VS166;abbreviation
+E0196;VS167;abbreviation
+E0197;VS168;abbreviation
+E0198;VS169;abbreviation
+E0199;VS170;abbreviation
+E019A;VS171;abbreviation
+E019B;VS172;abbreviation
+E019C;VS173;abbreviation
+E019D;VS174;abbreviation
+E019E;VS175;abbreviation
+E019F;VS176;abbreviation
+E01A0;VS177;abbreviation
+E01A1;VS178;abbreviation
+E01A2;VS179;abbreviation
+E01A3;VS180;abbreviation
+E01A4;VS181;abbreviation
+E01A5;VS182;abbreviation
+E01A6;VS183;abbreviation
+E01A7;VS184;abbreviation
+E01A8;VS185;abbreviation
+E01A9;VS186;abbreviation
+E01AA;VS187;abbreviation
+E01AB;VS188;abbreviation
+E01AC;VS189;abbreviation
+E01AD;VS190;abbreviation
+E01AE;VS191;abbreviation
+E01AF;VS192;abbreviation
+E01B0;VS193;abbreviation
+E01B1;VS194;abbreviation
+E01B2;VS195;abbreviation
+E01B3;VS196;abbreviation
+E01B4;VS197;abbreviation
+E01B5;VS198;abbreviation
+E01B6;VS199;abbreviation
+E01B7;VS200;abbreviation
+E01B8;VS201;abbreviation
+E01B9;VS202;abbreviation
+E01BA;VS203;abbreviation
+E01BB;VS204;abbreviation
+E01BC;VS205;abbreviation
+E01BD;VS206;abbreviation
+E01BE;VS207;abbreviation
+E01BF;VS208;abbreviation
+E01C0;VS209;abbreviation
+E01C1;VS210;abbreviation
+E01C2;VS211;abbreviation
+E01C3;VS212;abbreviation
+E01C4;VS213;abbreviation
+E01C5;VS214;abbreviation
+E01C6;VS215;abbreviation
+E01C7;VS216;abbreviation
+E01C8;VS217;abbreviation
+E01C9;VS218;abbreviation
+E01CA;VS219;abbreviation
+E01CB;VS220;abbreviation
+E01CC;VS221;abbreviation
+E01CD;VS222;abbreviation
+E01CE;VS223;abbreviation
+E01CF;VS224;abbreviation
+E01D0;VS225;abbreviation
+E01D1;VS226;abbreviation
+E01D2;VS227;abbreviation
+E01D3;VS228;abbreviation
+E01D4;VS229;abbreviation
+E01D5;VS230;abbreviation
+E01D6;VS231;abbreviation
+E01D7;VS232;abbreviation
+E01D8;VS233;abbreviation
+E01D9;VS234;abbreviation
+E01DA;VS235;abbreviation
+E01DB;VS236;abbreviation
+E01DC;VS237;abbreviation
+E01DD;VS238;abbreviation
+E01DE;VS239;abbreviation
+E01DF;VS240;abbreviation
+E01E0;VS241;abbreviation
+E01E1;VS242;abbreviation
+E01E2;VS243;abbreviation
+E01E3;VS244;abbreviation
+E01E4;VS245;abbreviation
+E01E5;VS246;abbreviation
+E01E6;VS247;abbreviation
+E01E7;VS248;abbreviation
+E01E8;VS249;abbreviation
+E01E9;VS250;abbreviation
+E01EA;VS251;abbreviation
+E01EB;VS252;abbreviation
+E01EC;VS253;abbreviation
+E01ED;VS254;abbreviation
+E01EE;VS255;abbreviation
+E01EF;VS256;abbreviation
+
+# EOF

utils/gen-unicode-data/Data/SpecialCasing.txt

@@ -0,0 +1,280 @@
+# SpecialCasing-14.0.0.txt
+# Date: 2021-03-08, 19:35:55 GMT
+# © 2021 Unicode®, Inc.
+# Unicode and the Unicode Logo are registered trademarks of Unicode, Inc. in the U.S. and other countries.
+# For terms of use, see http://www.unicode.org/terms_of_use.html
+#
+# Unicode Character Database
+#   For documentation, see http://www.unicode.org/reports/tr44/
+#
+# Special Casing
+#
+# This file is a supplement to the UnicodeData.txt file. It does not define any
+# properties, but rather provides additional information about the casing of
+# Unicode characters, for situations when casing incurs a change in string length
+# or is dependent on context or locale. For compatibility, the UnicodeData.txt
+# file only contains simple case mappings for characters where they are one-to-one
+# and independent of context and language. The data in this file, combined with
+# the simple case mappings in UnicodeData.txt, defines the full case mappings
+# Lowercase_Mapping (lc), Titlecase_Mapping (tc), and Uppercase_Mapping (uc).
+#
+# Note that the preferred mechanism for defining tailored casing operations is
+# the Unicode Common Locale Data Repository (CLDR). For more information, see the
+# discussion of case mappings and case algorithms in the Unicode Standard.
+#
+# All code points not listed in this file that do not have a simple case mappings
+# in UnicodeData.txt map to themselves.
+# ================================================================================
+# Format
+# ================================================================================
+# The entries in this file are in the following machine-readable format:
+#
+# <code>; <lower>; <title>; <upper>; (<condition_list>;)? # <comment>
+#
+# <code>, <lower>, <title>, and <upper> provide the respective full case mappings
+# of <code>, expressed as character values in hex. If there is more than one character,
+# they are separated by spaces. Other than as used to separate elements, spaces are
+# to be ignored.
+#
+# The <condition_list> is optional. Where present, it consists of one or more language IDs
+# or casing contexts, separated by spaces. In these conditions:
+# - A condition list overrides the normal behavior if all of the listed conditions are true.
+# - The casing context is always the context of the characters in the original string,
+#   NOT in the resulting string.
+# - Case distinctions in the condition list are not significant.
+# - Conditions preceded by "Not_" represent the negation of the condition.
+# The condition list is not represented in the UCD as a formal property.
+#
+# A language ID is defined by BCP 47, with '-' and '_' treated equivalently.
+#
+# A casing context for a character is defined by Section 3.13 Default Case Algorithms
+# of The Unicode Standard.
+#
+# Parsers of this file must be prepared to deal with future additions to this format:
+#  * Additional contexts
+#  * Additional fields
+# ================================================================================
+
+# ================================================================================
+# Unconditional mappings
+# ================================================================================
+
+# The German es-zed is special--the normal mapping is to SS.
+# Note: the titlecase should never occur in practice. It is equal to titlecase(uppercase(<es-zed>))
+
+00DF; 00DF; 0053 0073; 0053 0053; # LATIN SMALL LETTER SHARP S
+
+# Preserve canonical equivalence for I with dot. Turkic is handled below.
+
+0130; 0069 0307; 0130; 0130; # LATIN CAPITAL LETTER I WITH DOT ABOVE
+
+# Ligatures
+
+FB00; FB00; 0046 0066; 0046 0046; # LATIN SMALL LIGATURE FF
+FB01; FB01; 0046 0069; 0046 0049; # LATIN SMALL LIGATURE FI
+FB02; FB02; 0046 006C; 0046 004C; # LATIN SMALL LIGATURE FL
+FB03; FB03; 0046 0066 0069; 0046 0046 0049; # LATIN SMALL LIGATURE FFI
+FB04; FB04; 0046 0066 006C; 0046 0046 004C; # LATIN SMALL LIGATURE FFL
+FB05; FB05; 0053 0074; 0053 0054; # LATIN SMALL LIGATURE LONG S T
+FB06; FB06; 0053 0074; 0053 0054; # LATIN SMALL LIGATURE ST
+
+0587; 0587; 0535 0582; 0535 0552; # ARMENIAN SMALL LIGATURE ECH YIWN
+FB13; FB13; 0544 0576; 0544 0546; # ARMENIAN SMALL LIGATURE MEN NOW
+FB14; FB14; 0544 0565; 0544 0535; # ARMENIAN SMALL LIGATURE MEN ECH
+FB15; FB15; 0544 056B; 0544 053B; # ARMENIAN SMALL LIGATURE MEN INI
+FB16; FB16; 054E 0576; 054E 0546; # ARMENIAN SMALL LIGATURE VEW NOW
+FB17; FB17; 0544 056D; 0544 053D; # ARMENIAN SMALL LIGATURE MEN XEH
+
+# No corresponding uppercase precomposed character
+
+0149; 0149; 02BC 004E; 02BC 004E; # LATIN SMALL LETTER N PRECEDED BY APOSTROPHE
+0390; 0390; 0399 0308 0301; 0399 0308 0301; # GREEK SMALL LETTER IOTA WITH DIALYTIKA AND TONOS
+03B0; 03B0; 03A5 0308 0301; 03A5 0308 0301; # GREEK SMALL LETTER UPSILON WITH DIALYTIKA AND TONOS
+01F0; 01F0; 004A 030C; 004A 030C; # LATIN SMALL LETTER J WITH CARON
+1E96; 1E96; 0048 0331; 0048 0331; # LATIN SMALL LETTER H WITH LINE BELOW
+1E97; 1E97; 0054 0308; 0054 0308; # LATIN SMALL LETTER T WITH DIAERESIS
+1E98; 1E98; 0057 030A; 0057 030A; # LATIN SMALL LETTER W WITH RING ABOVE
+1E99; 1E99; 0059 030A; 0059 030A; # LATIN SMALL LETTER Y WITH RING ABOVE
+1E9A; 1E9A; 0041 02BE; 0041 02BE; # LATIN SMALL LETTER A WITH RIGHT HALF RING
+1F50; 1F50; 03A5 0313; 03A5 0313; # GREEK SMALL LETTER UPSILON WITH PSILI
+1F52; 1F52; 03A5 0313 0300; 03A5 0313 0300; # GREEK SMALL LETTER UPSILON WITH PSILI AND VARIA
+1F54; 1F54; 03A5 0313 0301; 03A5 0313 0301; # GREEK SMALL LETTER UPSILON WITH PSILI AND OXIA
+1F56; 1F56; 03A5 0313 0342; 03A5 0313 0342; # GREEK SMALL LETTER UPSILON WITH PSILI AND PERISPOMENI
+1FB6; 1FB6; 0391 0342; 0391 0342; # GREEK SMALL LETTER ALPHA WITH PERISPOMENI
+1FC6; 1FC6; 0397 0342; 0397 0342; # GREEK SMALL LETTER ETA WITH PERISPOMENI
+1FD2; 1FD2; 0399 0308 0300; 0399 0308 0300; # GREEK SMALL LETTER IOTA WITH DIALYTIKA AND VARIA
+1FD3; 1FD3; 0399 0308 0301; 0399 0308 0301; # GREEK SMALL LETTER IOTA WITH DIALYTIKA AND OXIA
+1FD6; 1FD6; 0399 0342; 0399 0342; # GREEK SMALL LETTER IOTA WITH PERISPOMENI
+1FD7; 1FD7; 0399 0308 0342; 0399 0308 0342; # GREEK SMALL LETTER IOTA WITH DIALYTIKA AND PERISPOMENI
+1FE2; 1FE2; 03A5 0308 0300; 03A5 0308 0300; # GREEK SMALL LETTER UPSILON WITH DIALYTIKA AND VARIA
+1FE3; 1FE3; 03A5 0308 0301; 03A5 0308 0301; # GREEK SMALL LETTER UPSILON WITH DIALYTIKA AND OXIA
+1FE4; 1FE4; 03A1 0313; 03A1 0313; # GREEK SMALL LETTER RHO WITH PSILI
+1FE6; 1FE6; 03A5 0342; 03A5 0342; # GREEK SMALL LETTER UPSILON WITH PERISPOMENI
+1FE7; 1FE7; 03A5 0308 0342; 03A5 0308 0342; # GREEK SMALL LETTER UPSILON WITH DIALYTIKA AND PERISPOMENI
+1FF6; 1FF6; 03A9 0342; 03A9 0342; # GREEK SMALL LETTER OMEGA WITH PERISPOMENI
+
+# IMPORTANT-when iota-subscript (0345) is uppercased or titlecased,
+#  the result will be incorrect unless the iota-subscript is moved to the end
+#  of any sequence of combining marks. Otherwise, the accents will go on the capital iota.
+#  This process can be achieved by first transforming the text to NFC before casing.
+#  E.g. <alpha><iota_subscript><acute> is uppercased to <ALPHA><acute><IOTA>
+
+# The following cases are already in the UnicodeData.txt file, so are only commented here.
+
+# 0345; 0345; 0399; 0399; # COMBINING GREEK YPOGEGRAMMENI
+
+# All letters with YPOGEGRAMMENI (iota-subscript) or PROSGEGRAMMENI (iota adscript)
+# have special uppercases.
+# Note: characters with PROSGEGRAMMENI are actually titlecase, not uppercase!
+
+1F80; 1F80; 1F88; 1F08 0399; # GREEK SMALL LETTER ALPHA WITH PSILI AND YPOGEGRAMMENI
+1F81; 1F81; 1F89; 1F09 0399; # GREEK SMALL LETTER ALPHA WITH DASIA AND YPOGEGRAMMENI
+1F82; 1F82; 1F8A; 1F0A 0399; # GREEK SMALL LETTER ALPHA WITH PSILI AND VARIA AND YPOGEGRAMMENI
+1F83; 1F83; 1F8B; 1F0B 0399; # GREEK SMALL LETTER ALPHA WITH DASIA AND VARIA AND YPOGEGRAMMENI
+1F84; 1F84; 1F8C; 1F0C 0399; # GREEK SMALL LETTER ALPHA WITH PSILI AND OXIA AND YPOGEGRAMMENI
+1F85; 1F85; 1F8D; 1F0D 0399; # GREEK SMALL LETTER ALPHA WITH DASIA AND OXIA AND YPOGEGRAMMENI
+1F86; 1F86; 1F8E; 1F0E 0399; # GREEK SMALL LETTER ALPHA WITH PSILI AND PERISPOMENI AND YPOGEGRAMMENI
+1F87; 1F87; 1F8F; 1F0F 0399; # GREEK SMALL LETTER ALPHA WITH DASIA AND PERISPOMENI AND YPOGEGRAMMENI
+1F88; 1F80; 1F88; 1F08 0399; # GREEK CAPITAL LETTER ALPHA WITH PSILI AND PROSGEGRAMMENI
+1F89; 1F81; 1F89; 1F09 0399; # GREEK CAPITAL LETTER ALPHA WITH DASIA AND PROSGEGRAMMENI
+1F8A; 1F82; 1F8A; 1F0A 0399; # GREEK CAPITAL LETTER ALPHA WITH PSILI AND VARIA AND PROSGEGRAMMENI
+1F8B; 1F83; 1F8B; 1F0B 0399; # GREEK CAPITAL LETTER ALPHA WITH DASIA AND VARIA AND PROSGEGRAMMENI
+1F8C; 1F84; 1F8C; 1F0C 0399; # GREEK CAPITAL LETTER ALPHA WITH PSILI AND OXIA AND PROSGEGRAMMENI
+1F8D; 1F85; 1F8D; 1F0D 0399; # GREEK CAPITAL LETTER ALPHA WITH DASIA AND OXIA AND PROSGEGRAMMENI
+1F8E; 1F86; 1F8E; 1F0E 0399; # GREEK CAPITAL LETTER ALPHA WITH PSILI AND PERISPOMENI AND PROSGEGRAMMENI
+1F8F; 1F87; 1F8F; 1F0F 0399; # GREEK CAPITAL LETTER ALPHA WITH DASIA AND PERISPOMENI AND PROSGEGRAMMENI
+1F90; 1F90; 1F98; 1F28 0399; # GREEK SMALL LETTER ETA WITH PSILI AND YPOGEGRAMMENI
+1F91; 1F91; 1F99; 1F29 0399; # GREEK SMALL LETTER ETA WITH DASIA AND YPOGEGRAMMENI
+1F92; 1F92; 1F9A; 1F2A 0399; # GREEK SMALL LETTER ETA WITH PSILI AND VARIA AND YPOGEGRAMMENI
+1F93; 1F93; 1F9B; 1F2B 0399; # GREEK SMALL LETTER ETA WITH DASIA AND VARIA AND YPOGEGRAMMENI
+1F94; 1F94; 1F9C; 1F2C 0399; # GREEK SMALL LETTER ETA WITH PSILI AND OXIA AND YPOGEGRAMMENI
+1F95; 1F95; 1F9D; 1F2D 0399; # GREEK SMALL LETTER ETA WITH DASIA AND OXIA AND YPOGEGRAMMENI
+1F96; 1F96; 1F9E; 1F2E 0399; # GREEK SMALL LETTER ETA WITH PSILI AND PERISPOMENI AND YPOGEGRAMMENI
+1F97; 1F97; 1F9F; 1F2F 0399; # GREEK SMALL LETTER ETA WITH DASIA AND PERISPOMENI AND YPOGEGRAMMENI
+1F98; 1F90; 1F98; 1F28 0399; # GREEK CAPITAL LETTER ETA WITH PSILI AND PROSGEGRAMMENI
+1F99; 1F91; 1F99; 1F29 0399; # GREEK CAPITAL LETTER ETA WITH DASIA AND PROSGEGRAMMENI
+1F9A; 1F92; 1F9A; 1F2A 0399; # GREEK CAPITAL LETTER ETA WITH PSILI AND VARIA AND PROSGEGRAMMENI
+1F9B; 1F93; 1F9B; 1F2B 0399; # GREEK CAPITAL LETTER ETA WITH DASIA AND VARIA AND PROSGEGRAMMENI
+1F9C; 1F94; 1F9C; 1F2C 0399; # GREEK CAPITAL LETTER ETA WITH PSILI AND OXIA AND PROSGEGRAMMENI
+1F9D; 1F95; 1F9D; 1F2D 0399; # GREEK CAPITAL LETTER ETA WITH DASIA AND OXIA AND PROSGEGRAMMENI
+1F9E; 1F96; 1F9E; 1F2E 0399; # GREEK CAPITAL LETTER ETA WITH PSILI AND PERISPOMENI AND PROSGEGRAMMENI
+1F9F; 1F97; 1F9F; 1F2F 0399; # GREEK CAPITAL LETTER ETA WITH DASIA AND PERISPOMENI AND PROSGEGRAMMENI
+1FA0; 1FA0; 1FA8; 1F68 0399; # GREEK SMALL LETTER OMEGA WITH PSILI AND YPOGEGRAMMENI
+1FA1; 1FA1; 1FA9; 1F69 0399; # GREEK SMALL LETTER OMEGA WITH DASIA AND YPOGEGRAMMENI
+1FA2; 1FA2; 1FAA; 1F6A 0399; # GREEK SMALL LETTER OMEGA WITH PSILI AND VARIA AND YPOGEGRAMMENI
+1FA3; 1FA3; 1FAB; 1F6B 0399; # GREEK SMALL LETTER OMEGA WITH DASIA AND VARIA AND YPOGEGRAMMENI
+1FA4; 1FA4; 1FAC; 1F6C 0399; # GREEK SMALL LETTER OMEGA WITH PSILI AND OXIA AND YPOGEGRAMMENI
+1FA5; 1FA5; 1FAD; 1F6D 0399; # GREEK SMALL LETTER OMEGA WITH DASIA AND OXIA AND YPOGEGRAMMENI
+1FA6; 1FA6; 1FAE; 1F6E 0399; # GREEK SMALL LETTER OMEGA WITH PSILI AND PERISPOMENI AND YPOGEGRAMMENI
+1FA7; 1FA7; 1FAF; 1F6F 0399; # GREEK SMALL LETTER OMEGA WITH DASIA AND PERISPOMENI AND YPOGEGRAMMENI
+1FA8; 1FA0; 1FA8; 1F68 0399; # GREEK CAPITAL LETTER OMEGA WITH PSILI AND PROSGEGRAMMENI
+1FA9; 1FA1; 1FA9; 1F69 0399; # GREEK CAPITAL LETTER OMEGA WITH DASIA AND PROSGEGRAMMENI
+1FAA; 1FA2; 1FAA; 1F6A 0399; # GREEK CAPITAL LETTER OMEGA WITH PSILI AND VARIA AND PROSGEGRAMMENI
+1FAB; 1FA3; 1FAB; 1F6B 0399; # GREEK CAPITAL LETTER OMEGA WITH DASIA AND VARIA AND PROSGEGRAMMENI
+1FAC; 1FA4; 1FAC; 1F6C 0399; # GREEK CAPITAL LETTER OMEGA WITH PSILI AND OXIA AND PROSGEGRAMMENI
+1FAD; 1FA5; 1FAD; 1F6D 0399; # GREEK CAPITAL LETTER OMEGA WITH DASIA AND OXIA AND PROSGEGRAMMENI
+1FAE; 1FA6; 1FAE; 1F6E 0399; # GREEK CAPITAL LETTER OMEGA WITH PSILI AND PERISPOMENI AND PROSGEGRAMMENI
+1FAF; 1FA7; 1FAF; 1F6F 0399; # GREEK CAPITAL LETTER OMEGA WITH DASIA AND PERISPOMENI AND PROSGEGRAMMENI
+1FB3; 1FB3; 1FBC; 0391 0399; # GREEK SMALL LETTER ALPHA WITH YPOGEGRAMMENI
+1FBC; 1FB3; 1FBC; 0391 0399; # GREEK CAPITAL LETTER ALPHA WITH PROSGEGRAMMENI
+1FC3; 1FC3; 1FCC; 0397 0399; # GREEK SMALL LETTER ETA WITH YPOGEGRAMMENI
+1FCC; 1FC3; 1FCC; 0397 0399; # GREEK CAPITAL LETTER ETA WITH PROSGEGRAMMENI
+1FF3; 1FF3; 1FFC; 03A9 0399; # GREEK SMALL LETTER OMEGA WITH YPOGEGRAMMENI
+1FFC; 1FF3; 1FFC; 03A9 0399; # GREEK CAPITAL LETTER OMEGA WITH PROSGEGRAMMENI
+
+# Some characters with YPOGEGRAMMENI also have no corresponding titlecases
+
+1FB2; 1FB2; 1FBA 0345; 1FBA 0399; # GREEK SMALL LETTER ALPHA WITH VARIA AND YPOGEGRAMMENI
+1FB4; 1FB4; 0386 0345; 0386 0399; # GREEK SMALL LETTER ALPHA WITH OXIA AND YPOGEGRAMMENI
+1FC2; 1FC2; 1FCA 0345; 1FCA 0399; # GREEK SMALL LETTER ETA WITH VARIA AND YPOGEGRAMMENI
+1FC4; 1FC4; 0389 0345; 0389 0399; # GREEK SMALL LETTER ETA WITH OXIA AND YPOGEGRAMMENI
+1FF2; 1FF2; 1FFA 0345; 1FFA 0399; # GREEK SMALL LETTER OMEGA WITH VARIA AND YPOGEGRAMMENI
+1FF4; 1FF4; 038F 0345; 038F 0399; # GREEK SMALL LETTER OMEGA WITH OXIA AND YPOGEGRAMMENI
+
+1FB7; 1FB7; 0391 0342 0345; 0391 0342 0399; # GREEK SMALL LETTER ALPHA WITH PERISPOMENI AND YPOGEGRAMMENI
+1FC7; 1FC7; 0397 0342 0345; 0397 0342 0399; # GREEK SMALL LETTER ETA WITH PERISPOMENI AND YPOGEGRAMMENI
+1FF7; 1FF7; 03A9 0342 0345; 03A9 0342 0399; # GREEK SMALL LETTER OMEGA WITH PERISPOMENI AND YPOGEGRAMMENI
+
+# ================================================================================
+# Conditional Mappings
+# The remainder of this file provides conditional casing data used to produce
+# full case mappings.
+# ================================================================================
+# Language-Insensitive Mappings
+# These are characters whose full case mappings do not depend on language, but do
+# depend on context (which characters come before or after). For more information
+# see the header of this file and the Unicode Standard.
+# ================================================================================
+
+# Special case for final form of sigma
+
+03A3; 03C2; 03A3; 03A3; Final_Sigma; # GREEK CAPITAL LETTER SIGMA
+
+# Note: the following cases for non-final are already in the UnicodeData.txt file.
+
+# 03A3; 03C3; 03A3; 03A3; # GREEK CAPITAL LETTER SIGMA
+# 03C3; 03C3; 03A3; 03A3; # GREEK SMALL LETTER SIGMA
+# 03C2; 03C2; 03A3; 03A3; # GREEK SMALL LETTER FINAL SIGMA
+
+# Note: the following cases are not included, since they would case-fold in lowercasing
+
+# 03C3; 03C2; 03A3; 03A3; Final_Sigma; # GREEK SMALL LETTER SIGMA
+# 03C2; 03C3; 03A3; 03A3; Not_Final_Sigma; # GREEK SMALL LETTER FINAL SIGMA
+
+# ================================================================================
+# Language-Sensitive Mappings
+# These are characters whose full case mappings depend on language and perhaps also
+# context (which characters come before or after). For more information
+# see the header of this file and the Unicode Standard.
+# ================================================================================
+
+# Lithuanian
+
+# Lithuanian retains the dot in a lowercase i when followed by accents.
+
+# Remove DOT ABOVE after "i" with upper or titlecase
+
+0307; 0307; ; ; lt After_Soft_Dotted; # COMBINING DOT ABOVE
+
+# Introduce an explicit dot above when lowercasing capital I's and J's
+# whenever there are more accents above.
+# (of the accents used in Lithuanian: grave, acute, tilde above, and ogonek)
+
+0049; 0069 0307; 0049; 0049; lt More_Above; # LATIN CAPITAL LETTER I
+004A; 006A 0307; 004A; 004A; lt More_Above; # LATIN CAPITAL LETTER J
+012E; 012F 0307; 012E; 012E; lt More_Above; # LATIN CAPITAL LETTER I WITH OGONEK
+00CC; 0069 0307 0300; 00CC; 00CC; lt; # LATIN CAPITAL LETTER I WITH GRAVE
+00CD; 0069 0307 0301; 00CD; 00CD; lt; # LATIN CAPITAL LETTER I WITH ACUTE
+0128; 0069 0307 0303; 0128; 0128; lt; # LATIN CAPITAL LETTER I WITH TILDE
+
+# ================================================================================
+
+# Turkish and Azeri
+
+# I and i-dotless; I-dot and i are case pairs in Turkish and Azeri
+# The following rules handle those cases.
+
+0130; 0069; 0130; 0130; tr; # LATIN CAPITAL LETTER I WITH DOT ABOVE
+0130; 0069; 0130; 0130; az; # LATIN CAPITAL LETTER I WITH DOT ABOVE
+
+# When lowercasing, remove dot_above in the sequence I + dot_above, which will turn into i.
+# This matches the behavior of the canonically equivalent I-dot_above
+
+0307; ; 0307; 0307; tr After_I; # COMBINING DOT ABOVE
+0307; ; 0307; 0307; az After_I; # COMBINING DOT ABOVE
+
+# When lowercasing, unless an I is before a dot_above, it turns into a dotless i.
+
+0049; 0131; 0049; 0049; tr Not_Before_Dot; # LATIN CAPITAL LETTER I
+0049; 0131; 0049; 0049; az Not_Before_Dot; # LATIN CAPITAL LETTER I
+
+# When uppercasing, i turns into a dotted capital I
+
+0069; 0069; 0130; 0130; tr; # LATIN SMALL LETTER I
+0069; 0069; 0130; 0130; az; # LATIN SMALL LETTER I
+
+# Note: the following case is already in the UnicodeData.txt file.
+
+# 0131; 0131; 0049; 0049; tr; # LATIN SMALL LETTER DOTLESS I
+
+# EOF

utils/gen-unicode-data/Sources/GenScalarProps/Age.swift

@@ -0,0 +1,97 @@
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2021 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+import GenUtils
+
+func getAge(
+  from data: String,
+  into result: inout [(ClosedRange<UInt32>, [UInt8])]
+) {
+  for line in data.split(separator: "\n") {
+    // Skip comments
+    guard !line.hasPrefix("#") else {
+      continue
+    }
+    
+    let info = line.split(separator: "#")
+    let components = info[0].split(separator: ";")
+    
+    let scalars: ClosedRange<UInt32>
+    
+    let filteredScalars = components[0].filter { !$0.isWhitespace }
+    
+    // If we have . appear, it means we have a legitimate range. Otherwise,
+    // it's a singular scalar.
+    if filteredScalars.contains(".") {
+      let range = filteredScalars.split(separator: ".")
+      
+      scalars = UInt32(range[0], radix: 16)! ... UInt32(range[1], radix: 16)!
+    } else {
+      let scalar = UInt32(filteredScalars, radix: 16)!
+      
+      scalars = scalar ... scalar
+    }
+    
+    let version = components[1].filter { !$0.isWhitespace }
+    let parts = version.split(separator: ".")
+    
+    let major = UInt8(parts[0])!
+    let minor = UInt8(parts[1])!
+    
+    result.append((scalars, [major, minor]))
+  }
+}
+
+func emitAge(
+  data: [(ClosedRange<UInt32>, [UInt8])],
+  into result: inout String
+) {
+  var uniqueAges: Set<[UInt8]> = []
+  
+  for (_, age) in data {
+    uniqueAges.insert(age)
+  }
+  
+  let ages = uniqueAges.map {
+    UInt16($0[0]) | (UInt16($0[1]) << 8)
+  }
+  
+  emitCollection(ages, name: "_swift_stdlib_ages_data", into: &result)
+  
+  emitCollection(
+    data,
+    name: "_swift_stdlib_ages",
+    type: "__swift_uint64_t",
+    into: &result
+  ) {
+    var value: UInt64 = UInt64($0.0.lowerBound)
+    
+    let age = UInt16($0.1[0]) | (UInt16($0.1[1]) << 8)
+    let ageIndex = ages.firstIndex(of: age)!
+    
+    value |= UInt64(ageIndex) << 21
+    
+    value |= UInt64($0.0.count - 1) << 32
+    
+    return "0x\(String(value, radix: 16, uppercase: true))"
+  }
+}
+
+func generateAgeProp(into result: inout String) {
+  let derivedAge = readFile("Data/DerivedAge.txt")
+  
+  var ageData: [(ClosedRange<UInt32>, [UInt8])] = []
+  
+  getAge(from: derivedAge, into: &ageData)
+  
+  emitAge(data: flatten(ageData), into: &result)
+}

utils/gen-unicode-data/Sources/GenScalarProps/GeneralCategory.swift

@@ -0,0 +1,182 @@
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2021 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+import GenUtils
+
+enum GeneralCategory: String {
+  case uppercaseLetter = "Lu"
+  case lowercaseLetter = "Ll"
+  case titlecaseLetter = "Lt"
+  case modifierLetter = "Lm"
+  case otherLetter = "Lo"
+  case nonspacingMark = "Mn"
+  case spacingMark = "Mc"
+  case enclosingMark = "Me"
+  case decimalNumber = "Nd"
+  case letterNumber = "Nl"
+  case otherNumber = "No"
+  case connectorPunctuation = "Pc"
+  case dashPunctuation = "Pd"
+  case openPunctuation = "Ps"
+  case closePunctuation = "Pe"
+  case initialPunctuation = "Pi"
+  case finalPunctuation = "Pf"
+  case otherPunctuation = "Po"
+  case mathSymbol = "Sm"
+  case currencySymbol = "Sc"
+  case modifierSymbol = "Sk"
+  case otherSymbol = "So"
+  case spaceSeperator = "Zs"
+  case lineSeperator = "Zl"
+  case paragraphSeperator = "Zp"
+  case control = "Cc"
+  case format = "Cf"
+  case surrogate = "Cs"
+  case privateUse = "Co"
+  case unassigned = "Cn"
+  
+  var binaryRepresentation: UInt8 {
+    switch self {
+    case .uppercaseLetter:
+      return 0
+    case .lowercaseLetter:
+      return 1
+    case .titlecaseLetter:
+      return 2
+    case .modifierLetter:
+      return 3
+    case .otherLetter:
+      return 4
+    case .nonspacingMark:
+      return 5
+    case .spacingMark:
+      return 6
+    case .enclosingMark:
+      return 7
+    case .decimalNumber:
+      return 8
+    case .letterNumber:
+      return 9
+    case .otherNumber:
+      return 10
+    case .connectorPunctuation:
+      return 11
+    case .dashPunctuation:
+      return 12
+    case .openPunctuation:
+      return 13
+    case .closePunctuation:
+      return 14
+    case .initialPunctuation:
+      return 15
+    case .finalPunctuation:
+      return 16
+    case .otherPunctuation:
+      return 17
+    case .mathSymbol:
+      return 18
+    case .currencySymbol:
+      return 19
+    case .modifierSymbol:
+      return 20
+    case .otherSymbol:
+      return 21
+    case .spaceSeperator:
+      return 22
+    case .lineSeperator:
+      return 23
+    case .paragraphSeperator:
+      return 24
+    case .control:
+      return 25
+    case .format:
+      return 26
+    case .surrogate:
+      return 27
+    case .privateUse:
+      return 28
+    case .unassigned:
+      return 29
+    }
+  }
+}
+
+func getGeneralCategory(
+  from data: String,
+  into result: inout [(ClosedRange<UInt32>, GeneralCategory)]
+) {
+  for line in data.split(separator: "\n") {
+    // Skip comments
+    guard !line.hasPrefix("#") else {
+      continue
+    }
+    
+    let info = line.split(separator: "#")
+    let components = info[0].split(separator: ";")
+    
+    let filteredCategory = components[1].filter { !$0.isWhitespace }
+    
+    guard let gc = GeneralCategory(rawValue: filteredCategory) else {
+      continue
+    }
+    
+    let scalars: ClosedRange<UInt32>
+    
+    let filteredScalars = components[0].filter { !$0.isWhitespace }
+    
+    // If we have . appear, it means we have a legitimate range. Otherwise,
+    // it's a singular scalar.
+    if filteredScalars.contains(".") {
+      let range = filteredScalars.split(separator: ".")
+      
+      scalars = UInt32(range[0], radix: 16)! ... UInt32(range[1], radix: 16)!
+    } else {
+      let scalar = UInt32(filteredScalars, radix: 16)!
+      
+      scalars = scalar ... scalar
+    }
+    
+    result.append((scalars, gc))
+  }
+}
+
+func emitGeneralCategory(
+  _ data: [(ClosedRange<UInt32>, GeneralCategory)],
+  into result: inout String
+) {
+  emitCollection(
+    data,
+    name: "_swift_stdlib_generalCategory",
+    type: "__swift_uint64_t",
+    into: &result
+  ) {
+    var value: UInt64 = UInt64($0.0.lowerBound)
+    
+    let generalCategory = $0.1.binaryRepresentation
+    
+    value |= UInt64(generalCategory) << 21
+    
+    value |= UInt64($0.0.count - 1) << 32
+    
+    return "0x\(String(value, radix: 16, uppercase: true))"
+  }
+}
+
+func generateGeneralCategory(into result: inout String) {
+  let derivedGeneralCategory = readFile("Data/DerivedGeneralCategory.txt")
+  
+  var data: [(ClosedRange<UInt32>, GeneralCategory)] = []
+  
+  getGeneralCategory(from: derivedGeneralCategory, into: &data)
+  
+  emitGeneralCategory(flatten(data), into: &result)
+}

utils/gen-unicode-data/Sources/GenScalarProps/Mappings.swift

@@ -0,0 +1,480 @@
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2021 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+import GenUtils
+
+func getMappings(
+  from data: String,
+  into dict: inout [UInt32: (Int?, Int?, Int?)]
+) {
+  for line in data.split(separator: "\n") {
+    let components = line.split(separator: ";", omittingEmptySubsequences: false)
+    
+    let uppercaseMapping = Int(components[12], radix: 16)
+    let lowercaseMapping = Int(components[13], radix: 16)
+    let titlecaseMapping = Int(components[14], radix: 16)
+    
+    guard uppercaseMapping != nil ||
+          lowercaseMapping != nil ||
+          titlecaseMapping != nil else {
+      continue
+    }
+    
+    let scalarStr = components[0]
+    let scalar = UInt32(scalarStr, radix: 16)!
+    
+    dict[scalar] = (uppercaseMapping, lowercaseMapping, titlecaseMapping)
+  }
+}
+
+func getSpecialMappings(
+  from data: String,
+  into dict: inout [UInt32: ([UInt32], [UInt32], [UInt32])]
+) {
+  for line in data.split(separator: "\n") {
+    guard !line.hasPrefix("#") else {
+      continue
+    }
+    
+    let components = line.split(separator: ";", omittingEmptySubsequences: false)
+    
+    // Conditional mappings have an extra component with the conditional name.
+    // Ignore those.
+    guard components.count == 5 else {
+      continue
+    }
+    
+    let scalar = UInt32(components[0], radix: 16)!
+    
+    let lowercaseMapping = components[1].split(separator: " ").map {
+      UInt32($0, radix: 16)!
+    }
+    
+    let titlecaseMapping = components[2].split(separator: " ").map {
+      UInt32($0, radix: 16)!
+    }
+    
+    let uppercaseMapping = components[3].split(separator: " ").map {
+      UInt32($0, radix: 16)!
+    }
+    
+    dict[scalar] = (uppercaseMapping, lowercaseMapping, titlecaseMapping)
+  }
+}
+
+func emitMappings(
+  _ data: [UInt32: (Int?, Int?, Int?)],
+  into result: inout String
+) {
+  var uniqueDistances: Set<Int> = []
+
+  for (scalar, mappings) in data {
+    if let uppercaseMapping = mappings.0 {
+      uniqueDistances.insert(uppercaseMapping - Int(scalar))
+    }
+    
+    if let lowercaseMapping = mappings.1 {
+      uniqueDistances.insert(lowercaseMapping - Int(scalar))
+    }
+    
+    if let titlecaseMapping = mappings.2 {
+      uniqueDistances.insert(titlecaseMapping - Int(scalar))
+    }
+  }
+  
+  let distances = Array(uniqueDistances)
+  
+  // 64 bit arrays * 8 bytes = .512 KB
+  var bitArrays: [BitArray] = .init(repeating: .init(size: 64), count: 64)
+  
+  let chunkSize = 0x110000 / 64 / 64
+  
+  var chunks: [Int] = []
+  
+  for i in 0 ..< 64 * 64 {
+    let lower = i * chunkSize
+    let upper = lower + chunkSize - 1
+    
+    let idx = i / 64
+    let bit = i % 64
+    
+    for scalar in lower ... upper {
+      if data.contains(where: { $0.0 == scalar }) {
+        chunks.append(i)
+        
+        bitArrays[idx][bit] = true
+        break
+      }
+    }
+  }
+  
+  // Remove the trailing 0s. Currently this reduces quick look size down to
+  // 96 bytes from 512 bytes.
+  var reducedBA = Array(bitArrays.reversed())
+  reducedBA = Array(reducedBA.drop {
+    $0.words == [0x0]
+  })
+  
+  bitArrays = reducedBA.reversed()
+  
+  // Keep a record of every rank for all the bitarrays.
+  var ranks: [UInt16] = []
+  
+  // Record our quick look ranks.
+  var lastRank: UInt16 = 0
+  for (i, _) in bitArrays.enumerated() {
+    guard i != 0 else {
+      ranks.append(0)
+      continue
+    }
+    
+    var rank = UInt16(bitArrays[i - 1].words[0].nonzeroBitCount)
+    rank += lastRank
+    
+    ranks.append(rank)
+    
+    lastRank = rank
+  }
+  
+  // Insert our quick look size at the beginning.
+  var size = BitArray(size: 64)
+  size.words = [UInt64(bitArrays.count)]
+  bitArrays.insert(size, at: 0)
+  
+  var dataIndices: [UInt32] = []
+  
+  for chunk in chunks {
+    var chunkBA = BitArray(size: chunkSize)
+    
+    let lower = chunk * chunkSize
+    let upper = lower + chunkSize
+    
+    let chunkDataIdx = UInt64(dataIndices.endIndex)
+    
+    // Insert our chunk's data index in the upper bits of the last word of our
+    // bit array.
+    chunkBA.words[chunkBA.words.endIndex - 1] |= chunkDataIdx << 16
+    
+    for scalar in lower ..< upper {
+      if data.contains(where: { $0.0 == scalar }) {
+        chunkBA[scalar % chunkSize] = true
+        
+        let mappings = data[UInt32(scalar)]!
+        
+        var dataIdx: UInt32 = 0
+        
+        if let uppercaseMapping = mappings.0 {
+          let distance = uppercaseMapping - scalar
+          let uppercaseIdx = distances.firstIndex(of: distance)!
+          
+          dataIdx = UInt32(uppercaseIdx)
+        } else {
+          dataIdx = UInt32(UInt8.max)
+        }
+        
+        if let lowercaseMapping = mappings.1 {
+          let distance = lowercaseMapping - scalar
+          let lowercaseIdx = distances.firstIndex(of: distance)!
+          
+          dataIdx |= UInt32(lowercaseIdx) << 8
+        } else {
+          dataIdx |= UInt32(UInt8.max) << 8
+        }
+        
+        if let titlecaseMapping = mappings.2 {
+          let distance = titlecaseMapping - scalar
+          let titlecaseIdx = distances.firstIndex(of: distance)!
+          
+          dataIdx |= UInt32(titlecaseIdx) << 16
+        } else {
+          dataIdx |= UInt32(UInt8.max) << 16
+        }
+        
+        dataIndices.append(dataIdx)
+      }
+    }
+    
+    // Append our chunk bit array's rank.
+    var lastRank: UInt16 = 0
+    for (i, _) in chunkBA.words.enumerated() {
+      guard i != 0 else {
+        ranks.append(0)
+        continue
+      }
+      
+      var rank = UInt16(chunkBA.words[i - 1].nonzeroBitCount)
+      rank += lastRank
+      
+      ranks.append(rank)
+      lastRank = rank
+    }
+    
+    bitArrays += chunkBA.words.map {
+      var ba = BitArray(size: 64)
+      ba.words = [$0]
+      return ba
+    }
+  }
+  
+  emitCollection(
+    distances,
+    name: "_swift_stdlib_mappings_data",
+    type: "__swift_int32_t",
+    into: &result
+  ) {
+    "\($0)"
+  }
+  
+  emitCollection(
+    dataIndices,
+    name: "_swift_stdlib_mappings_data_indices",
+    into: &result
+  )
+  
+  emitCollection(
+    ranks,
+    name: "_swift_stdlib_mappings_ranks",
+    into: &result
+  )
+  
+  emitCollection(
+    bitArrays,
+    name: "_swift_stdlib_mappings",
+    type: "__swift_uint64_t",
+    into: &result
+  ) {
+    assert($0.words.count == 1)
+    return "0x\(String($0.words[0], radix: 16, uppercase: true))"
+  }
+}
+
+func emitSpecialMappings(
+  _ data: [UInt32: ([UInt32], [UInt32], [UInt32])],
+  into result: inout String
+) {
+  var specialMappings: [UInt8] = []
+  var index: UInt32 = 0
+  var scalarIndices: [UInt32: UInt32] = [:]
+  
+  for (scalar, (uppercase, lowercase, titlecase)) in data {
+    scalarIndices[scalar] = index
+    
+    index += 1
+    if uppercase.count == 1 {
+      specialMappings.append(0)
+    } else {
+      let uppercase = uppercase.map { Unicode.Scalar($0)! }
+      
+      var utf8Length: UInt8 = 0
+      
+      for scalar in uppercase {
+        utf8Length += UInt8(scalar.utf8.count)
+      }
+      
+      specialMappings.append(utf8Length)
+      
+      for scalar in uppercase {
+        for byte in String(scalar).utf8 {
+          specialMappings.append(byte)
+          index += 1
+        }
+      }
+    }
+    
+    index += 1
+    if lowercase.count == 1 {
+      specialMappings.append(0)
+    } else {
+      let lowercase = lowercase.map { Unicode.Scalar($0)! }
+      
+      var utf8Length: UInt8 = 0
+      
+      for scalar in lowercase {
+        utf8Length += UInt8(scalar.utf8.count)
+      }
+      
+      specialMappings.append(utf8Length)
+      
+      for scalar in lowercase {
+        for byte in String(scalar).utf8 {
+          specialMappings.append(byte)
+          index += 1
+        }
+      }
+    }
+    
+    index += 1
+    if titlecase.count == 1 {
+      specialMappings.append(0)
+    } else {
+      let titlecase = titlecase.map { Unicode.Scalar($0)! }
+      
+      var utf8Length: UInt8 = 0
+      
+      for scalar in titlecase {
+        utf8Length += UInt8(scalar.utf8.count)
+      }
+      
+      specialMappings.append(utf8Length)
+      
+      for scalar in titlecase {
+        for byte in String(scalar).utf8 {
+          specialMappings.append(byte)
+          index += 1
+        }
+      }
+    }
+  }
+  
+  // 64 bit arrays * 8 bytes = .512 KB
+  var bitArrays: [BitArray] = .init(repeating: .init(size: 64), count: 64)
+  
+  let chunkSize = 0x110000 / 64 / 64
+  
+  var chunks: [Int] = []
+  
+  for i in 0 ..< 64 * 64 {
+    let lower = i * chunkSize
+    let upper = lower + chunkSize - 1
+    
+    let idx = i / 64
+    let bit = i % 64
+    
+    for scalar in lower ... upper {
+      if data.contains(where: { $0.0 == scalar }) {
+        chunks.append(i)
+        
+        bitArrays[idx][bit] = true
+        break
+      }
+    }
+  }
+  
+  // Remove the trailing 0s. Currently this reduces quick look size down to
+  // 96 bytes from 512 bytes.
+  var reducedBA = Array(bitArrays.reversed())
+  reducedBA = Array(reducedBA.drop {
+    $0.words == [0x0]
+  })
+  
+  bitArrays = reducedBA.reversed()
+  
+  // Keep a record of every rank for all the bitarrays.
+  var ranks: [UInt16] = []
+  
+  // Record our quick look ranks.
+  var lastRank: UInt16 = 0
+  for (i, _) in bitArrays.enumerated() {
+    guard i != 0 else {
+      ranks.append(0)
+      continue
+    }
+    
+    var rank = UInt16(bitArrays[i - 1].words[0].nonzeroBitCount)
+    rank += lastRank
+    
+    ranks.append(rank)
+    
+    lastRank = rank
+  }
+  
+  // Insert our quick look size at the beginning.
+  var size = BitArray(size: 64)
+  size.words = [UInt64(bitArrays.count)]
+  bitArrays.insert(size, at: 0)
+  
+  var dataIndices: [UInt16] = []
+  
+  for chunk in chunks {
+    var chunkBA = BitArray(size: chunkSize)
+    
+    let lower = chunk * chunkSize
+    let upper = lower + chunkSize
+    
+    let chunkDataIdx = UInt64(dataIndices.endIndex)
+    
+    // Insert our chunk's data index in the upper bits of the last word of our
+    // bit array.
+    chunkBA.words[chunkBA.words.endIndex - 1] |= chunkDataIdx << 16
+    
+    for scalar in lower ..< upper {
+      if data.contains(where: { $0.0 == scalar }) {
+        chunkBA[scalar % chunkSize] = true
+        
+        let dataIdx = UInt16(scalarIndices[UInt32(scalar)]!)
+        dataIndices.append(dataIdx)
+      }
+    }
+    
+    // Append our chunk bit array's rank.
+    var lastRank: UInt16 = 0
+    for (i, _) in chunkBA.words.enumerated() {
+      guard i != 0 else {
+        ranks.append(0)
+        continue
+      }
+      
+      var rank = UInt16(chunkBA.words[i - 1].nonzeroBitCount)
+      rank += lastRank
+      
+      ranks.append(rank)
+      lastRank = rank
+    }
+    
+    bitArrays += chunkBA.words.map {
+      var ba = BitArray(size: 64)
+      ba.words = [$0]
+      return ba
+    }
+  }
+  
+  emitCollection(
+    specialMappings,
+    name: "_swift_stdlib_special_mappings_data",
+    into: &result
+  )
+  
+  emitCollection(
+    dataIndices,
+    name: "_swift_stdlib_special_mappings_data_indices",
+    into: &result
+  )
+  
+  emitCollection(
+    ranks,
+    name: "_swift_stdlib_special_mappings_ranks",
+    into: &result
+  )
+  
+  emitCollection(
+    bitArrays,
+    name: "_swift_stdlib_special_mappings",
+    type: "__swift_uint64_t",
+    into: &result
+  ) {
+    assert($0.words.count == 1)
+    return "0x\(String($0.words[0], radix: 16, uppercase: true))"
+  }
+}
+
+func generateMappingProps(into result: inout String) {
+  let unicodeData = readFile("Data/UnicodeData.txt")
+  let specialCasing = readFile("Data/SpecialCasing.txt")
+  
+  var data: [UInt32: (Int?, Int?, Int?)] = [:]
+  getMappings(from: unicodeData, into: &data)
+  emitMappings(data, into: &result)
+  
+  var specialMappings: [UInt32: ([UInt32], [UInt32], [UInt32])] = [:]
+  getSpecialMappings(from: specialCasing, into: &specialMappings)
+  emitSpecialMappings(specialMappings, into: &result)
+}

utils/gen-unicode-data/Sources/GenScalarProps/NameAlias.swift

@@ -0,0 +1,192 @@
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2021 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+import GenUtils
+
+func getNameAliases(from data: String, into result: inout [(UInt32, String)]) {
+  for line in data.split(separator: "\n") {
+    // Skip comments
+    guard !line.hasPrefix("#") else {
+      continue
+    }
+    
+    let info = line.split(separator: "#")
+    let components = info[0].split(separator: ";")
+    
+    // Name aliases are only found with correction attribute.
+    guard components[2] == "correction" else {
+      continue
+    }
+    
+    let scalars: ClosedRange<UInt32>
+    
+    let filteredScalars = components[0].filter { !$0.isWhitespace }
+    
+    // If we have . appear, it means we have a legitimate range. Otherwise,
+    // it's a singular scalar.
+    if filteredScalars.contains(".") {
+      let range = filteredScalars.split(separator: ".")
+      
+      scalars = UInt32(range[0], radix: 16)! ... UInt32(range[1], radix: 16)!
+    } else {
+      let scalar = UInt32(filteredScalars, radix: 16)!
+      
+      scalars = scalar ... scalar
+    }
+    
+    let nameAlias = String(components[1])
+    
+    result.append((scalars.lowerBound, nameAlias))
+  }
+}
+
+func emitNameAliases(_ data: [(UInt32, String)], into result: inout String) {
+  // 64 bit arrays * 8 bytes = .512 KB
+  var bitArrays: [BitArray] = .init(repeating: .init(size: 64), count: 64)
+  
+  let chunkSize = 0x110000 / 64 / 64
+  
+  var chunks: [Int] = []
+  
+  for i in 0 ..< 64 * 64 {
+    let lower = i * chunkSize
+    let upper = lower + chunkSize - 1
+    
+    let idx = i / 64
+    let bit = i % 64
+    
+    for scalar in lower ... upper {
+      if data.contains(where: { $0.0 == scalar }) {
+        chunks.append(i)
+        
+        bitArrays[idx][bit] = true
+        break
+      }
+    }
+  }
+  
+  // Remove the trailing 0s. Currently this reduces quick look size down to
+  // 96 bytes from 512 bytes.
+  var reducedBA = Array(bitArrays.reversed())
+  reducedBA = Array(reducedBA.drop {
+    $0.words == [0x0]
+  })
+  
+  bitArrays = reducedBA.reversed()
+  
+  // Keep a record of every rank for all the bitarrays.
+  var ranks: [UInt16] = []
+  
+  // Record our quick look ranks.
+  var lastRank: UInt16 = 0
+  for (i, _) in bitArrays.enumerated() {
+    guard i != 0 else {
+      ranks.append(0)
+      continue
+    }
+    
+    var rank = UInt16(bitArrays[i - 1].words[0].nonzeroBitCount)
+    rank += lastRank
+    
+    ranks.append(rank)
+    
+    lastRank = rank
+  }
+  
+  // Insert our quick look size at the beginning.
+  var size = BitArray(size: 64)
+  size.words = [UInt64(bitArrays.count)]
+  bitArrays.insert(size, at: 0)
+  
+  var nameAliasData: [String] = []
+  
+  for chunk in chunks {
+    var chunkBA = BitArray(size: chunkSize)
+    
+    let lower = chunk * chunkSize
+    let upper = lower + chunkSize
+    
+    let chunkDataIdx = UInt64(nameAliasData.endIndex)
+    
+    // Insert our chunk's data index in the upper bits of the last word of our
+    // bit array.
+    chunkBA.words[chunkBA.words.endIndex - 1] |= chunkDataIdx << 16
+    
+    for scalar in lower ..< upper {
+      if data.contains(where: { $0.0 == scalar }) {
+        chunkBA[scalar % chunkSize] = true
+        
+        let data = data[data.firstIndex {
+          $0.0 == scalar
+        }!].1
+        
+        nameAliasData.append(data)
+      }
+    }
+    
+    // Append our chunk bit array's rank.
+    var lastRank: UInt16 = 0
+    for (i, _) in chunkBA.words.enumerated() {
+      guard i != 0 else {
+        ranks.append(0)
+        continue
+      }
+      
+      var rank = UInt16(chunkBA.words[i - 1].nonzeroBitCount)
+      rank += lastRank
+      
+      ranks.append(rank)
+      lastRank = rank
+    }
+    
+    bitArrays += chunkBA.words.map {
+      var ba = BitArray(size: 64)
+      ba.words = [$0]
+      return ba
+    }
+  }
+  
+  emitCollection(
+    nameAliasData,
+    name: "_swift_stdlib_nameAlias_data",
+    type: "char * const",
+    into: &result
+  ) {
+    "\"\($0)\""
+  }
+  
+  emitCollection(
+    ranks,
+    name: "_swift_stdlib_nameAlias_ranks",
+    into: &result
+  )
+  
+  emitCollection(
+    bitArrays,
+    name: "_swift_stdlib_nameAlias",
+    type: "__swift_uint64_t",
+    into: &result
+  ) {
+    assert($0.words.count == 1)
+    return "0x\(String($0.words[0], radix: 16, uppercase: true))"
+  }
+}
+
+func generateNameAliasProp(into result: inout String) {
+  let nameAliases = readFile("Data/NameAliases.txt")
+  
+  var data: [(UInt32, String)] = []
+  
+  getNameAliases(from: nameAliases, into: &data)
+  
+  emitNameAliases(data, into: &result)
+}

utils/gen-unicode-data/Sources/GenScalarProps/Names.swift

@@ -0,0 +1,259 @@
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2021 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+import GenUtils
+
+func getName(
+  from data: String,
+  into result: inout [(UInt32, String)],
+  words: inout [String]
+) {
+  var uniqueWords: Set<String> = []
+  
+  for line in data.split(separator: "\n") {
+    // Skip comments
+    guard !line.hasPrefix("#") else {
+      continue
+    }
+    
+    let info = line.split(separator: "#")
+    let components = info[0].split(separator: ";")
+    
+    let name = String(components[1].dropFirst())
+    
+    let filteredScalars = components[0].filter { !$0.isWhitespace }
+    
+    if filteredScalars.contains(".") {
+      continue
+    }
+    
+    let scalar = UInt32(filteredScalars, radix: 16)!
+    
+    if (0xE0100...0xE01EF).contains(scalar) {
+      continue
+    }
+    
+    if scalar >= 0xAC00, scalar <= 0xD7A3 {
+      continue
+    }
+    
+    result.append((scalar, name))
+    
+    for word in name.split(separator: " ") {
+      uniqueWords.insert(String(word))
+    }
+  }
+  
+  words = Array(uniqueWords)
+}
+
+func sortWords(
+  _ words: inout [String],
+  from data: [(UInt32, String)]
+) {
+  var popularity: [String: Int] = [:]
+  
+  for (_, name) in data {
+    let scalarWords = name.split(separator: " ")
+    
+    for word in scalarWords {
+      popularity[String(word), default: 0] += 1
+    }
+  }
+  
+  let sortedPopularity = Array(popularity).sorted { $0.value > $1.value }
+  
+  
+  words = sortedPopularity.map { $0.key }
+}
+
+func emitWords(
+  _ words: [String],
+  into result: inout String
+) -> [String: UInt32] {
+  var wordIndices: [String: UInt32] = [:]
+  var bytes: [UInt8] = []
+  
+  var index: UInt32 = 0
+  
+  for word in words {
+    wordIndices[word] = index
+    
+    for (i, byte) in word.utf8.enumerated() {
+      var element = byte
+      
+      if i == word.utf8.count - 1 {
+        element |= 0x80
+      }
+      
+      bytes.append(element)
+      index += 1
+    }
+  }
+  
+  emitCollection(bytes, name: "_swift_stdlib_words", into: &result)
+  
+  return wordIndices
+}
+
+func emitWordOffsets(
+  _ wordOffsets: [String: UInt32],
+  into result: inout String
+) -> [String: UInt32] {
+  let sortedWordOffsets = Array(wordOffsets).sorted { $0.value < $1.value }
+  
+  var wordIndices: [String: UInt32] = [:]
+  
+  for (i, (word, _)) in sortedWordOffsets.enumerated() {
+    wordIndices[word] = UInt32(i)
+  }
+  
+  emitCollection(
+    sortedWordOffsets.map { $0.value },
+    name: "_swift_stdlib_word_indices",
+    into: &result
+  )
+  
+  return wordIndices
+}
+
+func emitScalarNames(
+  _ names: [(UInt32, String)],
+  _ wordIndices: [String: UInt32],
+  into result: inout String
+) -> [UInt32: UInt32] {
+  var nameBytes: [UInt8] = []
+  
+  var scalarNameIndices: [UInt32: UInt32] = [:]
+  
+  var index: UInt32 = 0
+  
+  for (scalar, name) in names.sorted(by: { $0.0 < $1.0 }) {
+    scalarNameIndices[scalar] = index
+    
+    for word in name.split(separator: " ") {
+      let wordIndex = wordIndices[String(word)]!
+      
+      // If the word index is smaller than 0xFF, then we don't need to add the
+      // extra byte to represent the index.
+      if wordIndex < 0xFF {
+        nameBytes.append(UInt8(wordIndex))
+        index += 1
+      } else {
+        assert(wordIndex <= UInt16.max)
+        
+        nameBytes.append(0xFF)
+        nameBytes.append(UInt8(wordIndex & 0xFF))
+        nameBytes.append(UInt8(wordIndex >> 8))
+        index += 3
+      }
+    }
+  }
+  
+  emitCollection(nameBytes, name: "_swift_stdlib_names", into: &result)
+  
+  return scalarNameIndices
+}
+
+func emitScalars(
+  _ scalarNameIndices: [UInt32: UInt32],
+  into result: inout String
+) -> [UInt32: UInt16] {
+  var scalars: [UInt32] = []
+  var scalarSetIndices: [UInt32: UInt16] = [:]
+  var index: UInt16 = 0
+  
+  for i in 0x0 ... 0x10FFFF >> 7 {
+    let scalarRange = i << 7 ..< i << 7 + 128
+    let filteredRange = scalarRange.filter {
+      scalarNameIndices.keys.contains(UInt32($0))
+    }
+    
+    scalarSetIndices[UInt32(i)] = index
+    
+    if filteredRange.count >= 1 {
+      scalarSetIndices[UInt32(i)] = index
+      
+      for scalar in scalarRange {
+        index += 1
+        
+        guard let index = scalarNameIndices[UInt32(scalar)] else {
+          scalars.append(0)
+          continue
+        }
+        
+        scalars.append(index)
+      }
+    } else {
+      scalarSetIndices[UInt32(i)] = UInt16.max
+    }
+  }
+  
+  emitCollection(scalars, name: "_swift_stdlib_names_scalars", into: &result)
+  
+  return scalarSetIndices
+}
+
+func emitScalarSets(
+  _ scalarSetIndices: [UInt32: UInt16],
+  into result: inout String
+) {
+  var scalarSets: [UInt16] = []
+  
+  for i in 0x0 ... 0x10FFFF >> 7 {
+    let index = scalarSetIndices[UInt32(i)]!
+    
+    guard index != .max else {
+      scalarSets.append(index)
+      continue
+    }
+    
+    scalarSets.append(index >> 7)
+  }
+  
+  emitCollection(scalarSets, name: "_swift_stdlib_names_scalar_sets", into: &result)
+}
+
+func emitLargestNameCount(_ names: [(UInt32, String)], into result: inout String) {
+  var largestCount = 0
+  
+  for (_, name) in names {
+    largestCount = Swift.max(largestCount, name.count)
+  }
+  
+  print("""
+  Please copy and paste the following into 'stdlib/public/SwiftShims/UnicodeData.h':
+  
+  #define SWIFT_STDLIB_LARGEST_NAME_COUNT \(largestCount)
+  
+  """)
+}
+
+func generateNameProp(into result: inout String) {
+  let derivedName = readFile("Data/DerivedName.txt")
+  
+  var names: [(UInt32, String)] = []
+  var words: [String] = []
+  
+  getName(from: derivedName, into: &names, words: &words)
+  
+  sortWords(&words, from: names)
+  
+  emitLargestNameCount(names, into: &result)
+  
+  let wordOffsets = emitWords(words, into: &result)
+  let wordIndices = emitWordOffsets(wordOffsets, into: &result)
+  
+  let scalarNameIndices = emitScalarNames(names, wordIndices, into: &result)
+  let scalarSetIndices = emitScalars(scalarNameIndices, into: &result)
+  emitScalarSets(scalarSetIndices, into: &result)
+}

utils/gen-unicode-data/Sources/GenScalarProps/Numeric.swift

@@ -0,0 +1,182 @@
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2021 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+import GenUtils
+
+enum NumericType: String {
+  case numeric = "Numeric"
+  case digit = "Digit"
+  case decimal = "Decimal"
+  
+  var binaryRepresentation: UInt32 {
+    switch self {
+    case .numeric:
+      return 0
+    case .digit:
+      return 1
+    case .decimal:
+      return 2
+    }
+  }
+}
+
+func getNumericTypes(
+  from data: String,
+  into result: inout [(ClosedRange<UInt32>, NumericType)]
+) {
+  for line in data.split(separator: "\n") {
+    // Skip comments
+    guard !line.hasPrefix("#") else {
+      continue
+    }
+    
+    let info = line.split(separator: "#")
+    let components = info[0].split(separator: ";")
+    
+    let filteredProperty = components[1].filter { !$0.isWhitespace }
+    
+    guard let numericType = NumericType(rawValue: filteredProperty) else {
+      continue
+    }
+    
+    let scalars: ClosedRange<UInt32>
+    
+    let filteredScalars = components[0].filter { !$0.isWhitespace }
+    
+    // If we have . appear, it means we have a legitimate range. Otherwise,
+    // it's a singular scalar.
+    if filteredScalars.contains(".") {
+      let range = filteredScalars.split(separator: ".")
+      
+      scalars = UInt32(range[0], radix: 16)! ... UInt32(range[1], radix: 16)!
+    } else {
+      let scalar = UInt32(filteredScalars, radix: 16)!
+      
+      scalars = scalar ... scalar
+    }
+    
+    result.append((scalars, numericType))
+  }
+}
+
+func getNumericValues(
+  from data: String,
+  into result: inout [(ClosedRange<UInt32>, String)]
+) {
+  for line in data.split(separator: "\n") {
+    // Skip comments
+    guard !line.hasPrefix("#") else {
+      continue
+    }
+    
+    let info = line.split(separator: "#")
+    let components = info[0].split(separator: ";")
+    
+    let filteredValue = components[3].filter { !$0.isWhitespace }
+    
+    let scalars: ClosedRange<UInt32>
+    
+    let filteredScalars = components[0].filter { !$0.isWhitespace }
+    
+    // If we have . appear, it means we have a legitimate range. Otherwise,
+    // it's a singular scalar.
+    if filteredScalars.contains(".") {
+      let range = filteredScalars.split(separator: ".")
+      
+      scalars = UInt32(range[0], radix: 16)! ... UInt32(range[1], radix: 16)!
+    } else {
+      let scalar = UInt32(filteredScalars, radix: 16)!
+      
+      scalars = scalar ... scalar
+    }
+    
+    result.append((scalars, filteredValue))
+  }
+}
+
+func emitNumericData(
+  types: [(ClosedRange<UInt32>, NumericType)],
+  values: [(ClosedRange<UInt32>, String)],
+  into result: inout String
+) {
+  emitCollection(
+    types,
+    name: "_swift_stdlib_numeric_type",
+    type: "__swift_uint32_t",
+    into: &result
+  ) { range, type in
+    var value = range.lowerBound
+    assert(range.count - 1 <= UInt8.max)
+    value |= UInt32(range.count - 1) << 21
+    
+    value |= type.binaryRepresentation << 29
+    
+    return "0x\(String(value, radix: 16, uppercase: true))"
+  }
+  
+  let uniqueValues = Array(Set(values.map { $0.1 }))
+  
+  emitCollection(
+    uniqueValues,
+    name: "_swift_stdlib_numeric_values",
+    type: "double",
+    into: &result
+  ) {
+    "(double) \($0)"
+  }
+  
+  var allScalars: [UInt64] = []
+  
+  for (range, _) in values {
+    for scalar in range {
+      allScalars.append(UInt64(scalar))
+    }
+  }
+  
+  let valueMph = mph(for: allScalars)
+  
+  emitMph(valueMph, name: "_swift_stdlib_numeric_values", into: &result)
+  
+  var valueIndices: [UInt8] = .init(repeating: 0, count: allScalars.count)
+  
+  for scalar in allScalars {
+    let idx = valueMph.index(for: scalar)
+    
+    let value = values.first { $0.0.contains(UInt32(scalar)) }!
+    let valueIdx = uniqueValues.firstIndex(of: value.1)!
+    
+    valueIndices[idx] = UInt8(valueIdx)
+  }
+  
+  emitCollection(
+    valueIndices,
+    name: "_swift_stdlib_numeric_values_indices",
+    into: &result
+  )
+}
+
+func generateNumericProps(into result: inout String) {
+  let derivedNumericType = readFile("Data/DerivedNumericType.txt")
+  let derivedNumericValues = readFile("Data/DerivedNumericValues.txt")
+  
+  var numericTypes: [(ClosedRange<UInt32>, NumericType)] = []
+  var numericValues: [(ClosedRange<UInt32>, String)] = []
+  
+  getNumericTypes(from: derivedNumericType, into: &numericTypes)
+  getNumericValues(from: derivedNumericValues, into: &numericValues)
+  
+  emitNumericData(
+    types: flatten(numericTypes),
+    values: flatten(numericValues),
+    into: &result
+  )
+}

utils/gen-unicode-data/Sources/GenScalarProps/main.swift

@@ -16,6 +16,12 @@ func generateScalarProps() {
   var result = readFile("Input/UnicodeScalarProps.cpp")
   
   generateBinaryProps(into: &result)
+  genericNumericProps(into: &result)
+  generateNameAliasProp(into: &result)
+  generateMappingProps(into: &result)
+  generateNameProp(into: &result)
+  generateAgeProp(into: &result)
+  generateGeneralCategory(into: &result)
   
   write(result, to: "../../stdlib/public/stubs/UnicodeScalarProps.cpp")
 }