averello/swift-mirror
1
0
Fork 0
mirror of https://github.com/apple/swift.git synced 2025-12-21 12:14:44 +01:00
Code Issues Packages Projects Releases Wiki Activity

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

Browse Source 
* 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
This commit is contained in:
Alejandro Alonso
2021-11-30 12:40:32 -08:00
committed by GitHub
parent 7c4ad9bd73
commit ac6c08f157
23 changed files with 80441 additions and 1075 deletions
Download Patch File Download Diff File Expand all files Collapse all files

63
stdlib/public/SwiftShims/UnicodeData.h
View File

@@ -21,6 +21,26 @@
extern "C" { extern "C" {
#endif #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_RUNTIME_STDLIB_INTERNAL
__swift_uint16_t _swift_stdlib_getNormData(__swift_uint32_t scalar); __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 _swift_stdlib_getComposition(__swift_uint32_t x,
__swift_uint32_t y); __swift_uint32_t y);
SWIFT_RUNTIME_STDLIB_INTERNAL //===----------------------------------------------------------------------===//
__swift_intptr_t _swift_stdlib_getMphIdx(__swift_uint32_t scalar, // Grapheme Breaking
__swift_intptr_t levels, //===----------------------------------------------------------------------===//
const __swift_uint64_t * const *keys,
const __swift_uint16_t * const *ranks,
const __swift_uint16_t * const sizes);
SWIFT_RUNTIME_STDLIB_INTERNAL SWIFT_RUNTIME_STDLIB_INTERNAL
__swift_uint8_t _swift_stdlib_getGraphemeBreakProperty(__swift_uint32_t scalar); __swift_uint8_t _swift_stdlib_getGraphemeBreakProperty(__swift_uint32_t scalar);
//===----------------------------------------------------------------------===//
// Unicode.Scalar.Properties
//===----------------------------------------------------------------------===//
SWIFT_RUNTIME_STDLIB_INTERNAL SWIFT_RUNTIME_STDLIB_INTERNAL
__swift_uint64_t _swift_stdlib_getBinaryProperties(__swift_uint32_t scalar); __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 #ifdef __cplusplus
} // extern "C" } // extern "C"
#endif #endif

58
stdlib/public/SwiftShims/UnicodeShims.h
View File

@@ -29,16 +29,6 @@
extern "C" { extern "C" {
#endif #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 { typedef enum __swift_stdlib_UProperty {
__swift_stdlib_UCHAR_GENERAL_CATEGORY = 0x1005, __swift_stdlib_UCHAR_GENERAL_CATEGORY = 0x1005,
__swift_stdlib_UCHAR_NUMERIC_TYPE = 0x1009, __swift_stdlib_UCHAR_NUMERIC_TYPE = 0x1009,
@@ -264,16 +254,6 @@ typedef enum __swift_stdlib_UCharNameChoice {
#endif #endif
} __swift_stdlib_UCharNameChoice; } __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_UBreakIterator __swift_stdlib_UBreakIterator;
typedef struct __swift_stdlib_UText __swift_stdlib_UText; typedef struct __swift_stdlib_UText __swift_stdlib_UText;
typedef __swift_int8_t __swift_stdlib_UBool; typedef __swift_int8_t __swift_stdlib_UBool;
@@ -291,44 +271,6 @@ typedef __swift_uint16_t __swift_stdlib_UChar;
typedef __swift_uint8_t typedef __swift_uint8_t
__swift_stdlib_UVersionInfo[__SWIFT_STDLIB_U_MAX_VERSION_LENGTH]; __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 #ifdef __cplusplus
} // extern "C" } // extern "C"
#endif #endif

82
stdlib/public/core/String.swift
View File

@@ -849,41 +849,14 @@ extension String {
} }
} }
// TODO(String performance): Try out incremental case-conversion rather than var result = ""
// make UTF-16 array beforehand result.reserveCapacity(utf8.count)
let codeUnits = Array(self.utf16).withUnsafeBufferPointer {
(uChars: UnsafeBufferPointer<UInt16>) -> Array<UInt16> in for scalar in unicodeScalars {
var length: Int = 0 result += scalar.properties.lowercaseMapping
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
}
}
return result
} }
return codeUnits.withUnsafeBufferPointer { String._uncheckedFromUTF16($0) }
return result
} }
/// Returns an uppercase version of the string. /// Returns an uppercase version of the string.
@@ -910,41 +883,14 @@ extension String {
} }
} }
// TODO(String performance): Try out incremental case-conversion rather than var result = ""
// make UTF-16 array beforehand result.reserveCapacity(utf8.count)
let codeUnits = Array(self.utf16).withUnsafeBufferPointer {
(uChars: UnsafeBufferPointer<UInt16>) -> Array<UInt16> in for scalar in unicodeScalars {
var length: Int = 0 result += scalar.properties.uppercaseMapping
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
}
}
return result
} }
return codeUnits.withUnsafeBufferPointer { String._uncheckedFromUTF16($0) }
return result
} }
/// Creates an instance from the description of a given /// Creates an instance from the description of a given

