📄 libutf8_ranges-156b7408ec74e8ed.rmeta
/home/palash/git/iron_learn/target/debug/deps/libutf8_ranges-156b7408ec74e8ed.rmeta
Language: rmeta • Lines: 812
rust
�#rustc 1.92.0 (ded5c06cf 2025-12-08)���	ⷄ�ۆ��p��-225863f279df55c4��١�	�T�6a��D�
-5080178c80bf7a93��uӰ]����d��!�-06039bcfba61f665��**�٭T��HО�9�-3e2e950d4bac10b5��	�t�#3Ҵη��Ǣ-d25e598578fbf080�rustc_std_workspace_core������Nm��gmY���-327ea4f353b4eb8c���y.:i���gy"1�r-94fdfaf0af91a65d�miniz_oxide�M�^�yTLm�L�d=B-5312b588e5cfab93�adler2��;~�7�ɴ,P?���-1e0b0d62df36c85c�	hashbrown�L�ϫ	2݆y��q-2ed6a8f06fc51a9d�rustc_std_workspace_alloc�a���p��H����6Z�-05b02707a5b2a256�
std_detect�	c�LN����=1�ʶӐ-5978f0713dd5442d�rustc_demangle�X�Fq��UՃ�>7z
��-43b2ff22c18e1125�cfg_if�֦<����ɐ¬�-6a40188dd7d989d2�	addr2line���,2�!xb�"6�!�	-11d54e777384a9e5�gimli��2��I.�ġ�����-35018e994bad7042�object��T �f��Y�
hQec-2dc10b344e05b569�memchr��xZT9�C��I�Mg�-09f2ab7e0d97e07a��~ݤ	����h���-932f22f820d1e5ec�
quickcheck�T��$�tests�,�o�$�o�MAX_UTF8_BYTES�	char_utf8�TAG_CONT�	TAG_TWO_B�TAG_THREE_B�
TAG_FOUR_B�	MAX_ONE_B�	MAX_TWO_B�MAX_THREE_B�encode_utf8�from_encoded_range�as_slice��	matches�'a�IntoIter�����
�
"�
Utf8Sequences�$range_stack�&�
&reset�&push�ScalarRange�*�*�-�/�/�114split�4is_valid�4as_ascii�4is_ascii�4�max_scalar_value�Utf8Sequence�;One�<
<�;Two�?
?�A;Three�C
C�E;Four�G
G�I	
L�MMMQ�RRR
W�	Utf8Range�Y�Y�\�`�b�8888888888!8#8#8#8(8)8.8.8.81858687888989898M8R8X8X8]8a8a8c8�;<=�>�?@�A�CD�
E�GH�
I��KǨ�W�{�����������H�
��_��YY�Z�[�_~l_a��������������_��_**�+�,��6
�)�u=�J$$�
%�
Q�s���QK;^YL;\YQ;bYV;_YW;`Y
;"Y-*/$�J�
�
��
�
�H
�_�J�
�� �,�$4�\�
��o$	�"0b1000_0000�\�
����$
��$0b1100_0000�\�
����$��$0b1110_0000�\�
����$��$0b1111_0000�$�
���"
��$0x80�,�
���"��$0x800�<�
���"��$0x10000��
�B+�6=2��
�F+�6=3��
�J+�6=4�(��M!&,28�D�NWacl��N����2�gp��O����3�kt��P����4��R�&�-6@����S���2�����T���3�����U��4�
H�		*8
H�W	dx������	����	�
���				 �*
	 8
p�!�!�
��7"�F"�
�%]iw|
��%�%���p�#�#�
��7$�F$�
�&]iw|
��&�'���p�%�%���7&�F&��']iw|
��'�(���H�'�'��)(�8
(��O[
in
���)����X������)�� (�*07��C�*K�*S�*[�*c�*k�)@�)H�)S�+[�(�(�(�+"�'��'��'��+��%��%��%��,��������'�/�7�?�G�O�W�_i�w__self_discr��__arg1_discr��__self_0��__arg1_0��
�,N�,Z�,
�,�,��,�"�%��'G�(��)(�3�3]!&�2�)9BLh�4��#4X�4��#4;CO�3aH�3
�)�)���������F�S]�3c�3��)$.t�^
�2$�/6:�MAX_UTF8_BYTES�t�^
�3$�/6:�MAX_UTF8_BYTES��
;=#�.�5<J
;_=k�v�}��
;@#�.�'5<J
;_@k�v�'}�,�
;D#�.�&5<J
;_Dk�v�&}�$�
;H#�.�%5<J
;_Hk�v�%}�$*:;Y��$��-���*�,��/�	\�������
Crate `utf8-ranges` converts ranges of Unicode scalar values to equivalent
ranges of UTF-8 bytes. This is useful for constructing byte based automatons
that need to embed UTF-8 decoding.

