rust д#rustc 1.81.0 (eeb90cda1 2024-09-04)СЦ’–п§2ёvƒKАЄсfwп-d8cea91d43634f65СŒƒгњыХПYЭiФ1К-b1f27438890f45b3Сrustc_std_workspace_coreСшАМŽn&,М5w’tEиCМ-a22427de72ab3630С„Ц is_xid_startСis_xid_continueСtablesС … FС Align8С …щ Align64С …щ  ASCII_STARTС  ASCII_CONTINUEС  CHUNKС  TRIE_STARTС   TRIE_CONTINUEС  LEAFС! $ѕ Ќх$ю"trueС,‹ Дћ$„"falseСФ €)Ј4;128Сœ €Ј)Ј4;128Су  @ЈќУ #Ј,л $64С’  ’Ј)Ј4;402С$Љ Ј )Ј4;1793С$Џw рЈ")Ј4;7904СмЈ …'Тщ ЧЋ‹ЄЬЎй„ ^„ elx „ ŽšЄ Ѕ„ ЌГфщ „ $сщ тšЯсђБгБH„ [„ biu „ ‹—р Ђ„ ЉА Ц—tЛ\\Ы\А,и\ щ$п\!бlх\ МTє\ ќГbЃ [![github]](https://github.com/dtolnay/unicode-ident) [![crates-io]](https://crates.io/crates/unicode-ident) [![docs-rs]](https://docs.rs/unicode-ident)СќІЇg [github]: https://img.shields.io/badge/github-8da0cb?style=for-the-badge&labelColor=555555&logo=githubСќЋjk [crates-io]: https://img.shields.io/badge/crates.io-fc8d62?style=for-the-badge&labelColor=555555&logo=rustСќ–nj [docs-rs]: https://img.shields.io/badge/docs.rs-66c2a5?style=for-the-badge&labelColor=555555&logo=docs.rsСќ…mѓ
СDї€K Implementation of [Unicode Standard Annex #31][tr31] for determining whichСќ„N= `char` values are valid in programming language identifiers.Сќг@”. [tr31]: https://www.unicode.org/reports/tr31/Сќ˜1ЪK This crate is a better optimized implementation of the older `unicode-xid`СќЮNI crate. This crate uses less static storage, and is able to classify bothСќLJ ASCII and non-ASCII codepoints with better performance, 2–10×СќъM faster than `unicode-xid`.СєИзБDлф ## Comparison of performanceСќш ‰G The following table shows a comparison between five Unicode identifierСќJ implementations.СЄиэ! - `unicode-ident` is this crate;Сќё$F - [`unicode-xid`] is a widely used crate run by the "unicode-rs" org;Сќ– I@ - `ucd-trie` and `fst` are two data structures supported by theСќр C [`ucd-generate`] tool;СфЄ : - [`roaring`] is a Rust implementation of Roaring bitmap.СќС =џ M The *static storage* column shows the total size of `static` tables that theСќƒ P: crate bakes into your binary, measured in 1000s of bytes.Сќд =’ G The remaining columns show the **cost per call** to evaluate whether aСќ– JD single `char` has the XID\_Start or XID\_Continue Unicode property,Сќс GJ comparing across different ratios of ASCII to non-ASCII codepoints in theСќЉ M input data.С|ї ‡; [`unicode-xid`]: https://github.com/unicode-rs/unicode-xidСќ‹>= [`ucd-generate`]: https://github.com/BurntSushi/ucd-generateСќЪ@9 [`roaring`]: https://github.com/RoaringBitmap/roaring-rsСќ‹<Ш> | | static storage | 0% nonascii | 1% | 10% | 100% nonascii |СќЬA |---|---|---|---|---|---|СьŽI | **`unicode-ident`** | 10.4 K | 0.96 ns | 0.95 ns | 1.09 ns | 1.55 ns |СќЌLH | **`unicode-xid`** | 11.8 K | 1.88 ns | 2.14 ns | 3.48 ns | 15.63 ns |СќљKD | **`ucd-trie`** | 10.3 K | 1.29 ns | 1.28 ns | 1.36 ns | 2.15 ns |СќХG> | **`fst`** | 144 K | 55.1 ns | 54.9 ns | 53.2 ns | 28.5 ns |СќAC | **`roaring`** | 66.1 K | 2.78 ns | 3.09 ns | 3.37 ns | 4.70 ns |СќЯF–K Source code for the benchmark is provided in the *bench* directory of thisСќšN7 repo and may be repeated by running `cargo criterion`.Сќщ:ЄБDЈБ! ## Comparison of data structuresСќЕ$к #### unicode-xidСЄоѓL They use a sorted array of character ranges, and do a binary search to lookСќїO? up whether a given character lands inside one of those ranges.СќЧBŠ ```rustС\Ž # const _: &str = stringify! {Сќš"3 static XID_Continue_table: [(char, char); 763] = [СќН6" ('\u{30}', '\u{39}'), // 0-9Сќє%" ('\u{41}', '\u{5a}'), // A-ZСќš% # "С<Р т€ІС\Ші'<д ('\u{e0100}', '\u{e01ef}'),Сќм# ];С4€ # };СD‡ ```С<˜I The static storage used by this data structure scales with the number ofСќœLI contiguous ranges of identifier codepoints in Unicode. Every table entryСќщLI consumes 8 bytes, because it consists of a pair of 32-bit `char` values.СќЖLƒF In some ranges of the Unicode codepoint space, this is quite a sparseСќ‡IH representation – there are some ranges where tens of thousands ofСќбKJ adjacent codepoints are all valid identifier characters. In other places,СќMI the representation is quite inefficient. A characater like `ТЕ` (U+00B5)СќыLI which is surrounded by non-identifier codepoints consumes 64 bits in theСќИL7 table, while it would be just 1 bit in a dense bitmap.Сќ…:РK On a system with 64-byte cache lines, binary searching the table touches 7СќФNC cache lines on average. Each cache line fits only 8 table entries.Сќ“FK Additionally, the branching performed during the binary search is probablyСќкN. mostly unpredictable to the branch predictor.СќЉ1лK Overall, the crate ends up being about 10× slower on non-ASCII inputСќпN compared to the fastest crate.СќЎ "б K A potential improvement would be to pack the table entries more compactly.Сќе NL Rust's `char` type is a 21-bit integer padded to 32 bits, which means everyСќЄ!OI table entry is holding 22 bits of wasted space, adding up to 3.9 K. TheyСќє!LJ could instead fit every table entry into 6 bytes, leaving out some of theСќС"MM padding, for a 25% improvement in space used. With some cleverness it may beСќ#PH possible to fit in 5 bytes or even 4 bytes by storing a low char and anСќр#KK extent, instead of low char and high char. I don't expect that performanceСќЌ$NM would improve much but this could be the most efficient for space across allСќћ$P0 the libraries, needing only about 7 K to store.СќЬ%3€& #### ucd-trieСŒ„&–&H Their data structure is a compressed trie set specifically tailored forСќš&K= Unicode codepoints. The design is credited to Raph Levien inСќц&@ [rust-lang/rust#33098].СмЇ'У'E [rust-lang/rust#33098]: https://github.com/rust-lang/rust/pull/33098СќЧ'H(Ђ&\”( pub struct TrieSet {СФ (& tree1_level1: &'static [u64; 32],СќЙ()& tree2_level1: &'static [u8; 992],Сќу()" tree2_level2: &'static [u64],Сќ)%& tree3_level1: &'static [u8; 256],СќГ))! tree3_level2: &'static [u8],Сќн)$" tree3_level3: &'static [u64],Сќ‚*% }С,Ј*ч(<Ў*Ж*M It represents codepoint sets using a trie to achieve prefix compression. TheСќК*PH final states of the trie are embedded in leaves or "chunks", where eachСќ‹+KK chunk is a 64-bit integer. Each bit position of the integer corresponds toСќз+NJ whether a particular codepoint is in the set or not. These chunks are notСќІ,ML just a compact representation of the final states of the trie, but are alsoСќє,OF a form of suffix compression. In particular, if multiple ranges of 64СќФ-IM contiguous codepoints have the same Unicode properties, then they all map toСќŽ.P/ the same chunk in the final level of the trie.Сќп.2’/K Being tailored for Unicode codepoints, this trie is partitioned into threeСќ–/NL disjoint sets: tree1, tree2, tree3. The first set corresponds to codepointsСќх/OC \[0, 0x800), the second \[0x800, 0x10000) and the third \[0x10000,СќЕ0FK 0x110000). These partitions conveniently correspond to the space of 1 or 2Сќќ0NJ byte UTF-8 encoded codepoints, 3 byte UTF-8 encoded codepoints and 4 byteСќЫ1M( UTF-8 encoded codepoints, respectively.Сќ™2+Х2L Lookups in this data structure are significantly more efficient than binaryСќЩ2OM search. A lookup touches either 1, 2, or 3 cache lines based on which of theСќ™3P# trie partitions is being accessed.Сќъ3&‘4M One possible performance improvement would be for this crate to expose a wayСќ•4PI to query based on a UTF-8 encoded string, returning the Unicode propertyСќц4LM corresponding to the first character in the string. Without such an API, theСќГ5PK caller is required to tokenize their UTF-8 encoded input data into `char`,Сќ„6NJ hand the `char` into `ucd-trie`, only for `ucd-trie` to undo that work byСќг6ML converting back into the variable-length representation for trie traversal.СќЁ7Oё7 #### fstСdѕ7‚8I Uses a [finite state transducer][fst]. This representation is built intoСќ†8LG [ucd-generate] but I am not aware of any advantage over the `ucd-trie`Сќг8JJ representation. In particular `ucd-trie` is optimized for storing UnicodeСќž9M properties while `fst` is not.Сќь9":) [fst]: https://github.com/BurntSushi/fstСќ“:,; [ucd-generate]: https://github.com/BurntSushi/ucd-generateСќР:>џ:J As far as I can tell, the main thing that causes `fst` to have large sizeСќƒ;MJ and slow lookups for this use case relative to `ucd-trie` is that it doesСќб;MH not specialize for the fact that only 21 of the 32 bits in a `char` areСќŸDˆ?3 [Roaring Bitmap]: https://roaringbitmap.org/about/СќŒ?6У?M Roaring bitmaps are compressed bitmaps which tend to outperform conventionalСќЧ?PM compressed bitmaps such as WAH, EWAH or Concise. In some instances, they canСќ˜@PF be hundreds of times faster and they often offer significantly betterСќщ@I compression.С„ГAФAF In this use case the performance was reasonably competitive but stillСќШAIF substantially slower than the Unicode-optimized crates. Meanwhile theСќ’BIL compression was significantly worse, requiring 6× as much storage forСќмBO the data structure.СМЌCФCM I also benchmarked the [`croaring`] crate which is an FFI wrapper around theСќШCPJ C reference implementation of Roaring Bitmap. This crate was consistentlyСќ™DMM about 15% slower than pure-Rust `roaring`, which could just be FFI overhead.СќчDP I did not investigate further.СќИE"лE0 [`croaring`]: https://crates.io/crates/croaringСќпE3“F #### unicode-identСД—FЎFL This crate is most similar to the `ucd-trie` library, in that it's based onСќВFOL bitmaps stored in the leafs of a trie representation, achieving both prefixСќ‚GO$ compression and suffix compression.СќвG'њG The key differences are:СфўG›HM - Uses a single 2-level trie, rather than 3 disjoint partitions of differentСќŸHP depth each.СŒ№HB - Uses significantly larger chunks: 512 bits rather than 64 bits.Сќ‚IEB - Compresses the XID\_Start and XID\_Continue properties togetherСќШIEL simultaneously, rather than duplicating identical trie leaf chunks acrossСќŽJO the two.СtоJэJL The following diagram show the XID\_Start and XID\_Continue Unicode booleanСќёJO5 properties in uncompressed form, in row-major order:СќСK8њK С\ўK1 СќŠL4 СDПL СќШL   СќщMЃ СLO
XID_StartXID_Continue
XID_Start bitmapXID_Continue bitmap
Сd—OЄOM Uncompressed, these would take 140 K to store, which is beyond what would beСќЈOPJ reasonable. However, as you can see there is a large degree of similarityСќљOMA between the two bitmaps and across the rows, which lends well toСќЧPDœW„ŒQQK This crate stores one 512-bit "row" of the above bitmaps in the leaf levelСќЁQNK of a trie, and a single additional level to index into the leafs. It turnsСќ№QNM out there are 124 unique 512-bit chunks across the two bitmaps so 7 bits areСќПRP sufficient to index them.СьSЎSL The chunk size of 512 bits is selected as the size that minimizes the totalСќВSOI size of the data structure. A smaller chunk, like 256 or 128 bits, wouldСќ‚TLH achieve better deduplication but require a larger index. A larger chunkСќЯTKF would increase redundancy in the leaf bitmaps. 512 bit chunks are theСќ›UI7 optimum for total size of the index plus leaf bitmaps.СќхU: VJ In fact since there are only 124 unique chunks, we can use an 8-bit indexСќЄVMD with a spare bit to index at the half-chunk level. This achieves anСќђVGK additional 8.5% compression by eliminating redundancies between the secondСќКWNK half of any chunk and the first half of any other chunk. Note that this isСќ‰XNJ not the same as using chunks which are half the size, because it does notСќиXM8 necessitate raising the size of the trie's first level.СќІY;тYL In contrast to binary search or the `ucd-trie` crate, performing lookups inСќцYOF this data structure is straight-line code with no need for branching.СќЖZI[Ѓ ’[ Щ[ Œl“[ Ё[$https://docs.rs/unicode-ident/1.0.13СќЃ[&ќŒ[? Цєє—(А= щO!бd Мy єєєєєќЋ\T((==OOddyyќ‚]%d‰] chС–]ќз_(|о_ чvю_Tš\l‹\й <‹\оТ $”\\4ž\!lх ы lћ  u4К…Хб„ СЄ ЧЋ‹ЄЬЎй„ Є uU„ Є  „ ^`dФ„ 4<ћ…­y ƒр тšЯсђБгБH„ р 4L„ р  „ ^`d†„ ќ–3\Јсщ тšЯсђБгБHЈ€€€Јќы6t§‹|€€пЈьУ ,д Јќш /Tњ Тщ ЧЋ‹ЄЬЎйЈ’˜ #'-148<@EIMQTX\ `dfjnr(vx|€„ˆŒ”˜œ +ЄІЈ2ЎЏГЗЛCПСRУЦвдЪлпуЭчыэЉ№ѓЌѕАюёџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџ˜ƒЈќќ3lŽТщ ЧЋ‹ЄЬЎйЈˆ !%*/16:>BGKOQVZ^ bdhlpt(vz~‚†ŠŽ’–šžЂ+ЄІЋ2ЎБЕЙНCПСRУЩЬФЧЯвжиЪнсхЭщыаэЉ№ѓЌѕАюёйџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџˆгЈќŠw+$œwсщ тšЯсђБгБHЈр€>џџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџ??џџџџ??џЊџџџ?џџџџџџп_мЯџм џџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџ џџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџјџџџџџџџџџџџџџџџџџџџџџџџџџџџџџУџPпИ@зџџћџџџџџџџџџПџџџџџџџџџџџџџџџџџџџџџџџџџУџPџџџџџџџџџџџџџџпИРзџџћџџџџџџџџџПџџџџџџџџџџџџџџџџџќџџџџџџџџџџџџџџџџџџџџўџџџџџџџџџџџ‡џџџџџџџџџџџџџџџџћќџџџџџџџџџџџџџџџџџџџџўџџџџџџџџўџџџџПЖџџџ‡џџџџџРўџџџџџџџџџџџ/`Рœ§џџџрџџџџџџџџџџ?ќџџџ0џџџџџџџџџџУџџџџџџџџџџџџяŸџ§џŸџџџџџџџчџџџџџџџџџџџџџџџџџџ?$џџ?џџџџџџџ~џџџџџ№џџџџџџ#џўџсŸљџџ§Х#@Аџџџџџ?џџџџџџџ~€џџџџџџџџџћџџџџџџџџџџџџџџџЯџўџяŸљџџ§ХѓŸy€АЯџPр‡љџџ§m^рПћџџ§э#рŸљџџ§э#АшЧ=жЧџю‡љџџ§mг‡9^Рџ?юПћџџ§эѓП;ЯџўюŸљџџ§эѓŸ9рАЯџьЧ=жЧџУЧ=Рџрп§џџ§џ#'сп§џџ§я#`№п§џџџџ'@p€ќрџќџџћ/џп§џџ§џѓп=`'Яџяп§џџ§яѓп=``Яџџп§џџџџџп}№€Яџќюџќџџћ/„_џРџ ўџџџџџжїџџЏџ _№џўџџџўџџџџџџџџжїџџЏџџ?_џѓџ Тџўџџџўџпџџўџџџ@џџџџџ€?ўџџџџџџџџџрўџџџџџџџџџџїрџџџџџўџџџџџџџџџџџџџџџџрўџ>ўџџџџџџџџџцўџџџџџџџџџџџрџџџџџўџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџ?џџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџ'№џџџџџџџџџџџџџџџџџџџџџ џџџџџ€џџџ?џџџџџџџџџџ€џќџџџџџџџџџџџџљџџџџџџџ?ыќџџџџџџџџџџџ№Пџџџџџџџџџџџџџџ€џќџџџџџџџџџџџџљџџџџџџџ?ыќџЛїџџџџџџџџќџџџџџќhќџџ?џџџџџ№џџџџџ€пџ|џџџџџџџџџџџџџџџџџџџ?џџџџшџџџџџ?џџџџџџџџџџџџџџџ€џџџџџџџџџїџџФџџџџџџb>8џ~~~џџџџџїџџџџџџџџџџџџџџџџџџџџџџ?џџџќџџџџџџџџ8џџ|~~~џџџџџїџџџџџџџџџџџџџџџџ7џџџџџџџџџџџџџџ?џџџџџџџџџџџџџј џ§_лџџџџџџџџџџџџџјџџџџџџџџџџџџџџџџџџ?џџџџџџџџџџџџџјрџ§_лџџџџџџџџџџџџџјџџџџџџџџџџџџџџџџ?№џџџџџџџџџџџџџџџџџџџџџџџџџџ?џџџџџџџџќџџџџџџџŠЊџџџџџџџџџџџџџџџўџџўџџРџџџџџџ?џџџќќќџџџџрŠЊџџџџџџџџџџџџџџџџўџџ‡ўџџрџџџџџџџџџџќќќџяџџџџЗџ?џ?џџџџџџџџџџџџџџџџџџџџџџяџџџџЗџ?џ?џџџџџџџџџџџџџџџџџџџџџ џџџџџџџџџџџџџрџџџџџџџ?џџџ?џџџџџ>џџџџџџџџџџџџџрџџџџџџџџџџџ?џџџџџ>џџџџџџџџџџџџџџџџџџџ?џџџџџџџџџџџџџџџџџџџџїџїЗџћџћџџџџџџџџџџџџџџџџџџџџџџџџџ?џџџџџџџџџџџџџџџџџџџџџїџїЗџћџћџџџџџџ?§џџџџП‘џџ?џџџџџџџ7џџ?џџџџџџџџџџРяўџџ?џџџџџџџўџџџџџџџџ?џџ?џџџџo№яўџџ?‡џџџџџџџўџџџџџџџџ?џџ?џџџџџџџџџџџџџџџџџџџџџџџџџџџџџќџџ?€џџ?џџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџ?Оџџ?џџџџџџџџ€џџ?џџџџџџџџџџџ№џџџ€џџџџџџ?џџџџјџџџџџџ&јџџџџџџџџјџџџџџџџGјџџџџџџџџџџџџџРџ?€џџџџџџџџџџџџџџџџџпџ№џџџџOџџџџџџџџоџџџћџџ€НџПџџџџџџрŸљџџ§э#рџKџџџџП џџћџџџџРНџПџџџџџџџџџяŸљџџ§эћŸ9рЯџKџџџџПџЅїџџџџџџ€€џџџџџџАџџџџџџџџџџџџџџџУџџџџџџџџПџџџџџџџ?џ?џџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџчџџџџџџџџџџџџџџџ€ђoџџџ€џќџџџџ џџџџџџџџџџџџџџџџ€ђoџџџПљџџќџџџџџќјџџџџ№џџџџџ џџџџџџџџџџџџџџџџџџџџ€џџџџџџџџџ#џџџџџџџџџџџџџџџ§џџџќџџџћџџџџ@П§џџџџ§џџџџџџќџџџќџџўћџџџџДџџП§џџџћџџџєџ§џџџџџџџ§џџџџЧџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџ~џџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџ?џџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџ?џџџџџџџџџџџџџџџџџџџџџџџџџџџџџ?џџџџџџјџџрџџџџџџџџџџџџџџџџџџџџџџџџџџ?џџџџџџџјџџрџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџјџ џџџџџџџџџџџџџџџџџ‡џџџџџџџ€џџџџџџџџџџџџџџџџџџџџџџџџџџџџ?€џяoџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџ?џџџџџџџџџџџџџџџџџџрујч<џџџџџџџџџџџџџџџџcџџџрџoџџџџџџџџџџџџпџџџџџџџџпdоџыяџџџџџџџПчппџџџ{_ќ§џџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџ?џџџ§џџїџџџїџџпџџџпџџџџџџџџ§џџџ§џџїџџџџџџџџџџџџџџџџџџџџ?џџџ§џџїџџџїџџпџџџпџџџџџџџџ§џџџ§џџїЯџџџџџџџџџџџџјџџџџџ јўџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџ?џџџџџ€?@џџљлџџџџџџџ?€џџџџџџ?џCџџџ?џџџџџџџџџџџџџџџџџџџџџ?џџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџяџџџ–ўї „ъ–Њ–її^џћџюћџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџ?џџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџ?}џџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџ€>$ЈB!https://crates.io/crates/croaringС unicode-xidСcroaringС ucd-generateСgithubСUnicode Standard Annex #31Сhttps://docs.rs/unicode-identС%https://www.unicode.org/reports/tr31/С&https://crates.io/crates/unicode-identС)https://github.com/unicode-rs/unicode-xidС https://roaringbitmap.org/about/СФк crates-ioСъкrust-lang/rust#33098Сњк‡лfinite state transducerСЃлRoaring BitmapС(https://github.com/dtolnay/unicode-identСфл+https://github.com/RoaringBitmap/roaring-rsСчмФк’нІн˜лЃлroaringСэн*https://github.com/BurntSushi/ucd-generateС€о!https://github.com/BurntSushi/fstСГоІнњкdocs-rsС˜л‡пТл€офлЮпЙм,https://github.com/rust-lang/rust/pull/33098С†рЫн‡пэнТл™пЮпŽмЙмМр’нък†р‡лЫн™пГоŽмчмМрwщ›ИсM#ЇŽсђ1 фЈщ4‹‚€,(’тюБWГтЕЖА­ЪЏ–€юМ)TіуАЫQ&ЮŒЄВ;!ђ*Й|ж3ТЋkВ$)'ЊŸг4n<Мa—Eж}ЫОh9…tћ˜ї!bШ*ШcќМ№WчŸ"H0Ш‹Fн №I п%šІ‚Й}Ц%ЪJПJN-Т.0oƒВзPХHъ<лє&ЈЧ93ё%4PC Чд~deWћќѓ(ЩзйЦH*.Ђэємў9!j+GŽГЕNM'ъ < &ЫЙ,ФЕ4Œ’dl0ГрвПW&ђ іЂpž4DЎvp™г,­@їњ&(С!ТЌ‰X Y;q5Ј!„+СDg:ѓ=;t;Ј;ф;љ; <Љ<Р<S=l=c> ?7?AчId:д ;W<=  % %  c:P;‡;в;ш;§;$?J?’AњI‹§:;; ;;; ;&;,;2;8;o;Є;р;ѕ; ^> ??2?kAzAгIтI3m;; ;;;;#;);/;5;=;t;Ю;ф;љ; ?7?AчI_;–;ё;<*<Š<Ё<Ж<н<4=K=`=ˆ=Y>>?-?S?uA›AнIJ=mX;;ъ;џ;<<š<­<Щ<+=D=W==R>x>?&?L?nA”AжIќI6mb;™;є; <=<<Л<ч<9=e=‹=\>‚>?0?V?xAžAрIJ@mQ;ˆ;;?ƒAыIЄ<N=s2є@ыЇн-б"ъІ?Œ1эм,€а!r5г#xЧh9…з'|Ыlf;;Ц=„>’?кABJa:Ь; <Р<M<ї<?<щ<ЩЬазнсхщэёѕљ "/6>KOV]kov}“ЈЌИЩЭсх№P<њQ>KHN?A=BMLHBGO; %PC #7&& $ MMMJLNMM;OGO2O#OPMNQLOQ4LAI **&*%&QLONPJQ3OPGON,PQ'QMQONP MKN#-?NNLO'IE7QQJJJPQNQ#4PP(QFFPP9 5 ЁЄ QNEOOQPMLJ;NHOON<PJ @< Z(+JGQ+.MGQаЋS‡в§7зЏкђЃ№}П…Ю|€aarch64-apple-darwinСюК›M~rЏDЇ3ЖЋ)і unicode_identС-3cb01d1e297c2d6eСТ7йГBБКЧŸƒ“œр#˜"f*#?"##D"FD##FF#FB",D.#,F,#F##FF  '"D**#*F*зєrust-end-file