356
stdlib/public/core/UnicodeScalarProperties.swift
View File

@@ -26,11 +26,6 @@ extension Unicode.Scalar {
internal init(_ scalar: Unicode.Scalar) { internal init(_ scalar: Unicode.Scalar) {
self._scalar = 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. /// Properties of this scalar defined by the Unicode standard.
@@ -748,69 +743,50 @@ extension Unicode.Scalar.Properties {
/// Case mapping properties. /// Case mapping properties.
extension Unicode.Scalar.Properties { extension Unicode.Scalar.Properties {
// The type of ICU case conversion functions. fileprivate struct _CaseMapping {
internal typealias _U_StrToX = ( let rawValue: UInt8
/* dest */ UnsafeMutablePointer<__swift_stdlib_UChar>,
/* destCapacity */ Int32,
/* src */ UnsafePointer<__swift_stdlib_UChar>,
/* srcLength */ Int32,
/* locale */ UnsafePointer<Int8>,
/* pErrorCode */ UnsafeMutablePointer<__swift_stdlib_UErrorCode>
) -> Int32
/// Applies the given ICU string mapping to the scalar. static let uppercase = _CaseMapping(rawValue: 0)
/// static let lowercase = _CaseMapping(rawValue: 1)
/// This function attempts first to write the mapping into a stack-based static let titlecase = _CaseMapping(rawValue: 2)
/// 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. fileprivate func _getMapping(_ mapping: _CaseMapping) -> String {
internal func _applyMapping(_ u_strTo: _U_StrToX) -> String { // First, check if our scalar has a special mapping where it's mapped to
// Allocate 16 code units on the stack. // more than 1 scalar.
var fixedArray = _FixedArray16<UInt16>(allZeros: ()) var specialMappingLength = 0
let count: Int = fixedArray.withUnsafeMutableBufferPointer { buf in
return _scalar.withUTF16CodeUnits { utf16 in let specialMappingPtr = _swift_stdlib_getSpecialMapping(
var err = __swift_stdlib_U_ZERO_ERROR _scalar.value,
let correctSize = u_strTo( mapping.rawValue,
buf.baseAddress._unsafelyUnwrappedUnchecked, &specialMappingLength
Int32(buf.count), )
utf16.baseAddress._unsafelyUnwrappedUnchecked,
Int32(utf16.count), if let specialMapping = specialMappingPtr, specialMappingLength != 0 {
"", let buffer = UnsafeBufferPointer<UInt8>(
&err) start: specialMapping,
guard err.isSuccess else { count: specialMappingLength
fatalError("Unexpected error case-converting Unicode scalar.") )
}
return Int(correctSize) return String._uncheckedFromUTF8(buffer, isASCII: false)
}
} }
if _fastPath(count <= 16) {
fixedArray.count = count // If we did not have a special mapping, check if we have a direct scalar
return fixedArray.withUnsafeBufferPointer { // to scalar mapping.
String._uncheckedFromUTF16($0) let mappingDistance = _swift_stdlib_getMapping(
} _scalar.value,
} mapping.rawValue
// Allocate `count` code units on the heap. )
let array = Array<UInt16>(unsafeUninitializedCapacity: count) {
buf, initializedCount in if mappingDistance != 0 {
_scalar.withUTF16CodeUnits { utf16 in let scalar = Unicode.Scalar(
var err = __swift_stdlib_U_ZERO_ERROR _unchecked: UInt32(Int(_scalar.value) &+ Int(mappingDistance))
let correctSize = u_strTo( )
buf.baseAddress._unsafelyUnwrappedUnchecked, return String(scalar)
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. /// The lowercase mapping of the scalar.
@@ -824,7 +800,7 @@ extension Unicode.Scalar.Properties {
/// This property corresponds to the "Lowercase_Mapping" property in the /// This property corresponds to the "Lowercase_Mapping" property in the
/// [Unicode Standard](http://www.unicode.org/versions/latest/). /// [Unicode Standard](http://www.unicode.org/versions/latest/).
public var lowercaseMapping: String { public var lowercaseMapping: String {
return _applyMapping(__swift_stdlib_u_strToLower) _getMapping(.lowercase)
} }
/// The titlecase mapping of the scalar. /// The titlecase mapping of the scalar.
@@ -838,9 +814,7 @@ extension Unicode.Scalar.Properties {
/// This property corresponds to the "Titlecase_Mapping" property in the /// This property corresponds to the "Titlecase_Mapping" property in the
/// [Unicode Standard](http://www.unicode.org/versions/latest/). /// [Unicode Standard](http://www.unicode.org/versions/latest/).
public var titlecaseMapping: String { public var titlecaseMapping: String {
return _applyMapping { ptr, cap, src, len, locale, err in _getMapping(.titlecase)
return __swift_stdlib_u_strToTitle(ptr, cap, src, len, nil, locale, err)
}
} }
/// The uppercase mapping of the scalar. /// The uppercase mapping of the scalar.
@@ -854,7 +828,7 @@ extension Unicode.Scalar.Properties {
/// This property corresponds to the "Uppercase_Mapping" property in the /// This property corresponds to the "Uppercase_Mapping" property in the
/// [Unicode Standard](http://www.unicode.org/versions/latest/). /// [Unicode Standard](http://www.unicode.org/versions/latest/).
public var uppercaseMapping: String { 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 /// This property corresponds to the "Age" property in the
/// [Unicode Standard](http://www.unicode.org/versions/latest/). /// [Unicode Standard](http://www.unicode.org/versions/latest/).
public var age: Unicode.Version? { public var age: Unicode.Version? {
var versionInfo: __swift_stdlib_UVersionInfo = (0, 0, 0, 0) let age: UInt16 = _swift_stdlib_getAge(_scalar.value)
withUnsafeMutablePointer(to: &versionInfo) { tuplePtr in
tuplePtr.withMemoryRebound(to: UInt8.self, capacity: 4) { if age == .max {
versionInfoPtr in return nil
__swift_stdlib_u_charAge(icuValue, versionInfoPtr)
}
} }
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). /// [Unicode Standard](https://unicode.org/reports/tr44/#General_Category_Values).
case unassigned case unassigned
internal init(rawValue: __swift_stdlib_UCharCategory) { internal init(rawValue: UInt8) {
switch rawValue { switch rawValue {
case __swift_stdlib_U_UNASSIGNED: self = .unassigned case 0: self = .uppercaseLetter
case __swift_stdlib_U_UPPERCASE_LETTER: self = .uppercaseLetter case 1: self = .lowercaseLetter
case __swift_stdlib_U_LOWERCASE_LETTER: self = .lowercaseLetter case 2: self = .titlecaseLetter
case __swift_stdlib_U_TITLECASE_LETTER: self = .titlecaseLetter case 3: self = .modifierLetter
case __swift_stdlib_U_MODIFIER_LETTER: self = .modifierLetter case 4: self = .otherLetter
case __swift_stdlib_U_OTHER_LETTER: self = .otherLetter case 5: self = .nonspacingMark
case __swift_stdlib_U_NON_SPACING_MARK: self = .nonspacingMark case 6: self = .spacingMark
case __swift_stdlib_U_ENCLOSING_MARK: self = .enclosingMark case 7: self = .enclosingMark
case __swift_stdlib_U_COMBINING_SPACING_MARK: self = .spacingMark case 8: self = .decimalNumber
case __swift_stdlib_U_DECIMAL_DIGIT_NUMBER: self = .decimalNumber case 9: self = .letterNumber
case __swift_stdlib_U_LETTER_NUMBER: self = .letterNumber case 10: self = .otherNumber
case __swift_stdlib_U_OTHER_NUMBER: self = .otherNumber case 11: self = .connectorPunctuation
case __swift_stdlib_U_SPACE_SEPARATOR: self = .spaceSeparator case 12: self = .dashPunctuation
case __swift_stdlib_U_LINE_SEPARATOR: self = .lineSeparator case 13: self = .openPunctuation
case __swift_stdlib_U_PARAGRAPH_SEPARATOR: self = .paragraphSeparator case 14: self = .closePunctuation
case __swift_stdlib_U_CONTROL_CHAR: self = .control case 15: self = .initialPunctuation
case __swift_stdlib_U_FORMAT_CHAR: self = .format case 16: self = .finalPunctuation
case __swift_stdlib_U_PRIVATE_USE_CHAR: self = .privateUse case 17: self = .otherPunctuation
case __swift_stdlib_U_SURROGATE: self = .surrogate case 18: self = .mathSymbol
case __swift_stdlib_U_DASH_PUNCTUATION: self = .dashPunctuation case 19: self = .currencySymbol
case __swift_stdlib_U_START_PUNCTUATION: self = .openPunctuation case 20: self = .modifierSymbol
case __swift_stdlib_U_END_PUNCTUATION: self = .closePunctuation case 21: self = .otherSymbol
case __swift_stdlib_U_CONNECTOR_PUNCTUATION: self = .connectorPunctuation case 22: self = .spaceSeparator
case __swift_stdlib_U_OTHER_PUNCTUATION: self = .otherPunctuation case 23: self = .lineSeparator
case __swift_stdlib_U_MATH_SYMBOL: self = .mathSymbol case 24: self = .paragraphSeparator
case __swift_stdlib_U_CURRENCY_SYMBOL: self = .currencySymbol case 25: self = .control
case __swift_stdlib_U_MODIFIER_SYMBOL: self = .modifierSymbol case 26: self = .format
case __swift_stdlib_U_OTHER_SYMBOL: self = .otherSymbol case 27: self = .surrogate
case __swift_stdlib_U_INITIAL_PUNCTUATION: self = .initialPunctuation case 28: self = .privateUse
case __swift_stdlib_U_FINAL_PUNCTUATION: self = .finalPunctuation case 29: self = .unassigned
default: fatalError("Unknown general category \(rawValue)") default: fatalError("Unknown general category \(rawValue)")
} }
} }
@@ -1173,42 +1148,86 @@ extension Unicode.Scalar.Properties {
/// This property corresponds to the "General_Category" property in the /// This property corresponds to the "General_Category" property in the
/// [Unicode Standard](http://www.unicode.org/versions/latest/). /// [Unicode Standard](http://www.unicode.org/versions/latest/).
public var generalCategory: Unicode.GeneralCategory { public var generalCategory: Unicode.GeneralCategory {
let rawValue = __swift_stdlib_UCharCategory( let rawValue = _swift_stdlib_getGeneralCategory(_scalar.value)
__swift_stdlib_UCharCategory.RawValue(
__swift_stdlib_u_getIntPropertyValue(
icuValue, __swift_stdlib_UCHAR_GENERAL_CATEGORY)))
return Unicode.GeneralCategory(rawValue: rawValue) return Unicode.GeneralCategory(rawValue: rawValue)
} }
} }
extension Unicode.Scalar.Properties { 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( let hangulLTable = ["G", "GG", "N", "D", "DD", "R", "M", "B", "BB", "S",
_ choice: __swift_stdlib_UCharNameChoice "SS", "", "J", "JJ", "C", "K", "T", "P", "H"]
) -> 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 }
// ICU writes a trailing null, so we have to save room for it as well. let hangulVTable = ["A", "AE", "YA", "YAE", "EO", "E", "YEO", "YE", "O",
let array = Array<UInt8>(unsafeUninitializedCapacity: count + 1) { "WA", "WAE", "OE", "YO", "U", "WEO", "WE", "WI", "YU",
buffer, initializedCount in "EU", "YI", "I"]
var error = __swift_stdlib_U_ZERO_ERROR
let correctSize = __swift_stdlib_u_charName( let hangulTTable = ["", "G", "GG", "GS", "N", "NJ", "NH", "D", "L", "LG",
icuValue, "LM", "LB", "LS", "LT", "LP", "LH", "M", "B", "BS", "S",
choice, "SS", "NG", "J", "C", "K", "T", "P", "H"]
UnsafeMutableRawPointer(buffer.baseAddress._unsafelyUnwrappedUnchecked)
.assumingMemoryBound(to: Int8.self), let sIdx = _scalar.value &- S.base
Int32(buffer.count), let lIdx = Int(sIdx / N.count)
&error) let vIdx = Int((sIdx % N.count) / T.count)
guard error.isSuccess else { let tIdx = Int(sIdx % T.count)
fatalError("Unexpected error case-converting Unicode scalar.")
} let scalarName = hangulLTable[lIdx] + hangulVTable[vIdx] + hangulTTable[tIdx]
_internalInvariant(count == correctSize, "inconsistent ICU behavior") return "HANGUL SYLLABLE \(scalarName)"
initializedCount = count + 1 }
}
return array.withUnsafeBufferPointer { buffer in // Used to potentially return a name who can either be represented in a large
String._fromASCII(UnsafeBufferPointer(rebasing: buffer[..<count])) // 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 /// This property corresponds to the "Name" property in the
/// [Unicode Standard](http://www.unicode.org/versions/latest/). /// [Unicode Standard](http://www.unicode.org/versions/latest/).
public var name: String? { 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. /// 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 /// This property corresponds to the "Name_Alias" property in the
/// [Unicode Standard](http://www.unicode.org/versions/latest/). /// [Unicode Standard](http://www.unicode.org/versions/latest/).
public var nameAlias: String? { 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 /// This property corresponds to the "Canonical_Combining_Class" property in
/// the [Unicode Standard](http://www.unicode.org/versions/latest/). /// the [Unicode Standard](http://www.unicode.org/versions/latest/).
public var canonicalCombiningClass: Unicode.CanonicalCombiningClass { public var canonicalCombiningClass: Unicode.CanonicalCombiningClass {
let normData = _swift_stdlib_getNormData(_scalar.value) let normData = Unicode._NormData(_scalar)
let rawValue = UInt8(normData >> 3) return Unicode.CanonicalCombiningClass(rawValue: normData.ccc)
return Unicode.CanonicalCombiningClass(rawValue: rawValue)
} }
} }
@@ -1438,13 +1475,16 @@ extension Unicode {
/// and programs can treat `digit` and `numeric` equivalently. /// and programs can treat `digit` and `numeric` equivalently.
case numeric case numeric
internal init?(rawValue: __swift_stdlib_UNumericType) { internal init(rawValue: UInt8) {
switch rawValue { switch rawValue {
case __swift_stdlib_U_NT_NONE: return nil case 0:
case __swift_stdlib_U_NT_DECIMAL: self = .decimal self = .numeric
case __swift_stdlib_U_NT_DIGIT: self = .digit case 1:
case __swift_stdlib_U_NT_NUMERIC: self = .numeric self = .digit
default: fatalError("Unknown numeric type \(rawValue)") 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 /// This property corresponds to the "Numeric_Type" property in the
/// [Unicode Standard](http://www.unicode.org/versions/latest/). /// [Unicode Standard](http://www.unicode.org/versions/latest/).
public var numericType: Unicode.NumericType? { public var numericType: Unicode.NumericType? {
let rawValue = __swift_stdlib_UNumericType( let rawValue = _swift_stdlib_getNumericType(_scalar.value)
__swift_stdlib_UNumericType.RawValue(
__swift_stdlib_u_getIntPropertyValue( guard rawValue != .max else {
icuValue, __swift_stdlib_UCHAR_NUMERIC_TYPE))) return nil
}
return Unicode.NumericType(rawValue: rawValue) return Unicode.NumericType(rawValue: rawValue)
} }
@@ -1494,8 +1536,10 @@ extension Unicode.Scalar.Properties {
/// This property corresponds to the "Numeric_Value" property in the [Unicode /// This property corresponds to the "Numeric_Value" property in the [Unicode
/// Standard](http://www.unicode.org/versions/latest/). /// Standard](http://www.unicode.org/versions/latest/).
public var numericValue: Double? { public var numericValue: Double? {
let icuNoNumericValue: Double = -123456789 guard numericType != nil else {
let result = __swift_stdlib_u_getNumericValue(icuValue) return nil
return result != icuNoNumericValue ? result : nil }
return _swift_stdlib_getNumericValue(_scalar.value)
} }
} }

56
stdlib/public/stubs/UnicodeData.cpp
View File

@@ -11,6 +11,7 @@
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "../SwiftShims/UnicodeData.h" #include "../SwiftShims/UnicodeData.h"
#include <limits>
// Every 4 byte chunks of data that we need to hash (in this case only ever // 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 // 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 // This implementation is based on the minimal perfect hashing strategy found
// here: https://arxiv.org/pdf/1702.03154.pdf // 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 _swift_stdlib_getMphIdx(__swift_uint32_t scalar,
__swift_intptr_t levels, __swift_intptr_t levels,
const __swift_uint64_t * const *keys, const __swift_uint64_t * const *keys,
@@ -102,3 +102,57 @@ __swift_intptr_t _swift_stdlib_getMphIdx(__swift_uint32_t scalar,
return resultIdx; 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;
}

62
stdlib/public/stubs/UnicodeNormalization.cpp
View File

@@ -350,60 +350,18 @@ __swift_uint16_t _swift_stdlib_getNormData(__swift_uint32_t scalar) {
if (scalar < 0xC0) { if (scalar < 0xC0) {
return 0; return 0;
} }
auto chunkSize = 0x110000 / 64 / 64; auto dataIdx = _swift_stdlib_getScalarBitArrayIdx(scalar,
auto base = scalar / chunkSize; _swift_stdlib_normData,
auto idx = base / 64; _swift_stdlib_normData_ranks);
auto chunkBit = base % 64;
// If we don't have an index into the data indices, then this scalar has no
auto quickLookSize = _swift_stdlib_normData[0]; // normalization information.
if (dataIdx == std::numeric_limits<__swift_intptr_t>::max()) {
// 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 0; return 0;
} }
auto quickLook = _swift_stdlib_normData[idx + 1]; auto scalarDataIdx = _swift_stdlib_normData_data_indices[dataIdx];
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
];
return _swift_stdlib_normData_data[scalarDataIdx]; return _swift_stdlib_normData_data[scalarDataIdx];
} }

911
stdlib/public/stubs/UnicodeScalarProps.cpp
View File

@@ -10,613 +10,9 @@
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// This was auto-generated by utils/gen-unicode-data/GenScalarProps, #include "UnicodeScalarProps.h"
// please do not edit this file yourself!
#include "../SwiftShims/UnicodeData.h" #include "../SwiftShims/UnicodeData.h"
#include <limits>
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,
};
SWIFT_RUNTIME_STDLIB_INTERNAL SWIFT_RUNTIME_STDLIB_INTERNAL
__swift_uint64_t _swift_stdlib_getBinaryProperties(__swift_uint32_t scalar) { __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 to indicate no properties.
return 0; 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();
}

24681
stdlib/public/stubs/UnicodeScalarProps.h Normal file
View File

File diff suppressed because it is too large Load Diff

128
stdlib/public/stubs/UnicodeShims.cpp
View File

@@ -34,18 +34,6 @@ typedef __swift_stdlib_UProperty UProperty;
#define U_MAX_VERSION_LENGTH 4 #define U_MAX_VERSION_LENGTH 4
typedef uint8_t UVersionInfo[U_MAX_VERSION_LENGTH]; 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 #else
@@ -66,122 +54,6 @@ double u_getNumericValue(UChar32);
#endif #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 // Force an autolink with ICU
#if defined(__MACH__) #if defined(__MACH__)
asm(".linker_option \"-licucore\"\n"); asm(".linker_option \"-licucore\"\n");

1952
utils/gen-unicode-data/Data/DerivedAge.txt Normal file
View File

File diff suppressed because it is too large Load Diff

4192
utils/gen-unicode-data/Data/DerivedGeneralCategory.txt Normal file
View File

File diff suppressed because it is too large Load Diff

43878
utils/gen-unicode-data/Data/DerivedName.txt Normal file
View File

File diff suppressed because it is too large Load Diff

278
utils/gen-unicode-data/Data/DerivedNumericType.txt Normal file
View File

@@ -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

2574
utils/gen-unicode-data/Data/DerivedNumericValues.txt Normal file
View File

File diff suppressed because it is too large Load Diff

567
utils/gen-unicode-data/Data/NameAliases.txt Normal file
View File

@@ -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

280
utils/gen-unicode-data/Data/SpecialCasing.txt Normal file
View File

@@ -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

97
utils/gen-unicode-data/Sources/GenScalarProps/Age.swift Normal file
View File

@@ -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)
}

182
utils/gen-unicode-data/Sources/GenScalarProps/GeneralCategory.swift Normal file
View File

@@ -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)
}

480
utils/gen-unicode-data/Sources/GenScalarProps/Mappings.swift Normal file
View File

@@ -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)
}

192
utils/gen-unicode-data/Sources/GenScalarProps/NameAlias.swift Normal file
View File

@@ -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)
}

259
utils/gen-unicode-data/Sources/GenScalarProps/Names.swift Normal file
View File

@@ -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)
}

182
utils/gen-unicode-data/Sources/GenScalarProps/Numeric.swift Normal file
View File

@@ -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
)
}

6
utils/gen-unicode-data/Sources/GenScalarProps/main.swift
View File

@@ -16,6 +16,12 @@ func generateScalarProps() {
var result = readFile("Input/UnicodeScalarProps.cpp") var result = readFile("Input/UnicodeScalarProps.cpp")
generateBinaryProps(into: &result) 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") write(result, to: "../../stdlib/public/stubs/UnicodeScalarProps.cpp")
} }