See the documentation on the `Utf8Sequences` iterator for more details and
an example.

# Wait, what is this?

This is simplest to explain with an example. Let's say you wanted to test
whether a particular byte sequence was a Cyrillic character. One possible
scalar value range is `[0400-04FF]`. The set of allowed bytes for this
range can be expressed as a sequence of byte ranges:

```ignore
[D0-D3][80-BF]
```

This is simple enough: simply encode the boundaries, `0400` encodes to
`D0 80` and `04FF` encodes to `D3 BF`, and create ranges from each
corresponding pair of bytes: `D0` to `D3` and `80` to `BF`.

However, what if you wanted to add the Cyrillic Supplementary characters to
your range? Your range might then become `[0400-052F]`. The same procedure
as above doesn't quite work because `052F` encodes to `D4 AF`. The byte ranges
you'd get from the previous transformation would be `[D0-D4][80-AF]`. However,
this isn't quite correct because this range doesn't capture many characters,
for example, `04FF` (because its last byte, `BF` isn't in the range `80-AF`).

Instead, you need multiple sequences of byte ranges:

```ignore
[D0-D3][80-BF]  # matches codepoints 0400-04FF
[D4][80-AF]     # matches codepoints 0500-052F
```

This gets even more complicated if you want bigger ranges, particularly if
they naively contain surrogate codepoints. For example, the sequence of byte
ranges for the basic multilingual plane (`[0000-FFFF]`) look like this:

```ignore
[0-7F]
[C2-DF][80-BF]
[E0][A0-BF][80-BF]
[E1-EC][80-BF][80-BF]
[ED][80-9F][80-BF]
[EE-EF][80-BF][80-BF]
```

Note that the byte ranges above will *not* match any erroneous encoding of
UTF-8, including encodings of surrogate codepoints.

And, of course, for all of Unicode (`[000000-10FFFF]`):

```ignore
[0-7F]
[C2-DF][80-BF]
[E0][A0-BF][80-BF]
[E1-EC][80-BF][80-BF]
[ED][80-9F][80-BF]
[EE-EF][80-BF][80-BF]
[F0][90-BF][80-BF][80-BF]
[F1-F3][80-BF][80-BF][80-BF]
[F4][80-8F][80-BF][80-BF]
```

This crate automates the process of creating these byte ranges from ranges of
Unicode scalar values.

# Why would I ever use this?

You probably won't ever need this. In 99% of cases, you just decode the byte
sequence into a Unicode scalar value and compare scalar values directly.
However, this explicit decoding step isn't always possible. For example, the
construction of some finite state machines may benefit from converting ranges
of scalar values into UTF-8 decoder automata (e.g., for character classes in
regular expressions).

# Lineage

I got the idea and general implementation strategy from Russ Cox in his
[article on regexps](https://swtch.com/~rsc/regexp/regexp3.html) and RE2.
Russ Cox got it from Ken Thompson's `grep` (no source, folk lore?).
I also got the idea from
[Lucene](https://github.com/apache/lucene-solr/blob/trunk/lucene/core/src/java/org/apache/lucene/util/automaton/UTF32ToUTF8.java),
which uses it for executing automata on their term index.
�$*:;Y�����-���*���/�	�L�
D��T�������t��l�L�	

�oDu���L����\����T����L����L����\����D\�dd
�����������������;t�����
	character�L�dst������� 7�� efe�Tf�T�� 
�,� �� ��'&��&>; Returns the underlying sequence of byte ranges as a slice.�D�'gg�g
��'
$�'��'Լ*��)74 Returns the number of byte ranges in this sequence.��)���)C@ The length is guaranteed to be in the closed interval `[1, 4]`.��*hh���*
$�*��++��+IF Returns true if and only if a prefix of `bytes` matches this sequence���+ of byte ranges.�<�+iji�j�T�+
$�+bytes�,�+��-*�
��H�H�H�.l�.D�.�g�gIter��h��g�h
end_or_len��g�h_marker��gFPR<?���
�L�.$�.�
���.$L�.���H
�
$�/��/ ��_��/4�/klmk�l�^�^��^��[�^buf��[����e�S�m��������������������q�aX�ÅÅą��:�����/
$�/��0��0t�5� !��5"�5���
 �,�5��5��6$��5@= Returns true if and only if the given byte is in this range.�<�6nn���6
!$�6b��6�7�#�_#��74�7opqo�p�^�^��^��[�^�]�[����e�S�q�^"�7"
#$�7��7��H��9=: An iterator over ranges of matching UTF-8 byte sequences.��9���9KH The iteration represents an alternation of comprehensive byte sequences���:@= that match precisely the set of UTF-8 encoded scalar values.��:���:NK A byte sequence corresponds to one of the scalar values in the range given���;MJ if and only if it completely matches exactly one of the sequences of byte���<%" ranges produced by this iterator.��<���<OL Each sequence of byte ranges matches a unique set of bytes. That is, no two���=(% sequences will match the same bytes.��=�l�=
 # Example��=���=IF This shows how to match an arbitrary byte sequence against a range of���> scalar values.��>�\�> ```rust���>30 use utf8_ranges::{Utf8Sequences, Utf8Sequence};��>���>=: fn matches(seqs: &[Utf8Sequence], bytes: &[u8]) -> bool {�ܫ?     for range in seqs {���?%"         if range.matches(bytes) {���?             return true;�l�@
         }�L�@     }�l�@
     false�,�@ }��@���@)& // Test the basic multilingual plane.���@IF let seqs: Vec<_> = Utf8Sequences::new('\u{0}', '\u{FFFF}').collect();��A��A // UTF-8 encoding of 'a'.���A%" assert!(matches(&seqs, &[0x61]));���A,) // UTF-8 encoding of '☃' (`\u{2603}`).���B1. assert!(matches(&seqs, &[0xE2, 0x98, 0x83]));���B74 // UTF-8 encoding of `\u{10348}` (outside the BMP).���C85 assert!(!matches(&seqs, &[0xF0, 0x90, 0x8D, 0x88]));���CHE // Tries to match against a UTF-8 encoding of a surrogate codepoint,���DIF // which is invalid UTF-8, and therefore fails, despite the fact that���DEB // the corresponding codepoint (0xD800) falls in the range given.���E2/ assert!(!matches(&seqs, &[0xED, 0xA0, 0x80]));���E1. // And fails against plain old invalid UTF-8.���F,) assert!(!matches(&seqs, &[0xFF, 0xFF]));�<�F ```��F���FLI If this example seems circuitous, that's because it is! It's meant to be���GNK illustrative. In practice, you could just try to decode your byte sequence���GMJ and compare it with the scalar value range directly. However, this is not���H=: always possible (for example, in a byte based automaton).�l�H�Q�s���Q%�I\�I$$�?�?��?�]�:�?�	�:$x��Lk���B�B�BGlobal�����I����I�'()��J*��IKH Create a new iterator over UTF-8 byte ranges for the scalar value range�T�J given.��J�&&
'�,�J��J��M/��K(% reset resets the scalar value range.���K?< Any existing state is cleared, but resources may be reused.��L���L41 N.B. Benchmarks say that this method is dubious.���L�L�M8�4�Mt�L,�Mrr��&�M&
($�M�,�M��M��N($�Nss����&�N&
)$�N�,�N��N��O\�O��6
�)�u=+,T�O,�O**�D�O�O**���O�.�_.��O4�Otuvt�u�^�^��^��[�^�]�[����e�S�v�^-�O-
.$�O��O��P�01�J�J1L�Q$�Q//���Q($�Qww�����������������;t�����J/�Q/
1$�Q�11�11���`�56789��a5,�axx�����������������;t�����4�a4
5$�a��dD�dyy�4�d4
6$�d��f'D�fzz�����������������;t����4�f4
7$�f��hD�h{{�4�h4
8$�h��k;4�k|}~|�}�T~�T�4�k4
9$�k�,�k��k��m)��m��
:nbytes�4�m����63 Utf8Sequence represents a sequence of byte ranges.�����FC To match a Utf8Sequence, a candidate byte sequence must match each��� successive range.�����IF For example, if there are two ranges, `[C2-DF][80-BF]`, then the byte���>; sequence `\xDD\x61` would not match because `0x61 < 0x80`.�d���KǨ�W�{<=?@CDGH=>��@A�'�DE�&�HI�%�f�� One byte range.�f;;
=ff��;;��L�;;���� Two successive byte ranges.��;;
@���'�;;��t�;;�'�����! Three successive byte ranges.��;;
D���&�;;��t�;;�&)
���  Four successive byte ranges.�;;
H�%�;;��t�;;�%z
� ���
�
�M�M�
�
��L�L
M,���)
�z
�LL�R�RL�LLLL8�LLL����Q�Q
R���)
�z
�������X�X��������W�W
XL�����3��3,) A single inclusive range of UTF-8 bytes.�	L�4�_~l_a���Z[l�4��4$! Start of byte range (inclusive).�,�4YY�\�4��4" End of byte range (inclusive).��4YY����]�]������\�3\
],�3 �3�������a�a��������`�3`
aL�3��gg �c�cg�gggg8�ggg����b�3b
c�3x ���� �]�}����,�u��0�L�0������7�L�7���
����P�L�P����
��
�(
��	�~	��k��k���
�Z�`��q�w���&4article on regexps�*https://swtch.com/~rsc/regexp/regexp3.html�whttps://github.com/apache/lucene-solr/blob/trunk/lucene/core/src/java/org/apache/lucene/util/automaton/UTF32ToUTF8.java��Lucene���������������;B�������	{,;��H *���GCEo�� ~=�%�C�׺�~�m�krP��Z����9R
�����p!�'9��%=Kd�Ea��V�"�{�L�LP���>���L����Z>v��w�a��
��`b��LFj��t:F+�{��J\4[�(%"�.f���#N؆��@C���B�u�;���w&}e���q'�M4�rb�ghg�eKlc���Q�+��) �c	Rz�b&���c�U�Rgd]K�ʘX��_���!��=�$�\Ӗ�gY�δ��d٣
�
�Lڬk
�O�R1:�0�F>/c$r�:�RV�	�6&�o�8?���D�u.��CQ6�T_E$�[��3�"���BM�8���r#!V#�
�f��i�b�!�}fҟG�V�=���1�9�)42�Ba��8�D���n�3�ˣj-�:�M�7QK]�T$D:>��?������~ٝ��Y�kۘc@K�nM�����>v׆�&���`�o�9Z���wD�˲F6C)\��3����D!ЛJӤ.$�2�8MK]ɡ%d{~�������י2��&�K��h��Q	}Z�q�dp&�^F{��L�ݻ���O<`����f���}���do� ��q�J�LtW�N�2hZ�؋�����I�����
�Q�9z�]��mQ��QPy���z��U��L�k&��<�nq+Qp�y˥!n�*��_�C!�f�xG��mSbj�c����sm�h%�c�h=���zcSdH��.sFJ ���=��T����H���:j���XCp	���5<�@x�J�h��d}8Ǝ��ń"��LĀ�|bg'�h
���f�aL��?���
��8���-W��Y`�*�Ѭ;��8��q����z&E�+�Ͽsܸ�i�D����t�+)��@kv%�!J&�$��UFĠ�����*Q8�֫�fZЂ��`�������*-^������R^N�u����̂!� AD���rs�}�=q+b��E~���{��ƺ��B�����ڬ�g?x�f�n�T�U+%p>�R�[R��Ȝ8gKhKeKfKi(�(�()!)5)I)])q)�)�)<*V*�*[+>,-I-�-�-(.C.d/z/�/_0z021�:;;�;=k=�=�=�=�=�>�>�>y?�?)@u@AQA�A
B�C9DMD�D�DYE{E�EF(FFF�F�FpG�G�GHfH�H�H	IWIkI�I�IJJb()�CH*)-4.p/k0�:;�=�=�>�?�C�C�C�C$F9F�F�G�G`H�HgI|I�IJ










''''a(�())%)9)M)a)u)�)�)k*+,�,M-�-�-X.�/0�0e:�:�;�< =q=�=�=�=�>�>�?>@�@AfA�AjC�CD;DzD�D�DE:E[E�E�E�EZFG�GBH�H�HI�IUJ
�(�(�(�(�(�(�(�())1)E)Y)m)�)�)8*Q*�*S+W+9,
-?-E-�-�-#.>.\/`/u/�/[0u01�:;;�;=g=�=�=�=�=�>�>�>Q?c?u?�?%@p@ALA�AB�CD5DJD�D�D�D�D#EUEjExE�E�EFF%FCF�F�F�F�F�FCGQG_GmG�G�GHbH�H�HIRIhI}I�I�IJ�J�J�J�J�J�J�J�J�J�J�J�J�J�J�J�J�J�J�JK
KKKK"K(K/K6K<KBKHKNKTKZK`K�(�(�(�(�(�(�()!)5)I)])q)�)�)V*+�+�,C-I-�-�-C.z/
0z0a:�:�;�<=m=�=�=�=�>�>�?)@u@AQA�AfC�CD9DwD�D�DE&EYE�E�E�EFF�F�G>H�H�H	I�IAJ�J�J�J�J�J�J�J�J�J�J�J�J�J�J�J�J�J�JKK
KKKK%K,K3K9K?KEKKKQKWK]KbK�()-)A)U)i)})�)*D*�*D+*,�,%-V-�-.0.E/l/�/C0g01l:�:;�;�<H=y=�=�=�=k>�>�>B?\?n?�?@a@�@=A�A�AqC�C,DDD�D�D�D�DELEdEsE�E�E�E
F F5F~F�F�F�F�F4GLGZGhG}G�G�GIH�H�H�HCIcIxI�I�IJ{J�()');)O)c)w)�)*>*�*8+,�,-N-�-.*.9/f/�/70a0�0f:�:;�;�<<=s=�=�=�=_>�>�>6?T?f?{?
@U@�@1A�A�AkC�C$D<D{D�D�D�DEDE\EmE�E�E�EFF/FqF�F�F�F�F'GFGTGbGwG�G�GCH�H�H�H6I]IrI�I�IJnJ�()/)C)W)k))�)*F*�*H+.,�,'-Z-�-.2.I/n/�/G0i01n:�:;�;�<L={=�=�=�=o>�>�>F?`?r?�?@e@�@AA�A�AsC�C2DHD�D�D�D�DEREhEuE�E�E�EF"F7F�F�F�F�F�F8GNG\GjGG�G�GKH�H�H�HGIeIzI�I�IJJ�)m*+,�,�-Y.�/ 0�0f:�;�<"=s=�=�>�?@@�@AhA�AkCD�D;E�E[FG�GCHI�IVJ�)m*+,�,�-Y.�/ 0�0�;�<"=�=�>�?@@�@AhA�A�CD�C�D�C;E�C�E[FG�GI�IVJ�)Z*+�+�,�-G.~/0~0�;�<=�=�>�?-@y@	AUA�A	D�D)E�EIF�F�GI�IDJ��4	>	x	�����			*	d���
8��=S
q
�
!z�(~��@��'
dx
9����C�?�c7��;Q�p
�
 y�'}�c��&
w
��
8��7��B��<R�0D�DPE�Ei
�
h�r��O
p
�
��0�;�m
�
l�!v��S#
t
�
��4�?�*�*L+2,�,.M/�/K01�;�<P=s>J?@i@�@EA�A�A�F<G�GKI�I�J_(�(<*-(.d/_0_:;k=�=�>y?dC�CuD
E�EF-F�FuG�G<H�H[IpI�IJ|:�=�CYHp:}=uCMH��
/?N^p����������
&-48?CGNUY`t�����������������*1H[eipz~������������������������!(,04;?FLRX^djpv|���������������������~:�=�C�C�C�C[HL*M*N*O*,-1-6-5.r/s/l0;;;�=�>�>�?�?�?�?�?:F�F�G�H�IJiKb?t?�DwEF�F�F�FPG^GlGP*;-:.t/q0;�=�>�?$F?F�F�G�GIgI|I�IJ'(!#.1�C�g�g�Z�h��g�h�Z�g�h�[�gFPR<?����g�g�Z�h��g�h�Z�g�h�[�gFPR<?����C�����C�����������^���^���^���^���^���^���^��^��^��^��^�)��v&&RawVec�)inner�*�[��3�{���v�����E��J����D���D���&��������V,��Km
]��&�����&�����&������������,M�[�}���o��n��n��h��g��S�?��@��v�@��v�@��v�@��vI��v�H����Zip���a��C���`�C����C���	�C��ڸ(j�����H���A��vQ��v�E��������������g� ���+e�f\core_intrinsics�	derive_eq������;B�������c�p��gt	S)}�J���derive_clone_copy����;B�����n�m������	c(����������;B��������xXtt�,��������;B�����(���8�����%���Z���;B������J���51_���3%1���;B����������	�)��O\������;B�����Bg��[ov�~$�u����������;B�������J,��؀����;B�������m�i��R,�������;B����������w��~	$�3��������;B���������C��trrrrr�q rrrr$rtOs�s�ssHrCt�rvt�s�r8r3tps�st?s�rft�r�t�ss�ODHT ��� �c	Rz��Z>v��Ђ��`��x���B�u��I����R��9R
�������FXCp	���df�n�T�>�R�[R���Ȝ8�5<�@x�eD�˲F@
�f��/mSbj�c�\�n�3�5�2��&�KG��?����9�!��=�$ ��
��8�li�b�!�}f0�3�"���,T_E$�[�+]�T$D:>8L�k&��W�|bg'�hi�U+%p��+)��s�H *�����Q�+��)��	{,;�<�nq+Qp�X�JӤ.$�2C��1�9�2�CQ6�*BM�8��-�O<`�L)42�Ba��3�_�C!�Z8�D���4��z&E�+�p+b��E~��f�xG��[hg�eKlc��8MK]�DLtW�N�2P�R^N�u�{�7QK7�$��UFĠu�r#!V#�.ҟG�V�=�1��-W��m6C)\��3A���`�o>Kd�Ea��V

��`b��LF>/c$r�&U�Rgd]K�δ��d٣"%�c�h=^�ڬ�g?x��]��mQ��Ty˥!n�*�Y����p!�M4�rb�g���sm�h]QPy���U�%d{~��E�^F{��J�"�{�L��׺�~�m�4[�(%"z��U��VLP���>���f���}M���̂!� |s�}�=q~�>v׆�&=hZ�؋���Q��{��ƀ����D!�B+�{��J\krP��Z��K�nM����<L�ݻ��K�����*v:�RV�	�'���do�N��~ٝ��Y:GCEo��^�����zAD���r}L��?�kb&���c��9Z���w?Q8�֫�fZw6&�o�8?(Fj��t:F@kv%�!J&tϿsܸ�i�q�
�Q�9zS���D�u.�)J�h��df�\Ӗ�gY�!���L���
&}e���q'
���f�aj��8��q��oN؆��@C��h��Q	H�.f���#���B������kۘc@;�T����H�bˣj-�:�M6�����*-yw�a��}8Ǝ��g}Z�q�dp&I���zc_��:j���cń"��LĀh ~=�%�Ck
�O�R$�'9��%=	 ��q�J�OSdH��.s`Y`�*�Ѭ;nD����tr1:�0�%
�
�Lڬ#�;B�����FJ ���=�aʘX��_���;���w�s��e�U�:AkK���*)T����#gq
%{i�3e�Z\4_\x{��g�������������zwzr}���Y�d{�%���P?s~������7+&[Qw�����}B��34�����F�cvFC
F>8�����^����c�h.\M�j��,�
���9�Y��I�;-���#�����H���=�m������e�0\!����������� ��Z&
@
����1v@�!���u9:e�V��_�HJ;�s��e�U�:AkK���^/home/palash/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/utf8-ranges-0.1.3/src/lib.rs� -x5�}�[�^.1�.6���KM#KJJG5
GC<LKOOMN5
//KMH
K48
NMIMNM
HJD�:&!7GJ?&$&%NB>,%22'222&2222@
C-#B"$#
<H!N2&
0

-0+$#;#0=I9;
-&)')-E+) ;$,;
>LAON&P)J4>&
*J&-289IJF32-MON>#P1<+-D96"-/G";C"/
941($%##-373%):A-080A1-.:6-538>0

K.<6 #
;!M>.C
O*!,L1CB641/
,?
. 4*D+#:76+IF6I
$ACCDD&/.6!
7;7#9NNNN?%
�B�a3�٬�\���=���d/home/palash/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/utf8-ranges-0.1.3/src/char_utf8.rs� 7���m^l,��{םcj�	$=1%%%%###
G!-3716:719771

���r��RM�z��]����?�x86_64-unknown-linux-gnu��F��/���2���rutf8_ranges�-156b7408ec74e8ed��;B�����Ӌ����d�d�Z�ddd<�c���d�\��\���dd�d�d�d�d�c��dV�d��d�dIdd�dVV��ddd�c�ZZ����Zd��Vc��4M�!<!BB�!rust-end-file