Files
boc/rust-service/target/debug/deps/libzerovec-4472b0057d74fe55.rmeta
T

3167 lines
784 KiB
Plaintext
Raw Normal View History

rust
ä> #rustc 1.96.0 (ac68faa20 2026-05-25)ÁíàÄTËŸ ÜJîÄ)'ß\¥!-3d1337db07d0b3aeÁzerofromÁŠö‘JÁ¯G™è](^Ø”o-dcafde80b60b6e04Ázerofrom_deriveÁ¨ 8ïlÌfOµ— ˆ´-2ea7b665324646a9Á¤°ð ¾ä-±($²ï=©Ã-7e98a21bfd32b0edÁzerovec_deriveÁGôMjmO6ãžË˜}…œ-cb226320172b7a66ÁyokeÁõhŸÂM¾Šp>báf6Ì-d3327e9ee0391076Ástable_deref_traitÁ½ÊTýö÷n˜TóQ-á†-771635b0451f799dÁ yoke_deriveÁº‰ñyåÁðÕCáŠʘÃ-1f6bb0ffd13f0264Á¤,˜K»¤Œ÷JBoxÁ«»¤Œ… ManuallyDropÁd‡»¤ŒätestsÁ,ég$ÞghashmapÁ<ÍK»¯œ¯KØôK»¤ŒÜKmap2dÁ,—L»¤ŒÿKsamplesÁ<³L$¤LschemarsÁDÝL»¤ÂLY get_serializable_bytes_non_emptyÁüîÊ »¤ŒÓÊXownedÁ,÷»¤ŒÔ܃»¤ŒÜö»¤Ùö黤ŒÅXdatabakeÁDʻ̤¯XserdeÁ,ó»êŒÛXVarZeroVecOwnedÁ|ß»¤Œ¼¿Ì»Ì¤Ñ¿ê,•»êŒýÀÜ»¤ŒßÀ¿o¢»¤Œû¿öÑ»¤Œ­¿»¤Œ—¿,ùº$îº$‡customÁ4Ì Ó¾ §oð
»¤ŒÈ
§ToOwnedÁ<õ
»¤ §Ü«
»¤Œ…
§ß
»¤Œ¶
§Á
»¤Œë
§ö
»¤§encode_varule_to_boxÁ¤‰%
»¤Œî$
§$òW
$çW
é VarZeroSliceÁdÎ Ó½  ZeroMapKVÁLŽ »¤Œê  ZeroSliceÁL¿ »¤ŒŸ ZeroVecÁ<Ê »¤
test_utilsÁTº  ø,ÌX
$ÁX
¤ <Ô »¤Œ¬ Üä »¤š
¤¼ »¤Œ˜ Üß »¤Œ¹ ÎZeroMapBorrowedÁ|ö»¤ŒÒÎù
»¤ŒÎZeroMap2dBorrowedÁŒè»¤ŒÂÎZeroMapÁ<⻤ŒÂÎ ZeroMap2dÁL뻤 $ÍX$“Xöù
»¤ŒÑöÆ
<—»¤Œ÷öä
L »¤ ZeroHashMapÁ\ŸO»¯œñNÆ
<ßO»¤Œ²Oä
LP»¤ŒîO  borrowÁ4®R»¤Œ‡R  boxedÁ,çR»¤ŒÀR  ê,™S»êŒùRmapsÁ$ÅS»¤Œ©S¢ |’b»¤Œßa,ˤ$ç£ícowÁ
VarZeroCowÁ
'aÁ
§
@
marker1Á
RawVarZeroCowÁbufÁƒŠ§ƒŠ§ parse_bytesÁfrom_bytes_uncheckedÁ new_borrowedÁ"Š"§"is_ownedÁ"as_bytesÁ"from_rawÁ(Ü(ë+Š+§+å+´0Š0§0÷ 4Š4§4×
8Š8§8 <Š<§ ?Š?§?ï

CŠC§CGŠG§Gencode_var_ule_as_slicesÁJ£Jimpl FnOnce(&[&[u8]]) -> RÁGencode_var_ule_lenÁGencode_var_ule_writeÁOŠO§O zero_fromÁSŠS'bÁS§Sé
varzerovecÁX
componentsÁYYYYYYYVarZeroVecFormatÁ`IndexÁ`LenÁY
IntegerULEÁcTOO_LARGE_ERRORÁcSIZEÁc MAX_VALUEÁc
iule_to_usizeÁciule_from_usizeÁYiìiøYlìm løo Yqìr qøt Yvv©v´vÄvØY| ||©|´|Ä|ØYƒ ƒƒ©ƒ´ƒÄƒØYŠŠŠ¥ŠYŽŠŽ¥ŽŽƒYŠ¥>Y ˜Š˜¥˜˜æ Y
ХС ¡ parse_bytes_with_lengthÁœ from_bytes_unchecked_with_lengthÁis_emptyÁgetÁ
get_uncheckedÁget_things_rangeÁget_indices_sizeÁcheck_indices_and_thingsÁù
indices_sliceÁY °Š°¥°°ƒY µŠµ¥µµæ Y
ºŠº¥ºººó º size_hintÁYÁŠÁ¥ÁÁYÆŠÆ¥ÆÆ
binary_searchÁÊ Æbinary_search_in_rangeÁÌ YΊΥÎÎbinary_search_byÁÒimpl FnMut(&T) -> OrderingÁÎbinary_search_in_range_byÁÔÔ Ô Î binary_search_in_range_uncheckedÁØY'write_serializable_bytes_without_lengthÁÚ¥ÚÚYwrite_serializable_bytesÁÞ¥ÞÞY'compute_serializable_len_without_lengthÁâ¥âââ â Ycompute_serializable_lenÁè¥èèè XerrorÁíííð×X
lengthlessÁòòòòò÷¥÷÷
as_componentsÁúŠ÷ŠüŠü ÷œ÷from_bytes_unchecked_mutÁ÷ß÷ë÷get_bytes_at_mutÁXž 
  
Ù
¥Ú entire_sliceÁ˜¥˜˜ new_emptyÁ˜#œŠ˜œ˜˜Ä˜ù¡˜Ô˜ß˜ë˜
as_varzerovecÁ¦Š˜Š¨Šª¥ªª¦ªÀ¯¥¯¯ÿ²¯¹´¥validate_bytesÁ¹ œë½¥½½°½ÖÂ¥ÂÂÆ¥ÆÉ¥ÉÉï
Í¥ÍÍ Ñ¥ÑÑ×
Õ¥ÕÕÉXÁÙÙÙÙÙÙÙÙÙ
VarZeroVecÁâ
âŠâ¥ââˆÙVarZeroVecInnerÁèŠè¥èèBorrowedÁì
ìˆÙïŠï¥ïïƒÙô¥ôô×ÙøŠø¥øø÷Ùý¥ýý>Ù¥å´ÙŠ¥æ Šœas_sliceÁÜ‚#ÙŠ¥ÙŠ¥Ù¥Ÿ Ù ¡¥¡¡¡Ÿ¡ ¡§ § Ù
ªŠª¥ªªï
Ù ¯Š¯¥¯¯XXXXXXXXXX X
zerovecÁ¿žÀÀÀÀ Ä
ĥĈÀȥȚ%È
as_zerovecÁÈŠÈœÈfrom_ule_sliceÁÈëÈ as_ule_sliceÁÈÈÄÀÓ¥ÓÔÓ get_as_arrayÁÖŸÖ Ö Ö Ó get_subsliceÁÓ get_ule_refÁÓcastÁÝ¡Ótry_as_convertedÁß¡ÓfirstÁÓÓùãŠÓ split_firstÁÀæŠæ¥ææó æÕÀìŠì¥ìÀðŠð¥ð next_backÁÀô¥ô¦ö Àø¥øÿúimpl FnMut(T) -> OrderingÁú Àý¥ý—'ýœÀ¥À ƒ¥ƒÀ
¥À Š¥À Š¥À
¥×À¥ï
À¥Àš¥šÉÀ¥>¿¿¿¿¿¿¿¿¿¿ ¿
¿ ¿¹ ¬Š¬¥¬Â¬ ¬marker2Á¿²Š²¥¿µŠµ¥¿¸Š¸¥¸å¸´¿EyepatchHackVectorÁ½¦½Â¿À¦Àas_arbitrary_sliceÁŠÀœ,ÄŠÀtruncateÁ¿ÇŠÇ¥Çƒ¿ËŠË¥ËɿϥÏ׿ҥ¿ÔŠÔÔ¥Ô¿ ٥ٿ
Ü¥ÜŸÜ Üà ¿ âŠâ¥â>¿ æŠæ¥æï
¿
êŠê¥ê¿îŠî¥îÉ¿òŠò¥ò÷¿öŠö¥öæ ö const_lenÁö·öŠöœöœ,öÜöas_maybe_borrowedÁöowned_capacityÁ¿Š¿Š¥¿Š¥try_from_sliceÁŠ ¿ŒŠŒ¥ŒclearÁŒ truncatedÁ¿ zerosliceÁ¿é.uleÁcharsÁ from_alignedÁto_charÁœ—' ŸULEÁŸ to_unalignedÁŸfrom_unalignedÁ£ï
¥encodeÁ§§§§§§§§EncodeAsVarULEÁ¯¥¯Ü±£±¯£´ µ ¯¼· §¹¥¹Ü»£»§¾¥¾ÜÀ£À§Ã¥ÃÜţŧȥÈÜÊ£Êȣȼ§Ï¥ÏÜÑ£Ñϣϼ§Ö¥ÖÖÖÜÚ£ÚÖ£Ö¼§ß¥ßßÜâ£âߣ߼macrosÁçimpl_ule_from_arrayÁmultiÁéééééîLENÁîFormatÁîcompute_encoded_len_forÁñ î&new_from_lengths_partially_initializedÁóŠó î set_field_atÁö¥öîvalidate_fieldÁù¥î get_fieldÁû¥îœîëéÿÇBÿÒBÿ×éBlankSliceEncoderÁƒ
ƒˆéÜ££¼éŒÇBŒÒBŒ—' ŒœnicheÁ
NicheBytesÁŸNICHE_BIT_PATTERNÁ NichedOptionULEÁ¦ŸÄEž validÁ¡¦¡Ÿ¡×¥¦¥Ÿ¥æ ¥Ô¥É«¦«Ÿ®¦®Ÿ®ƒ²¦²Ÿ²¦Ÿ¹¦¹Ÿ¹—'¼ ¾¦¾Ÿ¾>¦ŸÂÈ=ÂÓ=Âç= ȥȟÈIntoIterÁÈÈê³
ÎÎÎÎÎ OptionULEÁÓ
Ó¦ÓˆÓÎØ¦ØÔØæ ÎܦÜ×Îߦߗ'á Îã¥ãÈ=ãÓ=ãç=Îè¦Îê¦êƒÎí¦íÎð¦Î OptionVarULEÁò
ò¦òˆòòŠÎø¦øÉÎ û¦û×Î
þ¦þ—'þœÎ ¥¦Ü££¼Î ЦŠÎ
¦Î¦ï
ΦplainÁœŸœëœ¼# Ÿ —'£Ÿ£ £÷¦ impl_numbers_with_raw_bytes_uleÁimpl_const_constructorsÁimpl_byte_slice_typeÁ«—'­È=­Ó=­ç=²—'³ µÈ=µÓ=µç= º ºÿE¼ 
¾—' ÀÈ=ÀÓ=Àç= 
ÅÈ=ÅÓ=Åç=É—'ËÈ=ËÓ=Ëç=З'ÒÈ=ÒÓ=Òç=slicesÁ××٥ٟ٠ٗ'×Þ¥ÞŸÞ ÞÈ=â ÞÓ=Þç=׿¥æŸæ ×ê—'ë êŠí êœ×ð¥ð—'ðœ°ôôô tuple_uleÁtuplevarÁøøøøøøøø tuple_varuleÁvartupleÁ ŒŒ§Œ—' Œœ§Ü££¼Š§é 
  
È=°—'°parse_bytes_to_sliceÁ°slice_from_bytes_uncheckedÁ°slice_as_bytesÁAsULEÁµÈ=µÓ=µç=EqULEÁ
SliceAsULEÁºslice_to_unalignedÁ¼¥¼»WVarULEÁ¿—'¿Š¿œ¿ëÆ×ÈparseÁÉ¥ÈlengthÁË¥
yoke_implsÁÎÎÎÎÎÎÎÎÎÎØŠØ¥Ø°Ø transformÁØtransform_ownedÁØmakeÁØ
transform_mutÁßßÎâŠâ¥â°â¿YâÐYâçYâóYééÎìŠì¥ì°ì¿YìÐYìçYìóYóózerofrom_implsÁöööööööööÿ'zfÁÿ¥ÿéöƒ ô[ƒ ¥ƒ éöô[¥éöô[¥éö ô[ ¥  éöô[¥é__zerovec_internal_reexportÁ  vecsÁ¢ ¢ ¢ ¢ ¢ ¢ ¢ ¢ ¢ ¢  ¢ 
¢  ¢  ¢  VarZeroVec16Á° а ¥¢  VarZeroVec32Á³ г ¥¢ VarZeroSlice16Á¥¢ VarZeroSlice32Á¸ ¥ YIndex8Á¼
YYYÀ ƒYÂ ×YÄ §Å ùYYÈ YÊ ÖYÌ ï
YÎ YIndex16ÁÐ
YYYÔ ƒYÖ ×YØ §Ù ùY Y!Ü Y"Þ ÖY#à ï
Y$â YIndex32Áä
Y%Y&Y'è ƒY(ê ×Y)ì §í ùY*Y+ð Y,ò ÖY-ô ï
Y.ö YVarZeroVecComponentsÁø Šø ¥ø ø ø indicesÁø thingsÁø ÚY/
Š
¥

×YVarZeroSliceIterÁ
Š
¥

¬
Ö
 start_indexÁY0Œ
ŠŒ
¥Œ
Œ
×íVarZeroVecFormatErrorÁ
MetadataÁ

ValuesÁ

ˆí
×òVarZeroLengthlessSliceÁ
¥

Ú
ñ$òž
¥ž
ò¡
¥¡
¡
ò¥
¥¥
¥
ÖÀ
ZeroSliceIterÁ©
©
Š©
¥©
ˆÀ®
Š®
¥®
×CharULEÁ²
²
ˆ´

×¹
»
Ö¼
 
¿
ƒÀ
  Ã
§Ä
ù
from_arrayÁÆ
ŸÆ
Æ
Æ
Æ
éMultiFieldsULEÁÌ
Ì
ÇBÌ
ÒBÌ
ˆéÑ
ÇBÑ
ÒBÑ
éÕ
ÇBÕ
ÒBÕ
Õ
Ù
éÛ
ÇBÛ
ÒBÛ
Û
Ö NichedOptionÁà
à
¦à
Ÿà
ˆ
å
¦å
Ÿå
å
× ê
¦ê
Ÿê
 î
¦î
Ÿî
î
ƒò

ô
¦ô
Ÿô
ø
¦ø
Ÿø
ø
ü
þ
¦þ
Ÿþ
þ
Öƒ ¦ƒ Ÿƒ ƒ § ù ¦ Ÿ  ï
  ¦ Ÿ    RawBytesULEÁ
 Ÿ ˆ˜ š Ÿš š מ Ÿž ¡ Ÿ¡ ¡ ¤ ¦ Ÿ¦ ¦ Ö© « Ÿ« ® Ÿ® ® ƒ± ± ´ Ÿ´ · Ÿ· · ï
º ¼ Ÿ¼ ¼ ¿ Á ŸÁ Á §Ä ùÇ Ç as_unsigned_intÁÇ 
as_signed_intÁÇ Ž=Ç îgÌ ŸÌ Ì Ì Ì Ò Ò ÷ Õ È=Ö Õ Ó=Õ ç=!"Û Û 
from_unsignedÁ#Þ try_from_bytesÁß STRIDEÁ$á á ÷%ä È=å ä Ó=ä ç=&'ê ê  from_signedÁ(í ¦pî ¼p)ñ ñ ñnñ ˆoñ as_floatÁñ Ž=ñ îg÷ Ÿ÷ ÷ ÷ ÷ *ý ý ÷+ È=  Ó= ç=,-  Œp. ¦pŠ ¼p/Œ Œ ÷0 È=  Ó= ç=12  q3˜ ¦p ¼p4  ÷5ž È=Ÿ ž Ó=ž ç=67¤ ¤ 
from_floatÁ8§ ¦p¨ ¼p9« « ñn« ˆo« Öq« Ž=« îg± Ÿ± ± ± ± :· · ÷;º È=» º Ó=º ç=<=À À Œp>à ¦pÄ ¼p?Æ Æ ÷@É È=Ê É Ó=É ç=ABÏ Ï qCÒ ¦pÓ ¼pDÕ Õ ÷EØ È=Ù Ø Ó=Ø ç=FGÞ Þ •tHá ¦pâ ¼pIå å ñnå ˆoå Ž=å îgê Ÿê ê ê ê Jð ð ÷Kó È=ô ó Ó=ó ç=LMù ù ŒpNü ¦pý ¼pOÿ ÿ ÷P
È=ƒ

Ó=
ç=QRˆ
ˆ
qS
¦pŒ
¼pTŽ
¦p
¼pU
¦p
¼pV
¦p
¼pô Tuple2ULEÁ



ˆ
ô


—'ô¡
¡
¡
È=¡
Ó=¡
ç=ô§
§
§
×ô«
«
«
ô¯
¯
ô²
²
²
ï
ô


ôº
º
º
ƒô¾
¾
ô Tuple3ULEÁÁ
Á
Á
Á
Á
ˆÁ
Á
Šô É
É
É
É
—'ô
Î
Î
Î
Î
È=Î
Ó=Î
ç=ô Õ
Õ
Õ
Õ
×ô Ú
Ú
Ú
Ú
ô
ß
ß
ß
ôã
ã
ã
ã
ï
ôè
è
è
è
ôí
í
í
í
ƒôò
ò
ò
ô Tuple4ULEÁö
ö
ö
ö
ö
ö
ˆö
ö
Šö
ô—'ôÈ=Ó=ç=ôŽŽŽŽŽ×ôôššššôŸŸŸŸŸï
ô¥¥¥¥¥ô«««««ƒô±±±±ô Tuple5ULEÁ
ˆŠŒô—'ôÉÉÉÉÉÉÈ=ÉÓ=Éç=ôÒÒÒÒÒÒ×ôÙÙÙÙÙÙôàààààô ææææææï
ô!ííííííô"ôôôôôôƒô#ûûûûûô Tuple6ULEÁ
ˆŠŒô$—'ô%È=Ó=ç=ô&¡¡¡¡¡¡¡×ô'©©©©©©©ô(±±±±±±ô)¸¸¸¸¸¸¸ï
ô*ÀÀÀÀÀÀÀô+ÈÈÈÈÈÈȃô,ÐÐÐÐÐÐø Tuple2VarULEÁ×××ÒB׬׭סBÝ øßßßÒB߬߭øåååÒBå—'é åœë ë øîîîÒBî×øóóóÒBóøøøøÒBøüüüÒBüï
øÒBøAEÁBEÁÒBÜŒ£Œ£ ¼ øŠŒÒBéø Tuple3VarULEÁÒB¬­®¡B£ ø ¥¥¥¥ÒB¥¬¥­¥®ø
­­­­ÒB­—'² ­œ´ ´ ø ····ÒB·×ø ½½½½ÒB½ø
ÃÃÃÃÒBøÈÈÈÈÒBÈï
øÎÎÎÎÒBÎøÔÔÔÔŒÔÔCEÁÔÒBÔÜÜ£ÜÔ£ß Ô¼á øãŠããããŒããû”ãÒBãéø Tuple4VarULEÁíííííÒBí¬í­í®í¯í¡B÷ øùùùùùÒBù¬ù­ù®ù¯øƒƒƒƒƒÒBƒ—' ƒœ  øŽŽŽŽŽÒBŽ×øÒBøœœœœœÒBø¢¢¢¢¢ÒB¢ï
ø©©©©©ÒB©ø°°°°°Œ°°û”°DEÁ°ÒB°Üº£º°£½ °¼¿ øÁŠÁÁÁÁÁŒÁÁû”ÁÒšÁÒBÁéø Tuple5VarULEÁÍÍÍÍÍÍÒBͬͭͮͯͰ͡BÙ øÛÛÛÛÛÛÒBÛ¬Û­Û®Û¯Û°øççççççÒBç—'î çœð ð øóóóóóóÒBó×øûûûûûûÒBûøƒƒƒƒƒƒÒBø ŠŠŠŠŠŠÒBŠï
ø!ÒBø"ššššššŒššû”šÒššEEÁšÒBšÜ¦£¦š£© 𼫠ø#­Š­­­­­­Œ­­û”­Òš­›¡­ÒB­éø Tuple6VarULEÁ»»»»»»»ÒB»¬»­»®»¯»°»±»¡BÉ ø$ËËËËËËËÒBˬ˭ˮ˯˰˱ø%ÙÙÙÙÙÙÙÒBÙ—'á Ùœã ã ø&æææææææÒBæ×ø'ïïïïïïïÒBïø(øøøøøøøÒBø)ÒBï
ø*ÒBø+Œû”Òš›¡FEÁÒBÜ £ ££ ¼¥ ø,§Š§§§§§§§Œ§§û”§Ò𧛡§Ö¨§ÒB§éVarTupleÁ···œ·variableÁ¼¼¼×ÀÀÃÃÃÇÇÇÖËËËï
ÏÏÏ ÓÓÓƒ VarTupleULEÁ×קל×Ū
ÜܧÜ× àà§ ãã§ã
çç§çÖëë§ëï
ïï§ïUleErrorÁó
InvalidLengthÁô´ôó
ParseErrorÁ÷´ûƒý× 
Ö

%
&
)
*
/
7
7
7
;
;
B
B
F
F
J
J
J
M
N
N

¯
´
¿
À
Å
Ê
Ê
Ì
Ì
Ò
Ò
Ô
Ô
Ø
Ø
Ú
Ú
Þ
Þ
â
è
ñ
ñ
ñ
ÿ



ƒ
ž
Ÿ
 
£
¤
¥
­
­
®
®
²
²
´
´
¹
»
¼
Á
Å
Å
Ì
Ì
Ð
Ð
Ô
Ô
Ô
Ø
ó
ô
÷
÷
÷
ý



Ž




Ÿ
Ÿ
Ÿ
¡
§
§
®
®
³
³
Ë
Ì
Í
Î
Ï
Ð
Ñ
Ò
Õ
Ö
Û
Ü
Ý
ß
á
â
å
ê
ë
ï
ó
ö
ö
ú
ÿ



ˆ
ˆ
Œ
Œ









š
œ

¼
Â
Æ
Ê
Î
Ï
Ñ
Ñ
Ñ
Ò
Ø
Ø
Ù
Ù
Û
Û
Û
Ü
à
à
é
é
í
í
ñ
ú
þ
ÿ




¤
¤
¦
¦
±
±
±
´
·
·
»
»
»
¾
À
À
À
Ã
Ã
Å
Å
Å
È
Ê
Ê
Ê
Í
Î
Î
Ï
Ñ
Ñ
Ñ
Ô
Õ
Õ
Ö
Ú
Ú
Ú
Ý
Þ
Þ
ß
â
â
â
å
æ
æ
ö
ö
ù
û
ý
þ






Š




¤
¤
¤
ª
±
µ
µ
¼
Þ
Þ
Þ
á
ì
ï
ï
ú
ý
ý
ý





ˆ


Œ
Œ




ž
Ÿ
¢
¬
³
¿
Ê
Ñ
Ý
ë
í
ï
ò
ó






š
š
±
²
³
´
»
¾
À
Á
Â
Ã
Ç
Ç
Ç
ÿ



Á
Ã
Ã
Ã
Å
Å
É
É
Ë
Í
Í
Ï
Ï
Õ
×
×
×
Ù
Ù
Ý
Ý
ß
á
á
ã
ã
é
ë
ë
ë
í
í
ñ
ñ
ó
õ
õ
÷
÷






˜
˜
˜
¤
¤
¨
±
±
±
·
·
·
º
º
¼
À
Ä
Ä
Ù
Ù
ß
é
é
é
ò
ü
ü










¤
¤
©
±
º
º
¿
¿
Ä
Ä
É
Ê
ß
î
ó
ô
õ
Š

¨
­
®
¯
Ä
Ó
â
ç
è
ý
Œ



 
ª
ª
ª
®
®
µ
µ
¹
¹
½
Í
Ù
Ù
Ù
Þ
Þ
ç
ç
ì
ì
ñ






¤
¤
ª
ª
°
È
Ø
Ø
Ø
ß
ß
ì
ì
ó
ó
ú

¨
¨
¨
°
°
¿
¿
Ç
Ç
Ï
ã
ä
é
ë
ò
ò
ò
÷
÷




Œ
Œ
Œ



ª
«
¬
²
´
¼
¼
¼
Â
Â
Í
Í
Ó
Ó
Ü
Ü
Ü
ß
á
á
ÿ










¨
¨
¯
¯
º
º
º
½
¿
¿
â
ã
ä
å
æ
î
ð
ú
ú
ú






¦
¦
¦
©
«
«
Ó
Ô
Õ
Ö
×
Ø
á
ã
î
î
î
÷
÷
ˆ
ˆ


 
 
 
£
¥
¥
¿
¿
¿
Æ
Æ
Ê
Î
Î
Ò
Ò
Ö
ß
ß
ß
æ
æ
ê
î
î
ò
ò
ü
þ
þ
þ


ƒ
`c¯°µ¹º¿Ìì®Â :I§ ¥ÈØ¥ÈØ

ù@ ž¡Òþ’]8犧é!ìÈéìÈ Š¥É¿cìȵßìÈìÈìÈíßìÈìȺìȯìÈ¥É
ìÈŠ¥É


ù@ ž¡Òþ’]8犧Š

ù@ ž¡Òþ’]8çïÊŠ ¼ ¼ ½ Ê_ ¼G_â+‘µZÛ¿ËØ¿Ë¿c¿Ëše¿ËÐì¿Ëµß¿Ë¿Ë¿Ëí߿˿˺¿ËŠ Ð Ð Ñ Ä` àl;ÛÚÌØÚÌ¿cÚÌšeÚÌÐìÚ̵ßÚÌÚÌÚÌíßÚÌÚ̺ÚÌŠ ä ä å ¿a àr…0aÛxÿÛõÍØõÍ¿cõÍšeõÍÐìõ͵ßõÍõÍõÍíßõÍõͺõÍ`¿Ë`ÚÌ`õÍcc   ¡l˜ ˆ dãÉfKx+oc   ¡l˜ ˆ dãÉfKx+o¿cø ø ºbü Yý öbYþ …cYÿ ÚYÚðx:]†%=ХР½Ðؽг½Ð¿c

¾c
¬YŠ
ÖY
þcY;?>sõ
'zŠ‘Ñ—ÑØÅÑùMÅÑÃMÅÑ¿c


Òd

çd
ˆ¼*„JÂDc¯¾¾ÒÄc¾ÒÐì

eœ
Úò
ñ$òÍ}Õ!cü˜è¥µß›Ó›Ó›Ó¿Ù
Úñ$ØY¼¦fNÕÓÛÓÙ¢ƒÔµßƒÔƒÔƒÔí߃ԃԺƒÔ¿cƒÔàƒÔƒÔØââã¼)çˆ Ó 7)ºëØjŠ‘Ñ—Ñ¿cââã¼)çˆ Ó 7)ºëØj8‘Ñ—Ñé«Õ ŠÙ
Úñ$ØY¼¦fN‘їѳñÕé!ñÕµßââã¼)çˆ Ó 7)ºëØjŠ¥ââã¼)çˆ Ó 7)ºëØjØ×Þ׫յßââã¼)çˆ Ó 7)ºëØj8Ø× 8
µßââã¼)çˆ Ó 7)ºëØj8‘ÑÞןí߫իպ«Õ¿c©
©
ª
œf­
ˆÀ ›T†É\sû¸Š‘ÑùM÷ÙÃM÷ÙŒM÷Ù¿ÄÄŠLjÀ Hr)¡>
ÕÓÛÚµßÛÚÛÚµßÛÚ
ÕÓµßÄÄŠLjÀ Hr)¡>
‘Ѭ¬¹ ¯Â¿° ¿±—6¿àAáš1&0Š‘ÑµßûÛÅÛ¿cÛÚíßÛÚÛÚºÛÚà 8
‘ÑÅÛ³ 8ÅÛÌìûÛ ûÛé!ûÛØûÛàûÛÅÛ¿c¬¬¹ ¯Â¿° ¿±—6¿àAáš1&08‘Ñòݵ߬¬¹ ¯Â¿° ¿±—6¿àAáš1&0Ш׬¬¹ ¯Â¿° ¿±—6¿àAáš1&0Ø×µß¬¬¹ ¯Â¿° ¿±—6¿àAáš1&08Ø× 8
Ø×µßòݑџ³ûÛíßûÛûÛºûÛàûÛÝéûÛ ŠÝ¿c²
²
³
ëf´
ˆ Çî"’}Qæ…Ðì¾áµß¾á¾á¾áÛ¾áØ¾áŠ ¾áše¾á°¾áµíß¾á¾áº¾á¯ÕÓÕÓ¯ 8‘ёѯ 8 8Ø×Ø×¯ 8
‘ÑÅÛ¯òÝÅÛ¯ 8
Ù
Úñ$ØY¼¦fN‘ÑÞׯñÕÀÖÐìÌ
Ì
Í
œhÐ
ˆé lÍjû®÷×ÇBÒBµßÃäÃäÃä¿cÃ䯃ƒÇDˆé }ÿJãeõ!Û
¿Ãä¿cFžÄE ÑFšuV»<ã¦ŸŠ öåØöåµßöåöåöå°öå¿cà
à
á
²iä
ˆ ò,t0ßð°æŸŠ ÿæØÿæÐìÿæµßÿæÿæÿæšeÿæíßÿæÿæºÿæ³ÿæµÿæÇLà
à
á
²iä
ˆ ò,t0ßðÕÓŸ¿cÓÓÔÈIÖˆÎ×Î ÛEfµU­]O°æ°øèµÛ¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙÕÓŠ øèØøèµßøèøèøè¿còòó«KõˆÎöÎ÷ŠÎ Çj¤»¿!¾°æ¿Îê¯Íéòòó«KõˆÎöÎ÷ŠÎ Çj¤»¿!¾¦µßÎêÎêÎêíßÎêÎêºÎê¿c   ¡l˜ ˆ dãÉfKx+oŸÐìÁìµßÁìÁìÁìÛÁìØÁìŠ ÁìíßÁìÁìºÁìšeÁì°ÁìéÁìŸé   ¡l˜ ˆ dãÉfKx+oÓ µ¹é   ¡l˜ ˆ dãÉfKx+oâ µ¹é   ¡l˜ ˆ dãÉfKx+oþ µ¹é   ¡l˜ ˆ dãÉfKx+o µ¹é   ¡l˜ ˆ dãÉfKx+oœ µ¹é   ¡l˜ ˆ dãÉfKx+o¸ µ¹é   ¡l˜ ˆ dãÉfKx+oÇ µ¹é   ¡l˜ ˆ dãÉfKx+oÖ µ¹é   ¡l˜ ˆ dãÉfKx+oñ µ¹é   ¡l˜ ˆ dãÉfKx+o
µ¹°µ¹°ô ô õ ¨÷ ˆÐ  mjçíto鵿ô¹æôæô°µ¹µô ô õ ¨÷ ˆÐ  mjçítoé°µ¹°µ¹°ÕÓŸµäö¹äö¿¿¸Û°

˜
ýy
ˆœ
 ô^ sÚjOµØ÷Þ÷¿cŸ÷µßŸ÷Ÿ÷Ÿ÷íߟ÷Ÿ÷ºŸ÷ØŸ÷Š Ÿ÷°Á
Á
Â
¸|Æ
ˆÇ
È
Š ÜøAwBWnØ÷Þ÷µØ÷Þ÷œù¿cÒøµßÒøÒøÒøíßÒøÒøºÒøØÒøŠ Òø°ö
ö
÷
Ëü
ˆý
þ
Šÿ
 4ÐñØ÷Þ÷œùµØ÷Þ÷œùêú¿c“úµß“ú“ú“úíß“ú“úº“úØ“úŠ “ú°·¶ƒ½ˆ¾¿ŠÀÁŒ hkL8üƒµØ÷Þ÷œùêúµØ÷Þ÷œùêúÉü¿cäûµßäûäûäûíßäûäûºäûØäûŠ äû°ù‡ˆŠŠŒŒŽ ž–¤™ ÒØ÷Þ÷œùêúÉüµØ÷Þ÷œùêúÉü¸þ¿cÆýµßÆýÆýÆýí߯ýÆýºÆýØÆýŠ Æý¿××Û¬øÜ­øÝ¡Bø^׊Z£oðØ÷Þ÷ÒB¿c¸ÿµß¸ÿ¸ÿ¸ÿí߸ÿ¸ÿº¸ÿ¯Œ××Û¬øÜ­øÝ¡Bø^׊Z£oðØ÷Þ÷ÒB
ŒŠ××Û¬øÜ­øÝ¡Bø^׊Z£oðÒB¿™‘ ¬ø¡­ø¢®ø£¡Bø ­\7;2zAØ÷Þ÷œùÒB¿c´‚µß´‚´‚´‚íß´‚´‚º´‚¯ÁÇû”™‘ ¬ø¡­ø¢®ø£¡Bø ­\7;2zAØ÷Þ÷œùÒB
Œû”Š™‘ ¬ø¡­ø¢®ø£¡Bø ­\7;2zA›‚¡‚ÒB¿ííó¬øô­øõ®øö¯ø÷¡Bø|![¹é;˜Ø÷Þ÷œùêú³¿cä…µßä…ä…ä…íßä…䅺䅯݄ã„é„Òšííó¬øô­øõ®øö¯ø÷¡Bø|![¹é;˜Ø÷Þ÷œùêúÒB
Œû”ÒšŠííó¬øô­øõ®øö¯ø÷¡Bø|![¹é;˜›‚¡‚Ñ… ÒB¿ÍÍ÷›Ô¬øÕ­øÖ®ø×¯øØ°øÙ¡BøMXÄñ£íSØ÷Þ÷œùêúÉü§‚¿cˉµßˉˉˉíßˉˉºˉ¯®ˆ´ˆºˆÀˆ ›¡ÍÍ÷›Ô¬øÕ­øÖ®ø×¯øØ°øÙ¡BøMXÄñ£íSØ÷Þ÷œùêúÉü
ÒB
Œû” Òš
›¡ŠÍÍ÷›Ô¬øÕ­øÖ®ø×¯øØ°øÙ¡BøMXÄñ£íS›‚¡‚Ñ…¸‰ ÒB¿»»Ñ¢Ã¬øÄ­øÅ®øÆ¯øÇ°øÈ±øÉ¡Bøúí:ÞÌ]Ø÷Þ÷œùêúÉü¸þÏ„¿cëµßëëëíßëëºë¯¸Œ¾ŒÄŒÊŒÐŒ Ö¨»»Ñ¢Ã¬øÄ­øÅ®øÆ¯øÇ°øÈ±øÉ¡Bøúí:ÞÌ]Ø÷Þ÷œùêúÉü¸þ ÒB
Œ û”
Òš ›¡ ֍л»Ñ¢Ã¬øÄ­øÅ®øÆ¯øÇ°øÈ±øÉ¡Bøúí:ÞÌ]›‚¡‚Ñ…¸‰Ø
ÒB¿c··ªºœ»ŪSè:¥RþØoØ÷Þ÷ÐìÄ’µßÄ’Ä’Ä’íßÄ’Ä’ºÄ’ØÄ’¿c×ט¬ÚœÛŪ*cë ÐäNØ÷¥ÉÐìÖ“µßÖ“Ö“Ö“íßÖ“Ö“ºÖ“¿Ö“¯Ä’×ט¬ÚœÛŪ*cë ÐäNØ÷ïÊ
··ªºœ»ŪSè:¥RþØo›‚¡‚Š×ט¬ÚœÛŪ*cë ÐäN›‚§ºÕÓŠ óô‚®õ´ö÷§®ø´ZEXw¼wƒÛÆ–ØÆ–¿cÆ–ÐìÆ–µßÆ–Æ–Æ–ÄcÆ–¾Æ–Ù¬¬¹ ¯Â¿° ¿±—6¿àAáš1&0‘ÑŠÙââã¼)çˆ Ó 7)ºëØj‘ÑÚÌŠÙ

ù@ ž¡Òþ’]8ç‘ÑŠ
¬¬¹ ¯Â¿° ¿±—6¿àAáš1&0ô[Ø×ô[üß
¬¬¹ ¯Â¿° ¿±—6¿àAáš1&0ô[‘Ñô[ÅÛ
 ô[ÅÛô[ÅÛ
ââã¼)çˆ Ó 7)ºëØjô[‘Ñ—Ñô[ÀÖ
ââã¼)çˆ Ó 7)ºëØjô[Ø×Þ×ô[ââã¼)çˆ Ó 7)ºëØj8Ø×Þ×
 ô[Ù
Úñ$ØY¼¦fN‘ÑÚÌô[²¬µ¬
À ¼ Ô Ð è ä Žø °
ïâǬ¿
²
®î
à
êÓ®  º

í
Á
«ö
ôÈÓ·ûó+
⸬0
øâò¬£ Ò  á  ý  Œ   ·  Æ  Õ  ð  ÿ  4
 ¼ Ö Ð ê ä €
ø Œ


Ñôâ®
©
ÄϬ
²
ÿÌ
¡å
à
ÜÓûòš  §

Õ
Á
Žö
Ò¡î×·ŽíóÍæ»¼·Ü×ýó8
È ¼ Ü Ð ð ä ¡

Âââ¡âƒÄÄĬԬ٬ܬ¹
²
Õ
Ì
²ø
à
íÓŠò¡  «

Ú
Á
ö
Ù©ó×½íûÍï»Ã·ã×ó<
Ê ¼ Þ Ð ò ä ¥

ÆâÄÒ¬»
²
Û
Ì
þ
à
ðÓò¦  ¯

ß
Á
šö
à±ø×ÜíƒÍø»Ç·ç×ó?
Ì ¼ à Ð ô ä ɪâÄæ¬£²
à
ò·  ²

ã
Á
Ÿö
æ¸ü×È¢íŠÍ»Ë·ë×C
Î ¼ â Ð ö ä ͯâÄꬥ²
à
ò¼ 

è
Á
¥ö
íÀ×ΩíͻϷï×G
¹¾
Ã
È
ϬÖ
ßâƒÛ¼
Ô
°
š

·O
S

ã
Á
­
§
·ÿ¬ƒ ¬
â â
¾ ¼ Ò Ð æ ä Šø Â
²
«ê
à
èÓ´  ¾

ò
Á
±ö
ûÐùó¿ ¼ Ó Ð ç ä ¾
²
«  úóÄ ¼ Ø Ð ì ä Ã
²
ƒ à
Á  Ç ¼ Û Ð ï ä ž

¸
²
Ñ
Ì
ô
à
ž  À·à×ÿói¼ lÐ qä v| ƒ ø ýâ
⬾à
º
æ©
Á
ì©
ï
Íóð
ÆóýÄŒÌ
þòêð å×­ƒíçÍÙ»Œ×½Õš
ˬî¬ð©
œ²
¹ßÓ  «²ô ¾ÉÐ
Ù

É
Á
ö
ŸÂà
ãÛ¼Õ ä   ž º É Ø ó 
­µô ÀÅô ËÒ
Þ¡

Î


É

Èà
Ú é   £ ¿ Î Ý ø 
±¹ô ÄÏÖ
æºô ¼Ø¬ââì
Ìì  Ø é!é¿c `µßúíßɺ¦¯¦
YŠ PÛiše*Ðì *`Mc³ùM!ÃM¾Äc¿ Ù¢NàŒM°µ]ÇLƒ¹PºÙË/ü÷/!¤÷/,÷/ àå —0üà/9

´à/
žàå\, ˜0«0í1ü±0–  Æ2—3œˆ3
 tˆ3
'¥É7, š3 ¤3«3 ü§.„üÇ/Þü§0þ

ù@ ž¡Òþ’]8ç¥É$ä. àå,Ð.§ ïíe¼îËè¿*àåºͱ» àå½¥È_£´`¥È7bytesÁwÂ@þØB\òB  ¥Éü˜B¸ 
¥É ÏCÖC'üÙAý׳$‰B¥ÈòA¥È PhantomDataÁFu\»Ÿëµ½@Lp\ "Attempted to build VarZeroVec out of elements that \
cumulatively are larger than a u8 in size"ÁŒâ
 
À$üÎ&x$t < ÏÎüù&yŠ $;ÏÎ]ƒ¸"Attempted to build VarZeroVec out of elements that \
cumulatively are larger than a u16 in size"ÁŒÕ$
 |Õ$
À¶Ï%üÁ$&,Í$$|ƒ%Dƒ%øÏüì$'ý$%<øÏ]ƒ¸"Attempted to build VarZeroVec out of elements that \
cumulatively are larger than a u32 in size"ÁŒ“*
 |“*
ÀùÏ%üÿ)&,*%DÁ*
 Ñüª* »*%B Ñu32::MAXÁ
üˆ'üŠ%¤‹,‹ ›Ó ®AN ´µÿüú» ›Ó–´½Á¢éÀ¡ã´ ´%L”ªàå ÁÂüóO–´½Á,–´d6üÂ"%üÄ"#”Å"Å"ÕÓÛÓ <I]ã´ Ç" ƒÔ æ"¡® î"ï"üÈ!§ ƒÔlä!ûÄþ¡Äýã´ü ÒÃþÐÃÒÃÆ"ÐÃZ :IÐÃeÒÃ_u
üŽ('ü(%¤‘(,(¡Ä ´(?L º(»(žü‡'´ûÄ,Á'–´,°'ûġĜ㴴%I”òDàå ‰EŠE¥üÂDH–´,âDûÄ,ØD–´d6ü´G$ÎG èÕÓÛÓ ÒGü©G+ âÕÓÛÓ ÓGÚG¦üÞF|ââã¼)çˆ Ó 7)ºëØjÕÓÛÓ¤ŠGûÄDýFèìí¢*bÈ‚Òk ÕÓÛÓûÄT®ü”=4Ì®=
¼®=
‘Ñ—Ñ6:P è‘Ñ—Ñ Ç=ü=: â‘Ñ—Ñ È= Î=Ï=Šüê<eââã¼)çˆ Ó 7)ºëØj‘Ñ—Ñ$€=èìí¢*bÈ‚Òk ‘Ñ—ÑA ÀÖDýÍM¤
ü³EwüÍE\ ,£F$ ýÍ3 ¨FQ è‘Ñ—Ñ ©Fü®E} â‘Ñ—Ñ ªF °F±FŒüâDÏüÌ$ŸE–´,‹E½ÍßýÍÞýÍæ–´ß´-Q
ÌÐ å ÊÕÓ ÕÓFS` 
ðÐ ç 
Œ¤Ð 
ÎÕÓž®² è  î ï Êüœ S ÛÚ ­Ò°ÑíÐ
íÐïÐæ íÐ)R ðÐKZÊíÐvïÐ`²Ñ ô¡
 ¬¡
ûÕÓR- ¾ ÄÅËüæ
_¬¬¹ ¯Â¿° ¿±—6¿àAáš1&0ÕÓtˆ­Ò
°Ñë°Ñó ü¥˜üº
üã 
$
„t4 ða ðÐr ü! \
,  
$
Ús 4
,– š œž 
Œž
ÀðÐ ,
 « 

»  
 ° 
m
uܺ
ërðÐ  ¥ » Ë
Ó¤¥ÔÑÞñö ¼ ÂÃÍü‰º­Ò–´­ÒV°ÑU°Ñ^ïÖWïÖ` [–´\öõ–´ö´´u
ü$ü‘"Œ’,’0 ÛÚ ²R_ º»ÎüÀû­Ò°Ñ­Ò…ܵ ²ÑƒÝ¾ž.R<“"²Ñ Ÿ" "ÐüÛ!E°ÑLÿ!­Ò,õ!°Ñd6œé&$é&#
*dî&
ÐÕÓ5tî&Q û&Ìé&
 ý&
ÚsðЈ,ý& ' ‡'ˆ'Ñü¾&J,Ù&­Ò,Ï&°ÑÚ°Ñâ­ÒÜ#Eœ±+$±+#
*d¶+ìÞ/t¶+K Ã+ô±+
 DÅ+
ÛsðÐTÅ+ Î+ Ô+Õ+Òü‚+S$¢+­Ò,˜+°ÑÓ°ÑÛ­ÒÕ#Dü½F3œÜF$ÜF#
*dáFìÞ/táFK îFi
pô½F
Ρƒ˜ ïF õFöFÝüØEž ÄÄŠLjÀ Hr)¡>
Æãl÷E­Ò,íEœä&°Ñ&°Ñ/­Ò*/ˆüú*#üü*! Œý*Dý*§ ïíe¼îËè¿*
°æP
W4†+
ªˆæhD†+  ˆæ +¬Ææ œ+ÌÙ ¤+¥+Äü ˆæ<¤* ½½õ6¿Â¿ÛO÷N©~.\°æD—*·ç^Ææ^Ææg ˆæcÚåd: ¿Pù‘Ñ ŽÝAN[ Ý ÁP¼¬P
 ”¬P
û‘Ñœ- ÂP ÈPÉPùü‡PB¬¬¹ ¯Â¿° ¿±—6¿àAáš1&0‘Ñ$P²é+öè4öè=øèÀPöèPŽ ŽÝrùÇöèøè`­´ÖQ\ÖQ½½õ6¿Â¿ÛO÷N©~.\ŽÝV
]DâQ
ÄŽÝhTâQ ëQäÖQ
 íQ
ÚsŽÝ»,íQ ñQ ÷QøQúü¥QS,ÆQ Ÿê,¼Q²é²é ¨ì)N ,Ö]üþ] œþ],þ]6 ÝG œ^üç]7

´ç]
žÝ~, ^  ^üÅ^…,ï^ ½ŽÝ É_\á_  ŽÝ\ƒ`

 ŽÝüª^ï ¬‘Ñ 
˜`
  ž`Ÿ`ûü‘\ŽüÒ]Í Ÿê$Ã\²é,«\§ ïíe¼îËè¿*ÝÑ“ïÒ“ïÛ Ýײòà¨ìXéñWëµFu\»ŸŽÝTëµFu\»ŸâðgžÛžüüm‚
ü¥n t¥n,¥n
$4«nÂÖ/D«n ²n\ ŽÝm ÃnüÒn!\Òn ,Òn


$ØnÁ×
/ ,Øn Ün
ψn 
Έn
ÀŽÝ ,  ¦      òn  c
kÜüm
ërŽÝwýš ýnüém–
 ”ém×éÕ( þn „o…oýüËlº
Ÿê$ˆm–´,ôl²é.²é7Ùô0Ùô9èÚ3–´4ÓÒ–´Óó´k,‡}´š}\š}¨ì"
)D¦}íì4T¦}J ¯} °}üº} ,Ô}
%̺}
ΑÑ6GK Ù} ß}à}þüË|•üƒ}] ÅÛlë|ƒî,á|²é²é ¢î!Œû˲éÊ6žXrÄÀ   Á  É 9
@ 
¥ÒN  × ­ ± µ ¹  Ø   è 

ì   ð   A 
  ò   
”â  ²
 ó  ù ú šüó ü¨ R
¾á$™  B3$ÜÜÛ11&®u0ÁÇu1Á¾u2Áµ_u3Á­ã PPÐ4 2 ²
 hPÝŸ(PüP„ øP` (P‡P‡    PŸ: xP«
0P³    
 )Ÿ7 
AŸ S  i
p8P«
š }
Ž  HPŸŸ 'ŸØPŸ
f
  0PÌ& (LøPT àç
ï » ø—` <B0Pî Æ
øPõøP̲øPø~¾áŸHP´ŸPLJE¾áE¢€FìÎxÉȾጊ¯&.5arrÁ  ç´,Ÿ
ŸŸ|ŸˆŸøœ.°œ
 œ
À. œ·
œ·
À.oœÊ
 øœ{;Aøl

àW6ƒ¸ 3Æ Vœ)&üjˆ°œŸ
  œŸªŠ#МÈ ${ _ }Áõ
øœÚ"
 МÚ
ƒÑL,œûœŠÉ øœsÀ8 ¶Ï´ÖŸ<¾
Öøœ¥ 
 Àœ¥
­É?,œÄœÓÊ øœæmÅ8ËŽÖ9˜œëë

&ñ
ýÐ4ñœýÈœæ  œþœË øœ m¶Ï œÏºÖÅ»C Ðøœ,øœ¡ œ¢:  œÀÝŸ©éü© ø©`
© 
  ©Ÿ=  «
³ ©· 
 
 +Ÿ9 
CŸ U  l
s«
Ë  
©¹ ©¦
ŸŸ (ŸØ©Ÿ
j
©º
 Ì©Ñ( )Nø©T
àø
 É ø™` <B©àî©ý
©þÌ ø©õø©Ì²ø©ø¶ÏŸ´Ÿ©ð˜}¶Ï|Öz é~ãá¶Ï£¡Ÿ°!Öˆ»/7>û‡ž ´šAŸŸ)ŸŸŸ°œ§
  œ§ªŠ#М¥Ð ${ _ }Á­œ1
 €­œ1ªŠ#°­š1Ó ${ _ }Á­ü2
 €­ü2ªŠ#°­ú2× ${ _ }Á­€7
 €­€7ªŠ#°­þ6Ü ${ _ }Áx­ì7­ì7

&X­î7á1î7­ú7à­à7  ­û7­Š8Ý ø­¤7f¶Ï ­É7­¼7ÖÁ¾ÁC
®™,Ÿ,
Ÿ,
 ®¥,Á×7¥,®©,ø®¦-3ø®¦-.ª-
ª-à ®´-;®¸-e®Å-
Å-Ë-à 1 A
@à ®Ð-æ®Ó-®Ø-''ø®ó-, ø®ü-!
—. 
 "
)Юü-
Í 9
LP 
®œ. ø®ð-0 Ö¿ ÄÄŠLjÀ Hr)¡>
Æ– ®Ÿ. ®±.
ø®£-á ø®Ò.Ÿ ®×/


! óø°ˆ/5ƒ¸
®ð/
ø®Î.¤ Ö¿¯¤Æ– ®ñ/  ®ƒ0®‘0®’0ß ø®¾+Ôø®•,ýØÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
¯¤Æ–¸®ë+–´Ú+Ö´Âxuq
¯¤c¯¤a–´_Æ–Œˆ´q6 Àà \à hà ®Ò,
 €®Ò,ªŠ#ø®¼,)à Ê,)±œ1
 €±œ1ÜŠ#°±š1â ${ _ }Á±ü2
 €±ü2ÜŠ#°±ú2æ ${ _ }Á±€7
 €±€7ÜŠ#°±þ6ë ${ _ }Áì7±ì7

&î7
§É4î7±ú7à±à7  ±û7±Š8ì ø±¤7f¶Ï ±É7±¼7ÖÄÁÁC
²™,Ÿ,
Ÿ,
 ²¥,Á×7¥,²©,ø²¦-3ø²¦-.ª-
ª-ï ²´-;²¸-e²Å-
Å-Ë-ï 1 A
@ï ²Ð-æ²Ó-²Ø-''ø²ó-, ø²ü-!
—. 
 "
)вü-
Í 9
LP 
²œ. ø²ð-0 Ö¿ ÄÄŠLjÀ Hr)¡>
Æ– ²Ÿ. ²±.
ø²£-á ø²Ò.Ÿ ²×/


! óø´ˆ/5ƒ¸
²ð/
ø²Î.¤ Ö¿¡²Æ– ²ñ/  ²ƒ0²‘0²’0î ø²¾+Ôø²•,ýØÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
¡²Æ–¸²ë+–´Ú+Ö´Âxuq
¡²c¡²a–´_Æ–Œˆ´q6 Àï \ï hï ²Ò,
 €²Ò,ÜŠ#ø²¼,)ï Ê,)
øµ.°µ
 µ
À. µ·
µ·
À.oµÊ
øµÑ-°µÑ
 µÑ…¸)˜µë
ˆµë
À.j{µý
 
øµ{AGY ðöo ø¶l
ñ‹˜^ƒ¸£4ð wµéæ¼b_:ƒÁ°µŸ
  µŸ…¸#еò ${ _ }Áõ
ýÿøµÚ"
 еÚ
«Ò?,µûµŠó øµsì8 ùÏ´ýÿ<¾
ýÿøµ¥ 
 Àµ¥
ÏÊ?,µÄµÓô øµæmñ8ñ½ýÿ9
ýÿøµƒ
 ¸µƒ
Ä>+µ¡µ´õ øµÆnö8ñ½ÜýÿŽ9˜µëë

&ñþü1ñµýȵæ  µþµö øµ mùÏ µÏºýÿ¿»C Ðøµ,øµ¡ µ¢:  µÀÝŸÅéüÅ øÅ`
Å 
  ÅŸ=  «
³ Å· 
 
 +Ÿ9 
CŸ U  l
s«
ö  
Ź Ŧ
ŸŸ (ŸØÅŸ
j
ź
 ÌÅÑ( )NøÅT
àø
 É ø›` <BÅàîÅý
Åþ÷ øÅõøÅ̲øÅøùÏŸ´ŸÅÁÉ}ùÏ|ýÿz é~ãáùÏ£¡Ÿ°!Öˆ»/7>û‡ž ´šAŸŸ)ŸŸŸ°µ§
  µ§…¸#е¥û ${ _ }ÁÉœ1
 €Éœ1…¸#°Éš1þ ${ _ }ÁÉü2
 €Éü2…¸#°Éú2 ${ _ }ÁÉ€7
 €É€7…¸#°Éþ6 ${ _ }Áì7Éì7

&î7þü1î7Éú7àÉà7  Éû7ÉŠ8ˆ øÉ¤7fùÏ ÉÉ7ɼ7ýÿÁ¾ÁC
Ê™,Ÿ,
Ÿ,
 Ê¥,Á×7¥,Ê©,øÊ¦-3øÊ¦-.ª-
ª- Ê´-;ʸ-eÊÅ-
Å-Ë- 1 A
@ ÊÐ-æÊÓ-ÊØ-''øÊó-, øÊü-!
—. 
 "
)ÐÊü-
Í 9
LP 
Êœ. øÊð-0 Ö¿ ÄÄŠLjÀ Hr)¡>
Ɩ ʟ. ʱ.
øÊ£-á øÊÒ.Ÿ Ê×/


! óøÌˆ/5ƒ¸
Êð/
øÊÎ.¤ Ö¿€ÕÆ– Êñ/  ʃ0Ê‘0Ê’0Š øÊ¾+ÔøÊ•,ýØÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
€ÕÆ–¸Êë+–´Ú+Ö´Âxuq
€Õc€Õa–´_Æ–Œˆ´q6 À \ h ÊÒ,
 €ÊÒ,…¸#øÊ¼,) Ê,)Íœ1
 €Íœ1·¸#°Íš1 ${ _ }ÁÍü2
 €Íü2·¸#°Íú2 ${ _ }ÁÍ€7
 €Í€7·¸#°Íþ6 ${ _ }Áì7Íì7

&î7
ÉÊ4î7Íú7àÍà7  Íû7ÍŠ8 øÍ¤7fùÏ ÍÉ7ͼ7ýÿÄÁÁC
Ι,Ÿ,
Ÿ,
 Î¥,Á×7¥,Ω,øÎ¦-3øÎ¦-.ª-
ª-š δ-;θ-eÎÅ-
Å-Ë-š 1 A
@š ÎÐ-æÎÓ-ÎØ-''øÎó-, øÎü-!
—. 
 "
)ÐÎü-
Í 9
LP 
Μ. øÎð-0 Ö¿ ÄÄŠLjÀ Hr)¡>
Ɩ Ο. α.
øÎ£-á øÎÒ.Ÿ Î×/


! óøÐˆ/5ƒ¸
Îð/
øÎÎ.¤ Ö¿òâÆ– Îñ/  ΃0Α0Î’0 øÎ¾+ÔøÎ•,ýØÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
òâÆ–¸Îë+–´Ú+Ö´Âxuq
òâcòâa–´_Æ–Œˆ´q6 Àš \š hš ÎÒ,
 €ÎÒ,·¸#øÎ¼,)š Ê,)Ñœ1
 €Ñœ1й#°Ñš1œ ${ _ }ÁÑü2
 €Ñü2й#°Ñú2  ${ _ }ÁÑ€7
 €Ñ€7й#°Ñþ6¥ ${ _ }Áì7Ñì7

&î7
¾3î7Ñú7àÑà7  Ñû7ÑŠ8¦ øÑ¤7fùÏ ÑÉ7Ѽ7ýÿÃÀÁC
Ò™,Ÿ,
Ÿ,
 Ò¥,Á×7¥,Ò©,øÒ¦-3øÒ¦-.ª-
ª-© Ò´-;Ò¸-eÒÅ-
Å-Ë-© 1 A
@© ÒÐ-æÒÓ-ÒØ-''øÒó-, øÒü-!
—. 
 "
)ÐÒü-
Í 9
LP 
Òœ. øÒð-0 Ö¿ ÄÄŠLjÀ Hr)¡>
Æ– ÒŸ. Ò±.
øÒ£-á øÒÒ.Ÿ Ò×/


! óøÔˆ/5 ƒ¸
Òð/
øÒÎ.¤ Ö¿ãðÆ– Òñ/  Òƒ0Ò‘0Ò’0¨ øÒ¾+ÔøÒ•,ýØÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
ãðÆ–¸Òë+–´Ú+Ö´Âxuq
ãðcãða–´_Æ–Œˆ´q6 À© \© h© ÒÒ,
 €ÒÒ,й#øÒ¼,)© Ê,)
øÕ.°Õ
 Õ
À. Õ·
Õ·
À.oÕÊ
øÕÑ-°ÕÑ
 ÕÑÇö)˜Õë
ˆÕë
À.j{Õý
Ö Ö
øÕ{AG6 ðö±6 øÖl
ñ‹Ú6
^ƒ¸å64ª wÕéæ¼b_:ƒÁ°ÕŸ
  ÕŸÇö#ÐÕ¬ ${ _ }Áõ
øÕÚ"
 ÐÕÚ
ÓÓL,ÕûÕŠ­ øÕs9    ¡l˜ ˆ dãÉfKx+o´ËûØu¾
ËûøÕ¥ 
 ÀÕ¥
ñË?,ÕÄÕÓ® øÕæm¢9ÀüËû9
ËûøÕƒ
 ¸Õƒ
Î>+Õ¡Õ´¯ øÕÆn§9ÀüÜËûŽ9˜Õëë

&ñ
ÍÓ4ñÕýÈÕæ  ÕþÕ° øÕ mÂü ÕϺËûÅ»C ÐøÕ,øÕ¡ Õ¢:  ÕÀÝŸåéüå øå`
å 
  åŸ=  «
³ å· 
 
 +Ÿ9 
CŸ U  l
s«
°  
å¹ å¦
ŸŸ (ŸØåŸ
j
åº
 ÌåÑ( )NøåT
àø
 É ø` <Båàîåý
åþ± øåõøå̲øåøÂüŸ´Ÿå̈}Âü|Ëûz é~ãáÂü£¡Ÿ°!Öˆ»/7>û‡ž ´šAŸŸ)ŸŸŸ°Õ§
  Õ§Çö#ÐÕ¥µ ${ _ }Áéœ1
 €éœ1Çö#°éš1¸ ${ _ }Áéü2
 €éü2Çö#°éú2¼ ${ _ }Áé€7
 €é€7Çö#°éþ6Á ${ _ }Áì7éì7

&î7½€1î7éú7àéà7  éû7éŠ8 øé¤7fÂü éÉ7é¼7ËûÁ¾ÁC
ê™,Ÿ,
Ÿ,
 ê¥,Á×7¥,ê©,øê¦-3øê¦-.ª-
ª-Å ê´-;ê¸-eêÅ-
Å-Ë-Å 1 A
@Å êÐ-æêÓ-êØ-''øêó-, øêü-!
—. 
 "
)Ðêü-
Í 9
LP 
êœ. øêð-0 Ö¿ ÄÄŠLjÀ Hr)¡>
Æ– êŸ. ê±.
øê£-á øêÒ.Ÿ ê×/


! óøìˆ/5 ƒ¸
êð/
øêÎ.¤ Ö¿‹”Æ– êñ/  êƒ0ê‘0ê’0Ä øê¾+Ôøê•,ýØÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
‹”Æ–¸êë+–´Ú+Ö´Âxuq
‹”c‹”a–´_Æ–Œˆ´q6 ÀÅ \Å hÅ êÒ,
 €êÒ,Çö#øê¼,)Å Ê,)íœ1
 €íœ1ùö#°íš1Ç ${ _ }Áíü2
 €íü2ùö#°íú2Ë ${ _ }Áí€7
 €í€7ùö#°íþ6Ð ${ _ }Áì7íì7

&î7
ëË4î7íú7àíà7  íû7íŠ8Ñ øí¤7fÂü íÉ7í¼7ËûÄÁÁC
î™,Ÿ,
Ÿ,
 î¥,Á×7¥,î©,øî¦-3øî¦-.ª-
ª-Ô î´-;î¸-eîÅ-
Å-Ë-Ô 1 A
@Ô îÐ-æîÓ-îØ-''øîó-, øîü-!
—. 
 "
)Ðîü-
Í 9
LP 
îœ. øîð-0 Ö¿ ÄÄŠLjÀ Hr)¡>
Æ– îŸ. î±.
øî£-á øîÒ.Ÿ î×/


! óøðˆ/5 ƒ¸
îð/
øîÎ.¤ Ö¿ý¡Æ– îñ/  îƒ0î‘0î’0Ó øî¾+Ôøî•,ýØÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
ý¡Æ–¸îë+–´Ú+Ö´Âxuq
ý¡cý¡a–´_Æ–Œˆ´q6 ÀÔ \Ô hÔ îÒ,
 €îÒ,ùö#øî¼,)Ô Ê,)ñœ1
 €ñœ1’ø#°ñš1Ö ${ _ }Áñü2
 €ñü2’ø#°ñú2Ú ${ _ }Áñ€7
 €ñ€7’ø#°ñþ6ß ${ _ }Áì7ñì7

&î7
È3î7ñú7àñà7  ñû7ñŠ8à øñ¤7fÂü ñÉ7ñ¼7ËûÃÀÁC
ò™,Ÿ,
Ÿ,
 ò¥,Á×7¥,ò©,øò¦-3øò¦-.ª-
ª-ã ò´-;ò¸-eòÅ-
Å-Ë-ã 1 A
@ã òÐ-æòÓ-òØ-''øòó-, øòü-!
—. 
 "
)Ðòü-
Í 9
LP 
òœ. øòð-0 Ö¿ ÄÄŠLjÀ Hr)¡>
Æ– òŸ. ò±.
øò£-á øòÒ.Ÿ ò×/


! óøôˆ/5
ƒ¸
òð/
øòÎ.¤ Ö¿î¯Æ– òñ/  òƒ0ò‘0ò’0â øò¾+Ôøò•,ýØÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
î¯Æ–¸òë+–´Ú+Ö´Âxuq
î¯cî¯a–´_Æ–Œˆ´q6 Àã \ã hã òÒ,
 €òÒ,’ø#øò¼,)ã Ê,)øõ.°õ
 õ
À. õ·
õ·
À.oõÊ
ö öøõ{;Aøöl
ñ‹¦U8ƒ¸±U4ä Wõ*'ýk°õŸ
  õŸÒµ#Ðõæ ${ _ }Áõ
øõÚ"
 ÐõÚ
ûÔL,õûõŠç øõs$Î9    ¡l˜ ˆ dãÉfKx+o´ÿ¸Øu¾
ÿ¸øõ¥ 
 Àõ¥
“Í?,õÄõÓè øõæm$Ô9ô¹ÿ¸9˜õëë

&ñ
õÔ4ñõýÈõæ  õþõé øõ mö¹ õϺÿ¸Å»C P‚Ðøõ,øõ¡ õ¢:  õÀh‚ÝŸé(‚ü ø‚`
(‚ 
  Ÿ=  x«
0‚³ · 
 
 +Ÿ9 
CŸ U  l
s8«
é  
¹ ¦
H‚ŸŸ (ŸØ‚Ÿ
j
º
 0‚ÌÑ( )Nø‚T
Ÿàø
 É øŸ` <Bà0‚îý
þê ø‚õø‚̲ø‚øö¹ŸH‚´ŸÒÄ}ö¹|ÿ¸z é~ãáö¹£¡Ÿ°!Öˆ»/7>û‡ž ´šAŸŸ)ŸŸŸ°õ§
  õ§Òµ#Ðõ¥î ${ _ }Áœ1
 €†œ1Òµ#°†š1ñ ${ _ }Áü2
 €†ü2Òµ#°†ú2õ ${ _ }Á€7
 €†€7Òµ#°†þ6ú ${ _ }Áx†ì7ì7

&X†î7ü1h†î7ú7à†à7  û7Š8û ø†¤7fö¹É7¼7ÿ¸Á¾ÁC
™,(‡Ÿ,
X‡Ÿ,
 ¥,Á×7(‡¥,©,ø‡¦-3ø‡¦-.X‡ª-
0‡ª-þ ´-;¸-eÅ-
`‡Å-0‡Ë-þ 1 A
@þ Ð-æÓ-Ø-''ø‡ó-, ø‡ü-!
(‡—. 
 "
)Їü-
Í 9
LP 
œ. ø‡ð-0 Ö¿ ÄÄŠLjÀ Hr)¡>
Æ– Ÿ. ±.
ø‡£-á ø‡Ò.Ÿ ×/


! óø‰ˆ/5ƒ¸
ð/
ø‡Î.¤ Ö¿‘ÐÆ– ñ/  ƒ0‘0’0ý ø‡¾+Ôø‡•,ýØÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
‘ÐÆ–¸‡ë+–´(‡Ú+Ö´Âxuq
‘Ðc‘Ða–´_Æ–Œˆ´q6 Àþ \þ hþ Ò,
 €‡Ò,Òµ#ø‡¼,)þ (‡Ê,)Šœ1
 €Šœ1„¶#°Šš1
${ _ }ÁŠü2
 €Šü2„¶#°Šú2
${ _ }ÁŠ€7
 €Š€7„¶#°Šþ6
${ _ }Áì7Šì7

&î7
Í4î7Šú7àŠà7  Šû7ŠŠ8Š
øŠ¤7fö¹ ŠÉ7м7ÿ¸ÄÁÁC
™,(‹Ÿ,
XŸ,
 ¥,Á×7(‹¥,©,ø‹¦-3ø‹¦-.Xª-
0ª-
´-;¸-eÅ-
`‹Å-0Ë-
1 A
@
Ð-æÓ-Ø-''ø‹ó-, ø‹ü-!
(—. 
 "
)Ћü-
Í 9
LP 
œ. ø‹ð-0 Ö¿ ÄÄŠLjÀ Hr)¡>
Æ– Ÿ. ±.
ø‹£-á ø‹Ò.Ÿ ×/


! óøˆ/5ƒ¸
ð/
ø‹Î.¤ Ö¿ƒÞÆ– ñ/  ƒ0‘0’0Œ
ø‹¾+Ôø‹•,ýØÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
ƒÞÆ–¸‹ë+–´(‹Ú+Ö´Âxuq
ƒÞcƒÞa–´_Æ–Œˆ´q6 À
\
h
Ò,
 €‹Ò,„¶#ø‹¼,)
(Ê,)
Ž™,Ÿ,
Ÿ,
 Ž¥,Á×7¥,Ž©,øŽ¦-3øŽ¦-.ª-
ª-
Ž´-;ޏ-eŽÅ-
Å-Ë-
1 A
@
ŽÐ-æŽÓ-ŽØ-''øŽó-, øŽü-!
—. 
 "
)ÐŽü-
Í 9
LP 
Žœ. øŽð-0 Ö¿ ÄÄŠLjÀ Hr)¡>
Æ– ŽŸ. ޱ.
øŽ£-á øŽÒ.Ÿ Ž×/


! óøˆ/5ƒ¸
Žð/
øŽÎ.¤ Ö¿ÚçÆ– Žñ/  Žƒ0Ž‘0Ž’0
øŽ¾+ÔøŽ•,ýØÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
ÚçÆ–¸Žë+–´Ú+Ö´Âxuq
ÚçcÚça–´_Æ–Œˆ´q6 À
\
h
ŽÒ,
 €ŽÒ,ª¹#øŽ¼,)
Ê,)4ôH $õHüÑH*¼<êH3
™,(‘Ÿ,
XŸ,
 ¥,Á×7(‘¥,©,ø‘¦-3ø‘¦-.Xª-
0ª-
´-;¸-eÅ-
`‘Å-0‘Ë-
1 A
@
Ð-æÓ-Ø-''ø‘ó-, ø‘ü-!
(—. 
 "
)Бü-
Í 8
KO 
œ. ø‘ð-0 Ö¿ ÄÄŠLjÀ Hr)¡>
Æ– Ÿ. ±.
ø‘£-á ø‘Ò.Ÿ ×/


! óø“ˆ/5ƒ¸
ð/
ø‘Î.¤ Ö¿¼òÆ– ñ/  ƒ0‘0’0
ø‘¾+Ôø‘•,ýØÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
¼òÆ–¸‘ë+–´(‘Ú+Á–´Àvso¼òa¼ò_–´]Æ–Œˆ´q4 ¾
Z
f
Ò,
 €‘Ò,
À'ø‘¼,)
(Ê,)
™,(”Ÿ,
X”Ÿ,
 ¥,Á×7(”¥,©,ø”¦-3ø”¦-.X”ª-
0ӻ-
´-;¸-eÅ-
`”Å-0”Ë-
1 A
@
Ð-æÓ-Ø-''ø”ó-, ø”ü-!
(”—. 
 "
)Дü-
Í 9
LP 
œ. ø”ð-0 Ö¿ ÄÄŠLjÀ Hr)¡>
Æ– Ÿ. ±.
ø”£-á ø”Ò.Ÿ ×/


! óø–ˆ/5ƒ¸
ð/
ø”Î.¤ Ö¿–üÆ– ñ/  ƒ0‘0’0
ø”¾+Ôø”•,ýØÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
–üÆ–¸”ë+–´(”Ú+Ö´Âxuq
–üc–üa–´_Æ–Œˆ´q6 À
\
h
Ò,
 €”Ò,
À(ø”¼,)
(”Ê,) 

%¾Ò1Æ–9@üè+1 â‘Ñ—Ñ#ã0üÌ<½ÍDKDÄ- è‘Ñ—Ñ"í/½Í;ýÍCJô¢
 ÄÕÓÅ)ÛÚ5²Ñ=DüŽf& ©
‘Ѫ
,©
©
ª
œf­
ˆÀ ›T†É\sû¸‘ÑlÄlÄlIterÁÇlµ ™lÈl
end_or_lenÁ™lÉl_markerÁ™lŒœjSžŽÝÑØ”ï  ²
³
%¾á1¢€9@üÛE Ì
ÇBûä#Í
0Ãä<

eœ
Úò
ñ$òÍ}Õ!cü˜èàåûäÄŠ& ƒ%®å18?ü¾0* à
°æŸ#á
0ÿæ<Û¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zٰ漩 Ó°æÔ,øè8>ÑÛÑÛ MaybeUninitÁÓÛuninitÁÝÔÛ»ÝÍõƒ«%9°æœü“$+ ò°æ#ó0Îê<ëµFu\»Ÿ°ækqàåyü‹&  Ÿ ,Áì8úí@Gø—¥' 
Ø÷Þ÷&˜
3Ÿ÷?Ø÷GÞ÷OVø™¥' Á
Ø÷Þ÷œù-Â
:ÒøFØ÷NÞ÷Vœù^eø›¥' ö
Ø÷Þ÷œùêú4÷
A“úMØ÷UÞ÷]œùeêúmtø¥' Ø÷Þ÷œùêúÉü;·HäûTØ÷\Þ÷dœùlêútÉü|ƒøŸ¥' Ø÷Þ÷œùêúÉü¸þBOÆý[Ø÷cÞ÷kœùsêú{Éüƒ¸þX¿Îö  ¢ íÅ<Lß²é.<Ÿ¹†Bœ˜èùTßN
Ù
dËP¼)TÞP✠¼)㜠 L„QÄž  ¹ <Q¬Ÿ make_uleÁD…|¹º make_varuleÁ\Ó£º» ü²¬«ü™MJ Zero-copy vector abstractions for arbitrary types, backed by byte slices.Áçúüëif `zerovec` enables a far wider range of types — beyond just `&[u8]` and `&str` — to participate inÁüÕ`] zero-copy deserialization from byte slices. It is `serde` compatible and comes equipped withÁ proc macrosÁÆúüÊXU Clients upgrading to `zerovec` benefit from zero heap allocations when deserializingÁœ£ read-only data.Á·úü»# This crate has four main types:Áßúüã[X - [`ZeroVec<'a, T>`] (and [`ZeroSlice<T>`](ZeroSlice)) for fixed-width types like `u32`Áü¿da - [`VarZeroVec<'a, T>`] (and [`VarZeroSlice<T>`](ZeroSlice)) for variable-width types like `str`Áü¤ 2/ - [`ZeroMap<'a, K, V>`] to map from `K` to `V`Áü× IF - [`ZeroMap2d<'a, K0, K1, V>`] to map from the pair `(K0, K1)` to `V`Á¡
úü¥
wt The first two are intended as close-to-drop-in replacements for `Vec<T>` in Serde structs. The third and fourth areÁü  intended as a replacement for `HashMap` or [`LiteMap`](https://docs.rs/litemap). When used with Serde derives, **be sure to applyÁü£ NK `#[serde(borrow)]` to these types**, same as one would for [`Cow<'a, T>`].Áò úüö vs [`ZeroVec<'a, T>`], [`VarZeroVec<'a, T>`], [`ZeroMap<'a, K, V>`], and [`ZeroMap2d<'a, K0, K1, V>`] all behave likeÁüí
li [`Cow<'a, T>`] in that they abstract over either borrowed or owned data. When performing deserializationÁüÚŒ from human-readable formats (like `json` and `xml`), typically these types will allocate and fully own their data, whereas if deserializingÁüê from binary formats like `bincode` and `postcard`, these types will borrow data directly from the buffer being deserialized from,Áüð avoiding allocations and only performing validity checks. As such, this crate can be pretty fast (see [below](#Performance) for more information)Á¼† on deserialization.Ážúü¢ See [the design doc](https://github.com/unicode-org/icu4x/blob/main/utils/zerovec/design_doc.md) for details on how this crateÁÌ¥ works under the hood.Á¿ú¤Ã # Cargo featuresÁØúüÜ30 This crate has several optional Cargo features:Áüro - `serde`: Allows serializing and deserializing `zerovec`'s abstractions via [`serde`](https://docs.rs/serde)Áüƒyv - `yoke`: Enables implementations of `Yokeable` from the [`yoke`](https://docs.rs/yoke/) crate, which is also usefulÁüýB? in situations involving a lot of zero-copy deserialization.ÁüÀ| - `derive`: Makes it easier to use custom types in these collections by providing the [`#[make_ule]`](crate::make_ule) andÁüÀro [`#[make_varule]`](crate::make_varule) proc macros, which generate appropriate [`ULE`](crate::ule::ULE) andÁü³QN [`VarULE`](crate::ule::VarULE)-conformant types for a given "normal" type.Áü…ƒ - `std`: Enabled `std::Error` implementations for error types. This crate is by default `no_std` with a dependency on `alloc`.Áúü [`ZeroVec<'a, T>`]: ZeroVecÁü­%" [`VarZeroVec<'a, T>`]: VarZeroVecÁüÓ" [`ZeroMap<'a, K, V>`]: ZeroMapÁüö+( [`ZeroMap2d<'a, K0, K1, V>`]: ZeroMap2dÁü¢&# [`Cow<'a, T>`]: alloc::borrow::CowÁÉú # ExamplesÁÜúüàXU Serialize and deserialize a struct with [`ZeroVec`] and [`VarZeroVec`] with Bincode:Á¹ú ```ÁüÅ! # #[cfg(feature = "serde")] {Áüç'$ use zerovec::{VarZeroVec, ZeroVec};Áúü“0- // This example requires the "serde" featureÁüÄ30 #[derive(serde::Serialize, serde::Deserialize)]Áüø" pub struct DataStruct<'data> {ÁÄ› #[serde(borrow)]Áü´" nums: ZeroVec<'data, u32>,ÁÄ××µüð$! chars: ZeroVec<'data, char>,Áĕ׵ü®%" strs: VarZeroVec<'data, str>,ÁÚúÜÞ let data = DataStruct {ÁüúB? nums: ZeroVec::from_slice_or_alloc(&[211, 281, 421, 461]),Áü½ @= chars: ZeroVec::alloc_from_slice(&['ö', '冇', 'म']),Áüþ 41 strs: VarZeroVec::from(&["hello", "world"]),Á4³! };Á¼º! let bincode_bytes =ÁüÒ!OL bincode::serialize(&data).expect("Serialization should be successful");Áü¢"(% assert_eq!(bincode_bytes.len(), 63);ÁË"úüÏ"GD let deserialized: DataStruct = bincode::deserialize(&bincode_bytes)Áü—#85 .expect("Deserialization should be successful");ÁüÐ#52 assert_eq!(deserialized.nums.first(), Some(211));Áü†$74 assert_eq!(deserialized.chars.get(1), Some('冇'));Áü¾$85 assert_eq!(deserialized.strs.get(1), Some("world"));Áü÷$;8 // The deserialization will not have allocated anythingÁü³%+( assert!(!deserialized.nums.is_owned());Áäß% # } // feature = "serde"Á<ü%
d: u8Á,ê)›·ð)úüô)74 // custom variable sized VarULE type for VarZeroVecÁü¬*&# #[zerovec::make_varule(PersonULE)]ÁüÓ*NK #[zerovec::derive(Serialize, Deserialize)] // add Serde impls to PersonULEÁü¢+ZW #[derive(Clone, PartialEq, Eq, Ord, PartialOrd, serde::Serialize, serde::Deserialize)]Á¼ý+ struct Person<'a> {Á¼•, birthday: Date,Áü­,! favorite_character: char,ÁÄÏ,×µÜè, name: Cow<'a, str>,Á,„-›·Š-úüŽ-3ï´¬Â- struct Data<'a> {ÁÄØ-×µüñ-+( important_dates: ZeroVec<'a, Date>,Áü.GD // note: VarZeroVec always must reference the ULE type directlyÁÄå.×µüþ.41 important_people: VarZeroVec<'a, PersonULE>,Áij/×µüÌ/96 birthdays_to_people: ZeroMap<'a, Date, PersonULE>Á,†0›·Œ0ú0úÔ”0 let person1 = Person {Áü¯0.+ birthday: Date { y: 1990, m: 9, d: 7},ÁüÞ0! favorite_character: 'Ï€',Áü€1 name: Cow::from("Kate")Á4 1­¹Ô§1 let person2 = Person {ÁüÂ1/, birthday: Date { y: 1960, m: 5, d: 25},Áüò1" favorite_character: '冇',Áü•2  name: Cow::from("Jesse")Á4¶2­¹½2úüÁ2 let important_dates = ZeroVec::alloc_from_slice(&[Date { y: 1943, m: 3, d: 20}, Date { y: 1976, m: 8, d: 2}, Date { y: 1998, m: 2, d: 15}]);ÁüÒ3C@ let important_people = VarZeroVec::from(&[&person1, &person2]);Áü–4KH let mut birthdays_to_people: ZeroMap<Date, PersonULE> = ZeroMap::new();Áüâ4ZW // `.insert_var_v()` is slightly more convenient over `.insert()` for custom ULE typesÁü½5B? birthdays_to_people.insert_var_v(&person1.birthday, &person1);Áü€6B? birthdays_to_people.insert_var_v(&person2.birthday, &person2);ÁÃ6úüÇ6OL let data = Data { important_dates, important_people, birthdays_to_people };Á—7úü›71. let bincode_bytes = bincode::serialize(&data)ÁüÍ763 .expect("Serialization should be successful");Áü„8)& assert_eq!(bincode_bytes.len(), 160);Á®8úü²8A> let deserialized: Data = bincode::deserialize(&bincode_bytes)Áüô88Å»­9úü±9EB assert_eq!(deserialized.important_dates.get(0).unwrap().y, 1943);Áü÷9MJ assert_eq!(&deserialized.important_people.get(1).unwrap().name, "Jesse");ÁüÅ:LI assert_eq!(&deserialized.important_people.get(0).unwrap().name, "Kate");Áü’;_\ assert_eq!(&deserialized.birthdays_to_people.get(&person1.birthday).unwrap().name, "Kate");Áò;úüö;# } // feature = serde and deriveÁ<š<¼³¢<úŒ¦< # PerformanceÁ¸<úü¼<a^ `zerovec` is designed for fast deserialization from byte buffers with zero memory allocationsÁüž=JG while minimizing performance regressions for common vector operations.Áé=úüí=" Benchmark results on `x86_64`:Á>úü”>(% | Operation | `Vec<T>` | `zerovec` |ÁŒ½> |---|---|---|ÁüÏ><9 | Deserialize vec of 100 `u32` | 233.18 ns | 14.120 ns |ÁüŒ?TQ | Compute sum of vec of 100 `u32` (read every element) | 8.7472 ns | 10.775 ns |Áüá?HE | Binary search vec of 1000 `u32` 50 times | 442.80 ns | 472.51 ns |Áüª@B? | Deserialize vec of 100 strings | 7.3740 μs\* | 1.4495 μs |Áüí@VS | Count chars in vec of 100 strings (read every element) | 747.50 ns | 955.28 ns |ÁüÄAIF | Binary search vec of 500 strings 10 times | 466.09 ns | 790.33 ns |ÁŽBúü’BÝÚ \* *This result is reported for `Vec<String>`. However, Serde also supports deserializing to the partially-zero-copy `Vec<&str>`; this gives 1.8420 μs, much faster than `Vec<String>` but a bit slower than `zerovec`.*ÁðCúüôCEB | Operation | `HashMap<K,V>` | `LiteMap<K,V>` | `ZeroMap<K,V>` |Á¬ºD |---|---|---|---|ÁüÐD>; | Deserialize a small map | 2.72 μs | 1.28 μs | 480 ns |ÁüE=: | Deserialize a large map | 50.5 ms | 18.3 ms | 3.74 ms |ÁüÍEE
\) ¼)[)✠¼)l)㜠 [)Äž  ¹ Z)¬Ÿ ‹—R)¹º ¦—G)º» /*2*5*< K¤K
È>tܯ¢ò­óêW4ö¿êW¸Å׺ `ëµ ëµ r,¤é!
§ ZeroFromÁDÑ
 Õë4 áãÍϾÀL´ÌÄ™o”¯b”ÇMüë $üÜfc Copy-on-write type that efficiently represents [`VarULE`] types as their bitstream representation.ÁÃúüÇli The primary use case for [`VarULE`] types is the ability to store complex variable-length datastructuresÁü´B? inside variable-length collections like [`crate::VarZeroVec`].Á÷úüûfc Underlying this ability is the fact that [`VarULE`] types can be efficiently represented as a flatÁ bytestream.Áòúüöol In zero-copy cases, sometimes one wishes to unconditionally use this bytestream representation, for exampleÁüæqn to save stack size. A struct with five `Cow<'a, str>`s is not as stack-efficient as a single `Cow` containingÁüØSP the bytestream representation of, say, `Tuple5VarULE<str, str, str, str, str>`.Á¬ úü° mj This type helps in this case: It is logically a `Cow<'a, V>`, with some optimizations, that is guaranteedÁüž
@= to serialize as a byte stream in machine-readable scenarios.Áß
úüã
if During human-readable serialization, it will fall back to the serde impls on `V`, which ought to haveÁìÍ  a human-readable variant.Á ЧÎì¥É ¥ÉŠÜ×
ìÈž¡Òþ’]8ç 35”¿
¿


¥ÈJ<×


ëµFu\»ŸÁɤ’l™¥È :I§”ÜÜ£´üƒ"¥Èü©"¥ÈäÐ¥ÈÙ¼ó ¥È¥È ü
üî!/Чþö ÷!ìÈÙó!¼¤",§" ìÈìÈ ­"
Š¥É$®"üï#.Чþö ø#¿¥É4û#ìÈ !ô#$&üö$=ü¤$MJ Construct from a slice. Errors if the slice doesn't represent a valid `V`Á\ý$ ŠàåÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
ìÈÆ–
Хɴ,‰%ü§.Aü¿,A> Construct from a slice that is known to represent a valid `V`Á…-úd- # SafetyÁž-úü¦-GD `bytes` must be a valid `V`, i.e. it must successfully pass throughÁüò-0- `V::parse_bytes()` or `V::validate_bytes()`.Á¤».øüìÈ
Хɴ™üð6'ü¿6,) Construct a new borrowed version of thisÁd÷6ÁÉìÈ
!Хɹ„7üÜ=%Š#§$#$þö å=ìÈ%&'á=ô­>üˆ>  Whether or not this is ownedÁD´> ìÈ" ½>"
%Š¥É$¾>üŠ@üõ>,) Get the byte representation of this typeÁ¦?úü®?30 Is also always a valid `V` and can be passed toÁüæ? `V::from_bytes_unchecked()`ÁD@ ìÈ àå" š@"
&Š¥É$@üÙA4DéA¥ÈìÈ""
'Š¥É@Ïš”ÚC¥È)*ô¦DD­Dˆ ˆ¥È( ¶D(
)$·Dü‹FDF ¥È àå( ›F(
*$œFü†G8Š,§-,-þö GÔû4’GìÈ./ê!ë!/G%'\ÅG4ÊG++¥É¬ÚG,ÝGŠ ŠìÈ Š¥É+ ãG+
/Š¥É$äGüçH>Š1§221þö ðHÔû4óHìÈ3ë3ìH!ì¬I$¯IÁÉìÈ00
3Хɹ
,´Iü KJŠ5§656þö ©KÔû4¬K¿c¥ÉT¾KìÈ7Àc7¥K/1üñKCôKŒ ìÈ Œ c cˆ¢cµ
 `£c `àB¤GS
Ö¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
ŸÈŸÈ ÈErrorÁ O˜éBL4 øK4
7Š¥É$ùK± ÿKü¦MHŠ9§:9:þö ¯MÔû4²Mµß¥É¥ÉLÄMìÈ;·ß;«M57üõM"øMŽ ŽìÈ ìÈ8 ûM8
;Š¥É$üM¹
,NüÊN:Š=§>>=þö ÓNÔû4ÖN¥ÉèNìÈÏN&(ü‰OJŠ@§AA@þö ’OÔû4•OíߥɥÉT§OìÈBïßBŽO57üÚOB\ÝO ìÈ ìÈÛ¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙ¿ßÀßÁßLessÁÂßÃßÄß~Å߯ßÇßGreaterÁÈßåºÝÈnûê7? éO?
BŠ¥É$êO¹
,ðOüØP<ŠD§EDEþö áPÔû4äPº¥ÉöPìÈF»FÝP/1ü›Q2žQ ìÈ ìÈ“’C ¢QC
FŠ¥É$£Q¹
,©QüåSKŠH§IIHþö õSÔû4øSìÈJMN±´·MJNñS13ü·TIĺT ìÈ£G£KLKL ÖTGÍì§– ÓTÍ좖ÔàT–"¢– 
àå¬åT¢–‘—˜"§– ùT
JХɧ–¢–$×T ÝTüëU%”îU ìÈG VG
MŠ¥É$‚VüÊV.¤ÍV˜ ˜ìÈ àåG âVG
NŠ¥É$ãVdstÁéVüædBŠP§QPQþö ïdÔû4òdìÈR
Rëd ü½e"LÀeÁÉìÈOO
RХɹ
,ÊeüfVŠTU§VUVTÎìïÊ šf¿ïÊ4f¶ÊW
Wff,.üøf2Lûf ŠûʶÊSS
WŠïʹ
,…gtçLTëLòÙÙ
d‹µ¼)T™âœ ¼)㜠ºb¤Êø ·Ä`<öÐ ¹Ä`Ñ ¹¿a<ÿä º¿aå ºÊ_4ˆ¼ »Ê_½ »¾c„
¼Õ„¢`½µd¬€
¾Ì‚T‘`cÚÞâèø …
Ð Ñ ä å ¼ ½ µd¬ø
YZ¾®¿ßY\íðY]ëµY^ëµY^¹,…£Y_° ôY[£SDÞ øY[êSDð Y[È=ä °Y[÷V,¦4 µY[œW,ÝA ¹Y[©WTƒC ºY[êW4Öd ¿Y[È>tâ ¯Y[¢åET¡ Y[¥F|» Y[§ÈILÞ ÓY[©«Kdé òY[ªÈ=ºƒ ·Y[ÄêW4Œ† ¸Y[Åò­D›‡ óY[ëf<‰ ²
Y[¡œht Ì
Y[£²id­ à
Y[¦²iá
Y[¦¡l\‡  Y[«¡l Y[«äñWT“œ¦K´¿>ÌÛ1„úüú+üC@ This trait allows switching between different possible internalÁüÑ96 representations of [`VarZeroVec`](super::VarZeroVec).ÁúüYV Currently this crate supports three formats: [`Index8`], [`Index16`] and [`Index32`],ÁüéPM with [`Index16`] being the default for all [`VarZeroVec`](super::VarZeroVec)Áüº0- types unless explicitly specified otherwise.ÁëúüïLI Do not implement this trait, its internals may be changed in the future,Áü¼=: and all of its associated items are hidden from the docs.Á„„``Íì, î¨<`æ¨"ø¨æ¨.ø¨)ababÍìî¨a¼½c·©¯©Æ©Íìî¨b¬ê cê©â©ù©´½ü¬*' The type to use for the indexing arrayÁÛúüãB? Safety: must be a ULE for which all byte sequences are allowedÁ``¤ê üÙ*' The type to use for the length segmentÁˆ úü Bã©ï ``üö  T‡ ccÎìî¨üö Œ°î¨ cŠ­)­Š­5­)defghdefghghüé #  cc ŒË


cc¤¶ccüÄ î¨cc
gî¨üý-|€Û¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙî¨cc
hî¨Ã üÝ ¿ËjkabT„,‰iiD™žiiü«!ÚÌmoabll¶Ï ìùll¶Ï ü’!õÍrtab,¿qqùÏ ÓàqqùÏ òìùwxyz{defghz{ü#vvš®ŒÎvv¤ùLÿvvü² vv
zü‚!,|…!Û¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙvv
{À •!üß")¶Ï~defgh †#ü##|•#||š®ŒÁ$$Ç$||¤ì$Lò$||ü¦%l©%¶Ï||
$·%üˆ&,|&Û¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙ¶Ï||
À &ü()ùψdefghˆ Ä(üÍ(#|Ó(ƒƒš®Œÿ)$…*ƒƒ¤ª*L°*ƒƒüÝ*là*ùσƒ
ˆ$î*ü¿+,|Â+Û¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙùσƒ
À Ò+üÔ5>Š¥ŒŒÎì‘Ñ Ý5Íì—Ñ è5½ÐÙ5!ü–6?ХŻ Ÿ6Ö» ª6½ÐÙ›6!#&(¼Ü6,ß6š š½Ð½ÐŽ å6Ž
Š‘Ñ—Ñ$æ6ü7JХŻ –7Ö» ª7¿‘Ñ4™7½Ð´’71368¤ì7<ï7½Ð
Š‘Ñ—Ñü 8>Š¥ššÅ» ©8Ö» ½8³¾4¬8½Ðœ¥8!#&(¤ó8ú8½Ð˜˜
œŠ‘Ñ—Ñü“:PŠž¥Ÿ Ÿž Å» œ:Ö» °:³¾4Ÿ:`—Ñ„³:½Ð¡¤¥¦§¨©ª«¬­®¯˜:TVY[üò@J\ù@øüÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
½Ð¾Ò
—Ña ª
¯Š‘Ñ—ÑüÔ—Vб¥²³²³±Å» Ý—Ö» ñ—³¾4à—ÍÁ„ô—ÅѴٴٗ68:<¼±˜,´˜œ œÅÑÅѰ º˜°
´Š‘Ñ—Ñ$»˜üà™LŠ¥·¸·¸Å» é™Ö» ý™³¾4ì™ÍÁ„€šÅѹå™.024ü³š1¶šY½ÐÅѵµ
¹Š‘Ñ—Ñ® ºšü—œYŠ»¥¼½»½¼Å»  œÖ» ´œ³¾4£œÍÁ„·œÅѾ¿ÀúMûMÿM¿ÀœœHJLNL÷œ$üœºº²Êü($’ ÅÑÛ¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙÅÑúMº º
¿Š‘Ñ—Ñü½ª-LÀªž žÅÑÛ¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙº ʪº
ÀŠ‘Ñ—Ñ$˪ü׫bŠÂ¥ÃÄÂÃÄÅ» à«Ö» ô«³¾4ã«ÍÁ„÷«ÅÑÅÄMÅÜ«68:<´À¬ìŸ ŸÅÑÁ ǬÁ
ÅŠ‘Ñ—Ñ$Ȭü­vŠÇ¥ÈÉÇÉÈÅ» –­Ö» ™­³¾4È­º‘Ñæ­ÍÁ„ò­½ÐÊÌ’­BDFHü¾¯?lů ¡  ½Ð ¡‘ÑÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
Æ Ó¯Æ
ÊŠ‘Ñ—Ñ$Ô¯needleÁ4Ú¯<ž°ÊêÂ˃ÃË¡ÃËËÊË‘Ñ—Ñ ‘Ñ“’ ‘Ñüݴ˰¢£ ¢½Ð £‘ÑùËÛ¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙ„ÜÆ ë°Æ
ÌŠ‘Ñ—Ñ$ì°ŠÜ4ú°rangeÁ,ޱ<ò±ÌêÂ̓ÃÍ¡ÃÍÍÌÍ‘Ñ—ÑøÝÞü²jŠÏ¥ÐÑÑÏÐÅ» ¦²Ö» ©²³¾4زÍÁ„ö²½ÐÒÔØ¢²468:üÊ´]„Ñ´¤ ¤½Ð„ÜÎÓÓ â´ÎÍì¡âÔô´¥“"¡â ¥‘Ѭù´¥¡âñâ˜"“’D†µ
ÒŠ‘Ñ—Ñ¡â$ã´ predicateÁLé´y{ü·¢Ì–·¦ ¦½Ð¡âùËäÞÎÕÕ ¹·ÎÏâÔÓ·§“"¡â §‘Ѭط§¡âáä˜"“’Då·
ÔŠ‘Ñ—Ñ¡â$º·ÄâLÈ·éÞ,÷·{}޼ÔêÂÖƒÃÖ¡ÃÖÖÔ֑їѡ⠼¼ÔêÂ׃ÃסÃ××Ô×‘Ñ—Ñ¡â¸æÅæüލüϽ Y¨ ¨½Ð¡âùË„ÜÎÙÙ ù½ÎÏâÔ—¾©“"¡â ©‘Ѭœ¾©¡âºè˜"“’D©¾
ØŠ‘Ñ—Ñ¡â$ú½ÄâLŒ¾éÞ,»¾{}üÒ«ü—Ò'ª« ª
›‚ «àå¥ÛÜÝÜÛÝ ÒÒÎìÕÓ ¿ÒÍ웂 ÂÒÖ» ÅÒ¿ÕÓ4øÒ¯›‚ÕÓŒÓÍÁ„ªÓ
ÚÕÓ›‚—ÑelementsÁDÈÒ»
4ØÒz|uwy{üÀäœÄÇ䬭 ¬åé ­àå¥ßàáàáß óä·ê àäÉê ãäÖ» æääê4™åõꌱåÍÁ„Ëå
ÞÕÓ›‚—Ñ¥êDéä»
4ùäVXZ\^`üßê§üæê'® ®åéÛ¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙ¥ãäååãä ¡ë·ê ŽëÉê ‘ëÖ» ”ëäê4ÃëõêŒÛëÍÁ„õë
âÕÓ›‚—Ñ¥êD—ëMOQSUW“ïâêÂæƒÃæ¡ÃææâæÕÓ›‚—Ñ ›‚¥î4ÛïâêÂçƒÃç¡ÃççâçÕÓ›‚—Ñ¥î¥îü™ñ˜Ä ñ¯ ¯åé¥î¥éêëéêë Ìñ·ê ¹ñÉê ¼ñÖ» ¿ñäê4îñõꌆòÍÁ„ ò
èÕÓ›‚—Ñ¥êDÂñMOQSUWùòèêÂìƒÃì¡ÃììèìÕÓ›‚—Ѥ
t<ÚÄcíî”ÏüÚ1¾Òü&¾ÒñÅcñü½DÀ°±² °¾Ò ± c cˆ¢cµ
 `£c `àB¤GS
²­Œð Äð
ñ± Ë̳
ºb¤âø òóëµòöëµòö¬a,Yòô¤"kíòôÇ"sòòôž,òôÁ£Ùòô°(,ôòõ£S),øòõêS*,òõÈ=+,°òõ÷V,,µòõœW-,¹òõ©W.,ºòõêW/,¿òõÕ‹-`òô½È>G,¯òõ¢åEH,òõ¥FI,òõ§ÈIJ,Óòõ©«KK,òòõªÈ=L,·òõÄêWL,¸òõÅÙ
 /òôµ¼)&/âòôœ ¼)B/ãòôœ ò­¢,óòõÄ`5/Ð òô¹Ä`M/Ñ òô¹¿aC/ä òôº¿a[/å òôºÊ_Q/¼ òô»Ê_i/½ òô»¾c_/
òô¼µdT/
òô¾ëfh-²
òõ¡œhi-Ì
òõ£²ij-à
òõ¦²i‚-á
òõ¦¡ln- òõ«¡l†- òõ«üÏ'ÍÌÆü°J¥øùùø·ê µÍìÛÓ Éäê`ÛÓ„Ì›ÓúüÿƒEGACü¨ \û û›Óø ø ºbü Yý öbYþ …cYÿ ÚYÚðx:]†%=ûÕÓÛÓ÷Ë ÷
úÕÓÛÓÙ %'ü÷ O ý ýàåÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
 ý›ÓÆ–÷Š
÷
üÕÓÛÓŽ
ž,˜
&(°üêÂþƒÃþ¡ÃþþüþÕÓÛÓ¾ÒÆ–üúF¤•³ ³àå ³›Ó÷ ±÷
ÿÕÓÛÓ´N üÍLÄâ´ ´àå ´›Ó÷ ÷
ÕÓÛÓ´üúElµ µ›Ó µÕÓ÷ ÷
ÕÓÛÓ¤éÉ®üó,D‡ ›Ó àå÷ ÷
ÕÓÛÓ$‘ü !S„µ!· ·›Ó ·àå÷ Æ!÷
ƒÕÓÛÓ$Ë!Ñ!éÉÛ!¤þ?¾c„ã
ºb¤õø ó)|œèˆ­ÞºŒ­¿Œ®¿ß³íߎ³ÄŽ× `ëµ\›ëµìÙ¢¹£¬ù5Y¤" íÇ"
òžÁ˜ Ù°¿5ôŠ£SÀ5øŠêSÁ5ŠÈ=Â5°Š÷VÃ5µŠœWÄ5¹Š©WÅ5ºŠêWÆ5¿ŠÕ"7`½È>Þ5¯Š¢åEß5Š¥Fà5ЧÈIá5ÓŠ©«Kâ5òŠªÈ=ã5·ŠÄêWã5¸ŠÅ¼)¡8✠¼)½8㜠ò­6óŠÄ`°8Ð ¹Ä`È8Ñ ¹¿a¾8ä º¿aÖ8å ºÊ_Ì8¼ »Ê_ä8½ »µd·8
¾ëfË6²
Š¡œhÌ6Ì
Š£²iÍ6à
Ц²iå6á
Ц¡lÑ6 Š«¡lé6 Š«ŒÏkn\_ÜQT¿KN(+øÌé„­Å„Ãü¯/ü”ZW A zero-copy "slice", that works for unsized types, i.e. the zero-copy version of `[T]`Áìï where `T` is not `Sized`.Áúü‘`] This behaves similarly to [`VarZeroVec<T>`], however [`VarZeroVec<T>`] is allowed to containÁüòQN owned data and as such is ideal for deserialization since most human readableÁüÄGD serialization formats cannot unconditionally deserialize zero-copy.ÁŒúüfc This type can be used inside [`VarZeroVec<T>`](crate::VarZeroVec) and [`ZeroMap`](crate::ZeroMap):Áü÷jg This essentially allows for the construction of zero-copy types isomorphic to `Vec<Vec<T>>` by insteadÁüâ%" using `VarZeroVec<ZeroSlice<T>>`.Áˆ úüŒ ur The `F` type parameter is a [`VarZeroVecFormat`] (see its docs for more details), which can be used to select theÁü‚
qn precise format of the backing buffer with various size and performance tradeoffs. It defaults to [`Index16`].Áô
úüø
QN This type can be nested within itself to allow for multi-level nested `Vec`s.ÁÊ ú «²Ý ú¤á  ## Nested SlicesÁö úüú ]Z The following code constructs the conceptual zero-copy equivalent of `Vec<Vec<Vec<str>>>`ÁØ ú Á¿üè ,) use zerovec::{VarZeroSlice, VarZeroVec};Áü•
96 let strings_1: Vec<&str> = vec!["foo", "bar", "baz"];ÁüÏ
HE let strings_2: Vec<&str> = vec!["twelve", "seventeen", "forty two"];Áü˜B? let strings_3: Vec<&str> = vec!["我", "喜歡", "çƒé¾èŒ¶"];ÁüÛ>; let strings_4: Vec<&str> = vec!["w", "ω", "æ–‡", "𑄃"];Áüš41 let strings_12 = vec![&*strings_1, &*strings_2];ÁüÏ41 let strings_34 = vec![&*strings_3, &*strings_4];Áü„30 let all_strings = vec![strings_12, strings_34];Á¸úü¼>; let vzv_1: VarZeroVec<str> = VarZeroVec::from(&strings_1);Áüû>; let vzv_2: VarZeroVec<str> = VarZeroVec::from(&strings_2);Áüº>; let vzv_3: VarZeroVec<str> = VarZeroVec::from(&strings_3);Áüù>; let vzv_4: VarZeroVec<str> = VarZeroVec::from(&strings_4);Áü¸IF let vzv_12 = VarZeroVec::from(&[vzv_1.as_slice(), vzv_2.as_slice()]);Áü‚IF let vzv_34 = VarZeroVec::from(&[vzv_3.as_slice(), vzv_4.as_slice()]);ÁüÌLI let vzv_all = VarZeroVec::from(&[vzv_12.as_slice(), vzv_34.as_slice()]);Áúü63 let reconstructed: Vec<Vec<Vec<String>>> = vzv_allÁ .iter()Áüä41 .map(|v: &VarZeroSlice<VarZeroSlice<str>>| {Á¤™ v.iter()Áü®,) .map(|x: &VarZeroSlice<_>| {ÁüÛ%" x.as_varzerovec()Áü .iter()Áü¡.+ .map(|s| s.to_owned())ÁüÐ1. .collect::<Vec<String>>()Á”‚ })Áü•$! .collect::<Vec<_>>()Á })ÁìÅ .collect::<Vec<_>>();Áüã+( assert_eq!(reconstructed, all_strings);Áúü“# let bytes = vzv_all.as_bytes();Áü·EB let vzv_from_bytes: VarZeroVec<VarZeroSlice<VarZeroSlice<str>>> =Áüý0- VarZeroVec::parse_bytes(bytes).unwrap();Áü®(% assert_eq!(vzv_from_bytes, vzv_all);Á<×¼³ßúÜã ## Iterate over WindowsÁÿúüƒMJ Although [`VarZeroSlice`] does not itself have a `.windows` iterator likeÁüÑTQ [`core::slice::Windows`], this behavior can be easily modeled using an iterator:Á¦ú¼³ä² use zerovec::VarZeroVec;ÁÏúüÓ=: let vzv = VarZeroVec::<str>::from(&["a", "b", "c", "d"]);Áü‘41 # let mut pairs: Vec<(&str, &str)> = Vec::new();ÁÆúüÊ'$ let mut it = vzv.iter().peekable();Áüò;8 while let (Some(x), Some(y)) = (it.next(), it.peek()) {Áü®  // Evaluate (x, y) here.ÁÜÏ # pairs.push((x, y));Á›·üñ?< # assert_eq!(pairs, &[("a", "b"), ("b", "c"), ("c", "d")]);Á¼³¥·ê Ç¡ÿƒÔØY¼¦fN(*- ÒÚÌÜåëµFu\»ŸÛÓÕÓ”» àåüÒ @¥šš·ê × ¡ÿ ë äêºÿ„î ƒÔœžŸ ¡£¤¥¦¨ACFHüÈ!)ü™!*' Construct a new empty [`VarZeroSlice`]ÁLÕ! ƒÔ˜˜
ÕÓÛÓüÐ#KlÞ# ƒÔø ø ºbü Yý öbYþ …cYÿ ÚYÚðx:]†%=ÕÓÛÓ˜ì#˜
œÕÓÛÓ$ô#ü‡'?üÏ%JG Uses a `&[u8]` buffer as a `VarZeroSlice<T>` without any verification.Áž&úd¦&ãý·&úü¿&C@ `bytes` need to be an output from [`VarZeroSlice::as_bytes()`].Á¤›'¸ ¸àå ¸ƒÔ˜ ·'˜
žÕÓÛÓ´=£Ôó*üÁ(,) Get the number of elements in this sliceÁò(úlú(
# ExampleÁŒ)ú\”)Á¿ô¤) # use zerovec::VarZeroVec;ÁÇ)úüÏ)41 let strings = vec!["foo", "bar", "baz", "quux"];Áüˆ*0- let vec = VarZeroVec::<str>::from(&strings);Á½*úìÅ* assert_eq!(vec.len(), 4);Á<ç*¼³ú*¹ ¹ƒÔ˜ þ*˜
ŸÕÓÛÓ$ÿ*ôç-ü¾+52 Returns `true` if the slice contains no elements.Áø+út€,«²“,ú<›,¼³ô§,“¹Ê,úüÒ,&# let strings: Vec<String> = vec![];Áüý,0…º²-úäº- assert!(vec.is_empty());Á<Û-¼³Dî-º ºƒÔ˜ ÷-˜
 ÕÓÛÓ$ø-üÁ27ü».1. Obtain an iterator over this slice's elementsÁñ.úlù.下/ú\“/Á¿ô£/“¹Æ/úüÎ/4ǹü‡00…º¼0úüÄ0;8 let mut iter_results: Vec<&str> = vec.iter().collect();Áü„1'$ assert_eq!(iter_results[0], "foo");Áü°1'$ assert_eq!(iter_results[1], "bar");ÁüÜ1'$ assert_eq!(iter_results[2], "baz");Áüˆ2(% assert_eq!(iter_results[3], "quux");Á<µ2¼³$È2¢ ¢ƒÔ

¾c
¬YŠ
ÖY
þcY;?>sõ
'z¢ÕÓÛÓ˜Í2˜
¡ÕÓÛÓ$Õ2üý7+üª3TQ Get one of this slice's elements, returning `None` if the index is out of boundsÁƒ4úl‹4ä¸4ú\¥4Á¿ôµ4“¹Ø4úüà44ǹü™50…ºÎ5úüÖ5;ì¿ü–6(% assert_eq!(vec.get(0), Some("foo"));ÁüÃ6(% assert_eq!(vec.get(1), Some("bar"));Áüð6(% assert_eq!(vec.get(2), Some("baz"));Áü7)& assert_eq!(vec.get(3), Some("quux"));ÁüË7! assert_eq!(vec.get(4), None);Á<ñ7¼³„8» »ƒÔÛ¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙ »ÕÓ˜ ˆ8˜
£ÕÓÛÓ$‰8éÉ8üÖ=4üÜ8$! Get one of this slice's elementsÁ…9úd9ãýž9úä¦9 `index` must be in rangeÁÇ9úlÏ9ä¸á9ú\é9Á¿ôù9“¹œ:úü¤:4ǹüÝ:0…º’;úüš;;ì¿dÚ; unsafe {Áüë;0- assert_eq!(vec.get_unchecked(0), "foo");Áü <0- assert_eq!(vec.get_unchecked(1), "bar");ÁüÕ<0- assert_eq!(vec.get_unchecked(2), "baz");ÁüŠ=1. assert_eq!(vec.get_unchecked(3), "quux");Á,À=›·<Ê=¼³lä=¼ ¼ƒÔ ¼ÕÓ˜ ò=˜
¤ÕÓÛÓ$ó=éÉù=üÂD%ü­@FC Get a reference to the entire encoded backing buffer of this sliceÁø@úü€A<9 The bytes can be passed back to [`Self::parse_bytes()`].ÁÁAúüÉADA To take the bytes as a vector, see [`VarZeroVec::into_bytes()`].ÁBúlšB丬Bú\´BÁ¿ôÄB“¹çBúüïB,) let strings = vec!["foo", "bar", "baz"];Áü C0- let vzv = VarZeroVec::<str>::from(&strings);ÁÕCúüÝCFC assert_eq!(vzv, VarZeroVec::parse_bytes(vzv.as_bytes()).unwrap());Á<¨D¼³DÏD½ ½ƒÔ ½àå˜ ØD˜
¥ÕÓÛÓ$ÙDüÞF@üE:7 Get this [`VarZeroSlice`] as a borrowed [`VarZeroVec`]ÁÏEúü×EDA If you wish to repeatedly call methods on this [`VarZeroSlice`],Áü F96 it is more efficient to perform this conversion firstÁlëF§ §ƒÔââã¼)çˆ Ó 7)ºëØj§ÕÓÛÓ˜ùF˜
¦ÕÓÛÓ$G!ü„IEüàGC@ Parse a [`VarZeroSlice`] from a slice of the appropriate formatÁ¨Húü°HOL Slices of the right format can be obtained via [`VarZeroSlice::as_bytes()`]Á\I© ©àåÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
 ©ƒÔÆ–˜—I˜
¨ÕÓÛÓž,›I ü‚Jf¥«¬¬«·ê ‡J¡ÿ ŠJäê4­JºÕÓËJºÿ„×JƒÔ­®68;=ü¼O:üïJ]Z Binary searches a sorted `VarZeroVec<T>` for the given element. For more information, seeÁüÑK41 the standard library function [`binary_search`].ÁŠLúl’L两Lú<¬L¼³ô¸L“¹ÛLúüãL+( let strings = vec!["a", "b", "f", "g"];Áü“M0…ºÈMúüÐM.+ assert_eq!(vec.binary_search("f"), Ok(2));ÁüƒN/, assert_eq!(vec.binary_search("e"), Err(2));Á<·N¼³ÃNúüËN^[ [`binary_search`]: https://doc.rust-lang.org/std/primitive.slice.html#method.binary_searchÁlÃO¾¿ ¾ƒÔ ¿Õӄܪ ÑOª
­ÕÓÛÓ$ÒOà ØOü´\ü²PZW Binary searches a `VarZeroVec<T>` for the given element within a certain sorted range.ÁQúü™QZW If the range is out of bounds, returns `None`. Otherwise, returns a `Result` accordingÁüøQGD to the behavior of the standard library function [`binary_search`].ÁÄRúüÌR=: The index is returned relative to the start of the range.ÁŽSúl–S丨Sú<°S¼³ô¼S“¹üßS:7 let strings = vec!["a", "b", "f", "g", "m",
,„…üĆl¥ÇÈÇÈ·ê Ɇ¡ÿ ̆äê4ö†ÕÓ”‡ºÿ„Ÿ‡ƒÔ579;ü¶‡\¥ÊËËÊ·ê »‡¡ÿ ܇äê4¾‡íßÕÓÕÓTЇºÿ„߇ƒÔÌïßÌFHJLü§ˆ7\ªˆÌÍ ÌƒÔ ÍƒÔΑÉ ¶ˆÉ
ÌÕÓÛÓ$·ˆ¹
,½ˆü˜‰N¥ÎÏÏÎ·ê ¡ÿ ·‰äê4 ‰‹Ú²‰ºÿ„º‰ƒÔлÐ8:<>üû‰'þ‰ÎÏ ÎƒÔ ÏƒÔ“’Í ‚ŠÍ
ÐÕÓÛÓ$ƒŠ¹
,‰ŠüÔŠh¥ÒÓÒÓ·ê ÙŠ¡ÿ íŠäê4ÜŠºÿ„ðŠ¿cÕÓT±‹ƒÔÔÀcÔ@BDFüË8Æ‹ÐÑÒ ÐƒÔ Ñ c cˆ¢cµ
 `£c `àB¤GS
Ò­ŒÑ Ê‹Ñ
ÔÕÓÛÓ$Ë‹± Ñ‹ü¼ŒU¥Ö××Ö·ê ÁŒ¡ÿ ÌŒºÿ„ÏŒƒÔØâØ&(*,ü˜'4Ó ÓƒÔ½’Õ ¢Õ
ØÕÓÛÓ””bMâãè­ïºÙÜ­¿ÙÜ®¿ßÙݳíßÙÞ³ÄÙÞ× `Ùßr,©é!Ùà°zôÙÚ£SzøÙÚêSzÙÚÈ=z°ÙÚ÷VzµÙÚœWz¹ÙÚ©WzºÙÚêWz¿ÙÚ¬R{YÙá¤"\PíÙáÇ"dOòÙážòNÙáÁñNÙÙáÕÛ{`Ùá½È>—z¯ÙÚ¢åE˜zÙÚ¥F™zÙÚ§ÈIšzÓÙÚ©«K›zòÙÚªÈ=œz·ÙÚÄêWœz¸ÙÚÅÙ
p}Ùáµò­¸zóÙÚºb]}ø Ùá·Ä`c}Ð Ùá¹Ä`{}Ñ Ùṿaq}ä Ùếa‰}å ÙáºÊ_}¼ Ùá»Ê_—}½ ÙỾc}
Ùá¼µd‚}
Ùá¾ëf–{²
ÙÚ¡œh—{Ì
ÙÚ£²i˜{à
ÙÚ¦²i°{á
ÙÚ¦¡lœ{ ÙÚ«¡l´{ ÙÚ«þÛÞËÎL«„žžüï>; A zero-copy, byte-aligned vector for variable-width types.Á®úü²_\ `VarZeroVec<T>` is designed as a drop-in replacement for `Vec<T>` in situations where it isÁü’a^ desirable to borrow data from an unaligned byte slice, such as zero-copy deserialization, andÁüô74 where `T`'s data is variable-length (e.g. `String`)Á¬úü°he `T` must implement [`VarULE`], which is already implemented for [`str`] and `[u8]`. For storing moreÁü™da complicated series of elements, it is implemented on `ZeroSlice<T>` as well as `VarZeroSlice<T>`ÁüþUR for nesting. [`zerovec::make_varule`](crate::make_varule) may be used to generateÁüÔRO a dynamically-sized [`VarULE`] type and conversions to and from a custom type.Á§úü«KH For example, here are some owned types and their zero-copy equivalents:Á÷úüû*' - `Vec<String>`: `VarZeroVec<'a, str>`Áü¦ -* - `Vec<Vec<u8>>>`: `VarZeroVec<'a, [u8]>`ÁüÔ 74 - `Vec<Vec<u32>>`: `VarZeroVec<'a, ZeroSlice<u32>>`ÁüŒ
=: - `Vec<Vec<String>>`: `VarZeroVec<'a, VarZeroSlice<str>>`ÁÊ
úüÎ
{x Most of the methods on `VarZeroVec<'a, T>` come from its [`Deref`] implementation to [`VarZeroSlice<T>`](VarZeroSlice).ÁÊ úüÎ XU For creating zero-copy vectors of fixed-size types, see [`ZeroVec`](crate::ZeroVec).Á§ úü« c` `VarZeroVec<T>` behaves much like [`Cow`](alloc::borrow::Cow), where it can be constructed fromÁü
HE owned data (and then mutated!) but can also borrow from some buffer.ÁØ
úüÜ
uï–üÒqî—ÄúÄÈ # Bytes and EqualityÁáúüåa^ Two [`VarZeroVec`]s are equal if and only if their bytes are equal, as described in the traitÁüÇ_\ [`VarULE`]. However, we do not guarantee stability of byte equality or serialization formatÁü§! across major SemVer releases.ÁÉúüÍVS To compare a [`Vec<T>`] to a [`VarZeroVec<T>`], it is generally recommended to useÁü¤a^ [`Iterator::eq`], since it is somewhat expensive at runtime to convert from a [`Vec<T>`] to aÁü†$! [`VarZeroVec<T>`] or vice-versa.Á«úü¯]Z Prior to zerovec reaching 1.0, the precise byte representation of [`VarZeroVec`] is stillÁüRO under consideration, with different options along the space-time spectrum. SeeÁüà>; [#1410](https://github.com/unicode-org/icu4x/issues/1410).ÁŸú丱úÁ¿äÁ߬ÞúüâA> // The little-endian bytes correspond to the list of strings.Áü¤1. let strings = vec!["w", "ω", "æ–‡", "𑄃"];ÁÖúüÚ3ï´¬ŽêÇĤ×µü½%" strings: VarZeroVec<'a, str>,Á›·éú¬í let data = Data {Áüƒ,) strings: VarZeroVec::from(&strings),Á­¹·ú¼»¼¹üÓOݹ£úü§+( // Will deserialize without allocationsÁüÓAÈÔü•8Å»ÎúüÒ96 assert_eq!(deserialized.strings.get(2), Some("æ–‡"));ÁüŒ0- assert_eq!(deserialized.strings, &*strings);Á¼³ÅúüÉB? Here's another example with `ZeroSlice<T>` (similar to `[T]`):ÁŒú\Á¿äœܹ߬ use zerovec::ZeroSlice;ÁÕúüÙ>; // The structured list correspond to the list of integers.Áü˜ let numbers: &[&[u32]] = &[Á´¸ &[12, 25, 38],Á´Ï &[39179, 100],Á¬æ &[42, 55555],ÁÜü &[12345, 54321, 9],Á4˜ ];ÁŸúü£3ï´¬×êÇÄí×µü†-* vecs: VarZeroVec<'a, ZeroSlice<u32>>,Á,´›·ºú¬¾¾°üÔ(% vecs: VarZeroVec::from(numbers),Á­¹ú¼ˆ ¼¹ü  Oݹð úüô AÈÔü¶!8Å»ï!úüó!96 assert_eq!(deserialized.vecs[0].get(1).unwrap(), 25);Áü­"2/ assert_eq!(deserialized.vecs[1], *numbers[1]);Á<à"¼³è"úüì"fc [`VarZeroVec`]s can be nested infinitely via a similar mechanism, see the docs of [`VarZeroSlice`]ÁÌÓ# for more information.Áí#ú”ñ# # How it WorksÁ„$úüˆ$YV `VarZeroVec<T>`, when used with non-human-readable serializers (like `bincode`), willÁüâ$DA serialize to a specially formatted list of bytes. The format is:Á§%úü«%@= - 2 bytes for `length` (interpreted as a little-endian u16)Áüì%OL - `2 * (length - 1)` bytes of `indices` (interpreted as little-endian u16s)Áü¼&'$ - Remaining bytes for actual `data`Áä&úüè&nk The format is tweakable by setting the `F` parameter, by default it uses u16 indices and lengths but otherÁü×'1. `VarZeroVecFormat` types can set other sizes.Á‰(úü(WT Each element in the `indices` array points to the ending index of its correspondingÁüå(\Y data part in the `data` list. The starting index can be calculated from the ending indexÁüÂ)he of the next element (or 0 for the first element). The last ending index, not stored in the array, isÁü«*%" the length of the `data` segment.ÁÑ*ú
 `£c `àB¤GS
Ø­Œô ü0ô
÷8‘Ñ—Ñ$ý0± ƒ1ü»3LŠù¥úûúûùÅ» Ä3Ö» Ï3«ÕüëüÀ3!#&(üŽ4.$4ºÖ«Õøø
üŠ‘Ñ—Ñ¹
,4üÌ7N8Ù¥þÿÙþÿÅ» Ñ7Ö» å7³¾4Ô7ÍÁ„è7ñÕ´+-02¤¯8<²8ñÕýý
8‘Ñ—Ñüã8L8Ú¥ƒÚƒÅ» è8Ö» ü8³¾4ë8ÍÁ„ÿ8ñÕê!ë!2479\¶94»9ÀÖüÜ9&,ß9Û ÛñÕ ÛÀÖ å9
8‘Ñ—Ñ$æ9ü¦:FŠ¥ˆˆÅ» ¯:Ö» Ã:³¾4²:ÍÁ„Æ:«ÕŠŒŽ«:8:=?Ôê<üó:)& Creates a new, empty `VarZeroVec<T>`.Á¡;út©;«²¼;ú<Ä;¼³äÐ;߬ñ;úüù;1. let vzv: VarZeroVec<str> = VarZeroVec::new();Áä¯< assert!(vzv.is_empty());Á<Ð<¼³÷<«Õ
ŠŠ‘Ñ—ÑüèA=üÕ=A> Parse a [`VarZeroVec`] from a slice of the appropriate formatÁ>úü£>PM Slices of the right format can be obtained via [`VarZeroSlice::as_bytes()`].Áø>úl€?丒?ú\š?Á¿ôª?“¹Í?úüÕ?4ǹüŽ@0…ºÃ@úüË@ assert_eq!(&vec[0], "foo");Áüï@ assert_eq!(&vec[1], "bar");Áü“A assert_eq!(&vec[2], "baz");Áü·A  assert_eq!(&vec[3], "quux");Á<ÜA¼³\ïAøüÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
«ÕÆ–
Š‘Ñ—Ñž,ûAüâDAü¬CHE Uses a `&[u8]` buffer as a `VarZeroVec<T>` without any verification.ÁùCúdDãý’DúüšDC붤öDøü«Õ
ŒŠ‘Ñ—Ñ´w§ü€W-üÇV41 Obtain this [`VarZeroVec`] as a [`VarZeroSlice`]ÁD‡WÜ Ü«Õ ÜÀÖ W
Š‘Ñ—Ñ$‘Wôµbüì`GD Return whether the [`VarZeroVec`] is operating on owned or borrowedÁü¸aIF data. [`VarZeroVec::into_owned()`] and [`VarZeroVec::make_mut()`] canÁü†b*' be used to force it into an owned typeÁD¼bÝ Ý«Õ Åb
ŽŠ‘Ñ—Ñ$ÆbüŸdD4’dl¦d «Õø ø ºbü Yý öbYþ …cYÿ ÚYÚðx:]†%=‘Ñ—Ñ´d
Š‘Ñ—Ñ$¼d#%ü¯mšŠ¥ÎìØ× ¼mÍìÞ× ¿m¿Ø×4ˆnµßØ×Ø×L¦n`Þׄ¸n¡×·ß´m¸megacüÞn2ánÞß Þ¡× ßä× än
ŠØ×Þ×$ån¹
,ënü¹srŠ˜¥š˜šÅ» ÂsÖ» Ås³¾4ñs‘ÑtÍÁ„št«Õ¾s68;=ü±t“8à8ᥜžáœžàòä ¶tÍìüØ ¹tÍìðØ ¼t”å4øt¤åLuàüØØ×D¢u`ðØ„³u¶ØŸ·ßŸikegacüÙu"Üuâãä â¶Ø ã äûØ ßu
Ÿ88Ø×üØðØ$àu¹
,æu¦vŸê ƒÃ ¡Ã  Ÿ Ø×üØðØ üØ Ø×üÀv¢8奢£¤Ÿ¥å¢¤¥£Å» ÅvÍìÊÙ Èvƒå ËvŸtÎv³¾4–wµß‘Ñ‘ÑL®wàÊÙ‘ÑDÀw¹å„Ñw‹Ù§·ß§tvpruwt Ôvü÷w$úwæç æ‹Ù çÉÙ¡ ýw¡
§8‘ÑÊÙÞן$þw¹
,„xÆx§ê©ƒÃ©¡Ã©©§©‘ÑÊÙÞן ÊÙ’ÞüàxbŠ«¥¬­­«¬Å» éxÖ» Šy³¾4ìxíߑёÑTþxÍÁy«Õ®ïß®åxGILNüÉy7\Ìyèé è«Õ é«ÕΑª Øyª
®Š‘Ñ—Ñ$Ùy¹
,ßyüºzTа¥±²°±²Å» ÃzÖ» Ýz³¾4ÆzøÚØzÍÁ„àz«Õ³»³¿z9;>@ü•{'˜{êë ê«Õ ë«Õ“’¯ œ{¯
³Š‘Ñ—Ñ${¹
,£{Ô«׫īǫü¾ ¡«Té–«™«3«äù)«\÷L<ûLÀ¬½ Ä œflÒ©
¡­æº¿¤­¿¿¤®¿ß¿¥³íß¿¦³Ä¿¦×Œ `¿§ëµ¿¨ëµ¿¨ NonZeroUsizeÁd÷²–¿©r,”é!¿ª§¿«°¨«ô¿¢£S©«ø¿¢êSª«¿¢È=««°¿¢÷V¬«µ¿¢œW­«¹¿¢©W®«º¿¢êW¯«¿¿¢È>°«¯¿¢¢åE±«¿¢¥F²«¿¢§ÈI³«Ó¿¢©«K´«ò¿¢ªÈ=µ«·¿¢ÄêWµ«¸¿¢Åò­µ«ó¿¢ëfµ«²
¿¢¡œh¶«Ì
¿¢£²i·«à
¿¢¦²iÏ«á
¿¢¦¡l»« ¿¢«¡lÓ« ¿¢«L¿ÄÅ©
ª
®D™¿ßÀ¹£ÀÞ>ÀÀÁ¹ ¬ÀÁõ6”„%½ÀÁ°®ôÀÁ¢£S®øÀÁ¢êSÀÁ¢È=°ÀÁ¢÷VµÀÁ¢œW¹ÀÁ¢©WºÀÁ¢êW¿ÀÁ¢­&ºÀÁ¤­>¿ÀÁ¤³íßÀÁ¦³1ÄÀÁ¦×  `ÀÁ§ëµ#ÀÁ¨ëµ<ÀÁ¨äõ ²–ÀÁ©r#é!ÀÁª§&ÀÁ«È>¯ÀÁ¢¢åEÀÁ¢¥FÀÁ¢§ÈIÓÀÁ¢©«KòÀÁ¢ªÈ=·ÀÁ¢ÄêW¸ÀÁ¢Åò­óÀÁ¢ëf²
ÀÁ¢¡œhÌ
ÀÁ¢£²ià
ÀÁ¢¦²i„¯á
ÀÁ¢¦¡l ÀÁ¢«¡l¯ ÀÁ¢«œŽ±„§¢üº=: A zero-copy "slice", i.e. the zero-copy version of `[T]`.Áøú„ü
This behavesÁüMJ similarly to [`ZeroVec<T>`], however [`ZeroVec<T>`] is allowed to containÁüÛQ˜“ü­Gó“õúüùfДüàjÀ•üËda using `VarZeroVec<ZeroSlice<T>>`. See the [`VarZeroVec`](crate::VarZeroVec) docs for an example.Á°ú«²ÃúüÇ+( Const-construct a [`ZeroSlice`] of u16:Áóú¼³äÿ use zerovec::ule::AsULE;ÁÜœ·´¸úü¼! const DATA: &ZeroSlice<u16> =ÁüÞKH ZeroSlice::<u16>::from_ule_slice(&<u16 as AsULE>::ULE::from_array([Áüª ! 211, 281, 421, 32973,Á ]));ÁÙ úüÝ '$ assert_eq!(DATA.get(1), Some(281));Á<…
¼³L­
¥ÆÆÍìÕÓ ·
µÕÓ
ÛÚHr)¡>
ÅDzÑÛÚãjÀ²ÑÛÚÄÄ
ÅÕÓ}
ÀÄIJÑüÍ
(¥ÉÉlj Ò
؉ ,ï
ÛÚÊËÌÍÎÏÐÑÒ+-üœ )Üü
 Returns an empty slice.ÁL©  ÛÚÈÈ
ÊÕÓüæ
0üõ 41 Get this [`ZeroSlice`] as a borrowed [`ZeroVec`]Á® úü¶ JG [`ZeroSlice`] does not have most of the methods that [`ZeroVec`] does,Áü…
NK so it is recommended to convert it to a [`ZeroVec`] before doing anything.ÁTó
ì ìÛÚ¬¬¹ ¯Â¿° ¿±—6¿àAáš1&0ìÕÓÈ þ
È
ËÕÓ$ÿ
üÊ;üËPM Attempt to construct a `&ZeroSlice<T>` from a byte slice, returning an errorÁü %" if it's not a valid byte sequenceÁ\Ñí íàåÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
 íÛÚÆ–È äÈ
ÌÕÓ´ü‰?üÙEB Uses a `&[u8]` buffer as a `ZeroVec<T>` without any verification.Á£úãý¼úüÄ@= `bytes` need to be an output from [`ZeroSlice::as_bytes()`].Á¤î îàå îÛÚÈ ¹È
ÍÕÓ´µ¬üÀ6üÉ52 Construct a `&ZeroSlice<T>` from a slice of ULEs.Áƒúü‹XU This function can be used for constructing [`ZeroVec`]s in a const context, avoidingÁœè parsing checks.Áúüˆ%" See [`ZeroSlice`] for an example.ÁtÍï ï²Ñ ïÛÚÈ ãÈÔÑží­ü¼ ü‡LI Returns this slice as its underlying `&[u8]` byte buffer representation.ÁØúìà Useful for serialization.Áú东ú¼³̰ use zerovec::ZeroVec;ÁÎúüÖOL // The little-endian bytes correspond to the numbers on the following line.ÁüªIF let bytes: &[u8] = &[0xD3, 0x00, 0x19, 0x01, 0xA5, 0x01, 0xCD, 0x80];Áüø/, let nums: &[u16] = &[211, 281, 421, 32973];Á¬úü´2/ let zerovec = ZeroVec::alloc_from_slice(nums);Áëúüó*' assert_eq!(bytes, zerovec.as_bytes());Á¼³ð ðÛÚ ðàåÈ Ì È
ÏÕÓüÛ!-ü!+( Dereferences this slice as `&[T::ULE]`.Ádè!ñ ñÛÚ ñ²ÑÈ õ!ÈìÞ$ö!ü¾& ü¦"1. Returns the number of elements in this slice.ÁÜ"úlä"ä¸ö"ú<þ"¼³äŠ#é… Ì«#ë— É#úüÑ#Ió˜ üŸ$ let zerovec: ZeroVec<u16> =ÁüÃ$96 ZeroVec::parse_bytes(bytes).expect("infallible");Á%úü‰%! assert_eq!(4, zerovec.len());Á|¯%€õ¤Ã% bytes.len(),ÁüÜ%85 zerovec.len() * size_of::<<u16 as AsULE>::ULE>()Á4™&úõ<¤&¼³Ë&ò òÛÚÈ Ï&È
ÑÕÓ$Ð&ü‚+$üŽ'(% Returns whether this slice is empty.Á»'úlÃ'ä¸Õ'ú<Ý'¼³Ìé'ë— ‡(úü(Ió˜ üÝ(®ž ü)9מ ü¿)! assert!(!zerovec.is_empty());Áå)úüí)PM let emptyvec: ZeroVec<u16> = ZeroVec::parse_bytes(&[]).expect("infallible");ÁüÂ*! assert!(emptyvec.is_empty());Á<è*¼³D+ó óÛÚÈ ˜+È
ÒÕÓ$™+üÙ+(¥ÔÔlj Þ+؉ ,û+ÛÚÕÖÛÜÝßáâãå.0üØ/,üˆ,LI Gets the element at the specified index. Returns `None` if out of range.ÁÙ,úlá,ä¸ó,ú<û,¼³̇-ë— ¥-úü­-Ió˜ üû-®ž üŸ.9מ Ý.úüå.*' assert_eq!(zerovec.get(2), Some(421));Áü”/%" assert_eq!(zerovec.get(4), None);Á<¾/¼³ß/ô ôÛÚÍéÓ ã/Ó
ÕÕÓ$ä/Ö,ê/ü£5<ü€1PM Gets the entire slice as an array of length `N`. Returns `None` if the sliceÁüÕ1'$ does not have exactly `N` elements.Á2úl‰2ä¸2ú<£2¼³̯2ë— Í2úüÕ2Ió˜
©
ª
œf­
ˆÀ ›T†É\sû¸äÕÓÓ¸\Ó
ãÕÓ$À\üÌb7ü]TQ Returns a tuple with the first element and a subslice of the remaining elements.Áö]úlþ]ä¸^ú<˜^¼³ä¤^é… ÜÅ^·´å^úüí^!¨† ü“_KÓ† üã_!¨‡ d‰`Ò‡ üš`41 const EXPECTED_VALUE: (u16, &ZeroSlice<u16>) = (ÁdÓ` 211,Áüä`KÓ† ä´a 281, 421, 32973,ÁdÕa ])),Á4æaúõüña<9 assert_eq!(EXPECTED_VALUE, DATA.split_first().unwrap());Á<²b¼³\Óbü üÛÚÛ¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙÕÓÔ× Ó ßbÓ
åÕÓ$àbüÖf4Šç¥èçèÍì‘Ñ ßfµ‘Ñ,âf÷ÙéêëúMûMÿMêëÛf;=Lg$–gææ‘Ñü¤g$§gý ý÷ÙÛ¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙ‘Ñæ ¬gæ
ꊑÑ$±gü‡h-LŠhþ þ÷Ù®×æ ”hæ
늑Ñ$•hüÛh=Ší¥îîíÿØ ähÙ ,çh÷ÙïÄMïàh!#´Ÿi¢iÿ ÿ÷Ùì ¦iì
Ñ$§iüÖi?Šñ¥òñòÿØ ßiÙ ,âi÷ÙóMóÛi!#üœj$LŸj ÷Ù Ú ð ©jð
óŠ‘Ñ$®jü‡k.¥õõlj Œk؉ ,©k‹Ú±kÛÚöüÏp:ü¼kZW Binary searches a sorted `ZeroVec<T>` for the given element. For more information, seeÁü›l-* the primitive function [`binary_search`].ÁÍlúlÕlä¸çlú<ïl¼³Ìûlë— ™múü¡mIó˜ üïm®ž ü“n9מ ÑnúüÙn30 assert_eq!(zerovec.binary_search(&281), Ok(1));Áü‘o41 assert_eq!(zerovec.binary_search(&282), Err(2));Á<Êo¼³ÖoúüÞo^ŸÝlÖp ÛÚ ÕÓ„Üô äpô
öÕÓ$åpà ëp<ÆqöêÂ÷ƒÃ÷¡Ã÷÷ö÷ÕÓ ðГ’ ÕÓüùq(¥ùùlj þq؉ ,›rÛÚúüåwwü¨r_\ Binary searches a sorted `ZeroVec<T>` based on a given predicate. For more information, seeÁüŒs0- the primitive function [`binary_search_by`].ÁÁsúlÉsä¸Ûsú<ãs¼³Ìïsë— túü•tIó˜ üãt®ž ü‡u9מ ÅuúüÍuA> assert_eq!(zerovec.binary_search_by(|x| x.cmp(&281)), Ok(1));Áü“vB? assert_eq!(zerovec.binary_search_by(|x| x.cmp(&282)), Err(2));Á<Úv¼³ævúüîvd•ð„ìwƒ ƒÛÚ—3„Üø—3ûû †xøÍìµé ̤x“"µé ÕÓ¤©xµé þé ˜"“’Dµx
úÕÓµé $‡xÄâL™xNP<™yúêÂüƒÃü¡ÃüüúüÕÓµé Ää  µé ü²7¥þþlj ¾؉ ,ÁÕ€ÛÚÿÀÂÿ.0üþ7t àåÙý —€ý
ÿÕÓ´,ü÷€5¤ àå ÛÚý ý
ÕÓ´,–ü€‚/¥lj …‚؉ ,¥‚ŒŠ­‚ÛÚü´‚P¥lj ¹‚؉ ,ò‚þ‡Lú‚ÛÚ·ß')ü™ƒ*œƒ ÛÚ ÛÚƒ Ÿƒƒ
ÕÓ$ ƒ¹
,¦ƒüG¥lj †„؉ ,¶„þ‡L¾„ÛÚˆ·ßˆ')üÝ„!à„ˆ ˆÛÚ ¸Û ã„
ˆÕÓ$䄹
,ê„ü¸…VŠŠ¥ŠÿØ Á…Ù ,ü…œíL„†ÅÛŒ·ßŒ½….0ü£†,¦†Š ŠÅÛ ûÛ ©†
ŒŠ‘Ñ$ª†¹
,°†üÿ†VŠŽ¥ŽÿØ ˆ‡Ù ,ÇœíLˇûÛ·ß„‡.0üê‡*퇌 ŒûÛ ÅÛ ð‡
Š‘Ñ$ñ‡¹
,÷‡üňD¥lj ʈ؉ ,öˆ¨TþˆÛÚÀc&(ü4“‰Ž ŽÛÚ  c cˆ¢cµ
 `£c `àB¤GS
­Œ —‰
ÕÓ$˜‰± ž‰üñ‰7¥lj ö‰؉ ,ù‰TŠÛÚïß')ü¯Š7\²Š ÛÚ ÛÚΑ ¾Š
ÕÓ$¿Š¹
,ÅŠü ‹)¥˜˜lj ¥‹؉ ,¨‹‹Ú°‹ÛÚ»&(üЋ'Ó‹ ÛÚ ÛÚ“’ ׋
ÕÓ$Ø‹¹
,Þ‹üÖ08¥ÿØ ÛÙ ,ވݜâœüŽ!4Ž ˆÝ ÅÛš —Žš
œ8‘Ñ$˜ŽüçŽ58¥žžÿØ ìŽÙ ,–¥ÝŸ´Ÿ¤£¥Ý
Ÿ8‘Ñ„±D¤Ë DTæDDßCâCÏCÒCL†¯CÌÍ C¼ìpC„‰bC”ŸTCÌü´;8 A zero-copy, byte-aligned vector for fixed-width types.Áðúüô\Y `ZeroVec<T>` is designed as a drop-in replacement for `Vec<T>` in situations where it isÁüÑ]Z desirable to borrow data from an unaligned byte slice, such as zero-copy deserialization.Á¯úü³[X `T` must implement [`AsULE`], which is auto-implemented for a number of built-in types,ÁüXU including all fixed-width multibyte integers. For variable-width types like [`str`],ÁüèUR see [`VarZeroVec`](crate::VarZeroVec). [`zerovec::make_ule`](crate::make_ule) mayÁü¾ eb be used to automatically implement [`AsULE`] for a type and generate the underlying [`ULE`] type.Á¤
úü¨
VS Typically, the zero-copy equivalent of a `Vec<T>` will simply be `ZeroVec<'a, T>`.Áÿ
úüƒ ro Most of the methods on `ZeroVec<'a, T>` come from its [`Deref`] implementation to [`ZeroSlice<T>`](ZeroSlice).Áö úüú ^[ For creating zero-copy vectors of fixed-size types, see [`VarZeroVec`](crate::VarZeroVec).ÁÙ úüÝ `] `ZeroVec<T>` behaves much like [`Cow`](alloc::borrow::Cow), where it can be constructed fromÁü¾
H¤¦úl‹ä¸ú<¼³Ì¥ë— ¿úüÃOš˜ ü“-* let nums: &[u16] = &[211, 281, 421, 461];ÁÁúüÅ3ï´¬ùêÇÄ×µü¨ nums: ZeroVec<'a, u16>,Á›·ÎúüÒ&# // The owned version will allocateÁ¬ù¾°ü.+ nums: ZeroVec::alloc_from_slice(nums),Á­¹¼Å¼¹üÝOݹ­úü±+Ó±üÝAÈÔüŸ8Å»ØúüÜ,) // This deserializes without allocation!Áü‰+޾üµ41 assert_eq!(deserialized.nums.get(2), Some(421));Áüê(% assert_eq!(deserialized.nums, nums);Á<“¼³ú¼ŸËÄ·ú”»È»ÎúüÒa^ `ZeroVec<T>` represents a slice of `T` as a slice of `T::ULE`. The difference between `T` andÁü´da `T::ULE` is that `T::ULE` must be encoded in little-endian with 1-byte alignment. When accessingÁü™c` items from `ZeroVec<T>`, we fetch the `T::ULE`, convert it on the fly to `T`, and return `T` byÁ value.ÁˆúüŒyv Benchmarks can be found in the project repository, with some results found in the [crate-level documentation](crate).ÁúüŠvÀÃ’JŠ­¥®®­ÿØ ˜Ù ,¨ŽÝŠüü ûÛàAáš1&0¯°±@Büµ"¿¬¬¨ìäÚ¿¬¬Øòo<ü¿¬¬ëµFu\»Ÿ ŠŽÝüKг¥´³´ÿØ  Ù ,£ÌìŽÝ ŽÝûÛœ79ü™DŠ¥··ÿØ ©Ù ,¬Ó“
ûÛ¥ üâ+й¥ºº¹ÿØ ëÙ ,îûÛ»¼ê!ë!¼ç(*\” 4™ ¸¸ÅÛü ˜ ˜ûÛ ˜ûÛê!¸ Ë ¸
¼Š‘Ñäý$<M¿¦¾¾Íì°æ —%ÆçÛO÷N©~.\¿ Œê&ê&¿½½Úåìí'¦ÁÁè–
ò'ÆçÂÄÆüò(2”ü(¿ Æç ŠˆæÀŠÃà “)À
°æŠ$”))ü**DŠ*¿Å ÅÆç ňæÀ“*À
İæ$*ü‹1"DŽ1¿š šÆçÀ —1À
ưæ$œ1maxÁ¢1ü´9+ŠÈ¥ÉÈÉÿØ ½9Ù ,À9ûÛÊÙʹ9!#¼æ9,é9 ûÛûÛÇ ï9Ç
ÊŠ‘Ñ$ð9ü—=9ŠÌ¥ÍÍÌÿØ  =Ù ,£=ûÛÎâΜ=!#ü×=!4Ú=œ œûÛ œÅÛË á=Ë
Ί‘Ñ$â=üœ>F8¥ÐÐÿØ ¡>Ù ,Ï>¡ÍT×>òÝÑÀcÑ#%üé>4ì>žŸ  žòÝ Ÿ c cˆ¢cµ
 `£c `àB¤GS
 ­ŒÏ ð>Ï
Ñ8‘Ñ$ñ>± ÷>ü¯A18¡¥Ó¡ÓÿØ ´AÙ ,ÖAÕçÞAòÝüåA\ŠÕÖ¥×ÕÖ×ÍìØ× òAµØ×,¯B¤åL·BÔÞØ·ßØêAîA8:üÖB,ÙB¢£ ¢ÔÞ £¤ßÔ ÜBÔ
ØŠØ×$ÝB¹
,ãBüêCJ8¤8¥¥ÚÚ¥¤ø 
ïC‰¡
,¢D¤åLªDüßÛ·ßÛ$&üÉD"ÌD¦§¨ ¦üß § ¨ÐàÙ ÏDÙ
Û88Ø×$ÐD¹
,ÖDü¥E\8©¥ÝŸÞ©ÝÞÿØ ªEŸt­EÙ ,ïEœíL÷EòÝà·ßà241 ³Eü–F$™Fª« ªòÝ «âàÜ œFÜ
à8‘ÑŸ$F¹
,£FüôF-Šã¥ääãÿØ ýFÙ ,€GûÛå´åùF!#¤¶G<¹GûÛââ
劑ÑüêG=Šç¥èèçÿØ óGÙ ,öGåðTþGûÛéïßéïG*,ü®H7\±H¬­ ¬ûÛ ­ûÛΑæ ½Hæ
銑Ñ$¾H¹
,ÄHüŸI/Šë¥ìëìÿØ ¨IÙ ,«IøÚ³IûÛí»í¤I)+üÕI'ØI®¯ ®ûÛ ¯ûÛ“’ê ÜIê
튑Ñ$ÝI¹
,ãIü®J5Šï¥ððïÿØ ·JÙ ,ºJûÛñâñ³J!#ìêJ4íJ° °ûÛ °Ýî ôJî
ñŠ‘Ñ$õJü¯K8Šó¥ôôóÿØ ¸KÙ ,»KûÛõëõ´K!#üîK$$ñK¬áûÛòò
õŠ‘Ñ¹
,öKüìM!Š÷¥ø÷øÿØ õMÙ ,øMûÛùúûüýþÿñM13Ô‡Pü”N0- Creates a new, borrowed, empty `ZeroVec<T>`.ÁÉNútÑN«²äNú<ìN¼³ÌøNë— –OúüžO*' let zv: ZeroVec<u16> = ZeroVec::new();ÁÜÍO assert!(zv.is_empty());Á<íO¼³”PûÛöö
ùŠ‘Ñü¥Q&üÏPQN Same as `ZeroSlice::len`, which is available through `Deref` and not `const`.ÁL²Q± ±ûÛö ¼Qö
úŠ‘Ñ$½Qü‘\6üñZ85 Creates a new borrowed [`ZeroVec`] using an existingÁ”®[ backing bufferÁÅ[úüÍ[1. ✨ *Enabled with the `alloc` Cargo feature.*Ádž\¬áûÛöö
ûŠ‘Ñžc¸üâi=üËb0- Parses a `&[u8]` buffer into a `ZeroVec<T>`.Á€cúüˆcYV This function is infallible for built-in integer types, but fallible for other types,ÁüæcLI such as `char`. For more information, see [`ULE::parse_bytes_to_slice`].Á·dúü¿dZW The bytes within the byte buffer must remain constant for the life of the [`ZeroVec`].Ážeú„¦e
# EndiannessÁ»eúüÃeUR The byte buffer must be encoded in little-endian, even if running in a big-endianÁüfSP environment. This ensures a consistent representation of data across platforms.Áõfúlýfä¸gú<—g¼³Ì£gë— ÁgúüÉgIF let bytes: &[u8] = &[0xD3, 0x00, 0x19, 0x01, 0xA5, 0x01, 0xCD, 0x01];Áü—h®ž ü»h9מ ùhúüi! assert!(!zerovec.is_owned());Áü§i*°§ <Öi¼³\éiøüÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
ûÛÆ–öö
üŠ‘Ñ´,õiüËlAü›kE©‘ åkúdíkãýþkúü†l@’ ¤ßløüûÛöö
ýŠ‘Ñ´†»üË|-ü…{0- Returns this [`ZeroVec`] as a [`ZeroSlice`].Áº{úüÂ{JG To get a reference with a longer lifetime from a borrowed [`ZeroVec`],Áü‘|'$ use [`ZeroVec::as_maybe_borrowed`].ÁDØ|² ²ûÛ ²ÅÛö á|ö
þŠ‘Ñ$â|ôÔ¤üœ¤%" Check if this type is fully ownedÁDÛ¤³ ³ûÛö ä¤ö
ÿŠ‘Ñ$å¤üñ§;ü‰¦GD If this is a borrowed [`ZeroVec`], return it as a slice that coversÁÜÕ¦ its lifetime parameter.Áõ¦úüý¦B? To infallibly get a [`ZeroSlice`] with a shorter lifetime, useÁÔħ [`ZeroVec::as_slice`].ÁŒø§´ ´ûÛÛ¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙ ŠÅÛö Ѝö
Š‘Ñ$‹¨üü°4üìªDA If the [`ZeroVec`] is owned, returns the capacity of the vector.Áµ«úü½«>; Otherwise, if the [`ZeroVec`] is borrowed, returns `None`.Á€¬útˆ¬«²›¬ú<£¬¼³̯¬ë— ͬúüÕ¬<9 let mut zv = ZeroVec::<u8>::new_borrowed(&[0, 1, 2, 3]);Áä–­ assert!(!zv.is_owned());Áü·­*' assert_eq!(zv.owned_capacity(), None);Áæ­úüî­2/ // Convert to owned without appending anythingÁÄ¥® zv.with_mut(|v| ());ÁÜ® assert!(zv.is_owned());Áüâ®A> assert_eq!(zv.owned_capacity(), Some(4.try_into().unwrap()));Á¨¯úü°¯# // Double the size by appendingÁüد zv.with_mut(|v| v.push(0));ÁÜü¯…È
üœ°A> assert_eq!(zv.owned_capacity(), Some(8.try_into().unwrap()));Á<â°¼³tƒ±µ µûÛÛ¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙô ô õ ¨÷ ˆÐ  mjçítoéö ’±ö
Š‘Ñ$“±ÄܲŠƒƒ¬¬¹ ¯Â¿° ¿±—6¿àAáš1&0Šá²üÆ¿.Š¥ÿØ Ï¿Ù ,î¿ûÛË¿ü¹Ê.Šˆ¥ˆÿØ Âʹ‘Ñ,áÊûÛŠ¾Ê$&ü—Ð5üîÊUR Attempts to create a `ZeroVec<'a, T>` from a `&'a [T]` by borrowing the argument.ÁÈËúüÐËRO If this is not possible, such as on a big-endian platform, `None` is returned.Á§Ìúl¯Ìä¸ÁÌú<É̼³ÌÕÌë— óÌúüûÌOš˜ üÏÍI›¹
üÎ-†‡
ÏÎúü×Î:7 if let Some(zerovec) = ZeroVec::try_from_slice(nums) {Áü–Ï%" assert!(!zerovec.is_owned());ÁüÀÏ.+ assert_eq!(bytes, zerovec.as_bytes());Á,óÏ›·<ýϼ³tžÐ нãÛ¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙûÛ
ŠŠ‘Ñž,­Ð\øÐŠêƒáÊ‘ѲéŸêü£Ù.Š¥ŽŽÿØ ¬ÙÙ ,ËÙûÛ¨Ù!¼ñ„ü–„VS Remove all elements from this [`ZeroVec`] and reset it to an empty borrowed state.Á,ø„ ûÛŒ þ„Œ
Š‘Ñ$ƒ…üϤ.üˆ¤41 Truncates this vector to `min(self.len(), max)`.ÁLÖ¤ûÛûÛŒŒ
Š‘Ñ$䤙
ꤴҲüú§eb Convenience wrapper for [`ZeroSlice::from_ule_slice`]. The value will be created at compile-time,Áüà¨52 meaning that all arguments must also be constant.Á–©ú|š© # ArgumentsÁª©úü®©WT * `$aligned` - The type of an element in its canonical, aligned form, e.g., `char`.Áü†ªda * `$convert` - A const function that converts an `$aligned` into its unaligned equivalent, e.g.,ÁüëªFC `const fn from_aligned(a: CanonicalType) -> CanonicalType::ULE`.Áü²«96 * `$x` - The elements that the `ZeroSlice` will hold.Áì«útð««²ÿ«úüƒ¬<9 Using array-conversion functions provided by this crate:ÁÀ¬ú<Ĭ¼³ü̬41 use zerovec::{ZeroSlice, zeroslice, ule::AsULE};Á­úü…­ur const SIGNATURE: &ZeroSlice<char> = zeroslice!(char; <char as AsULE>::ULE::from_aligned; ['b', 'y', 'e', '✌']);Áüû­0- const EMPTY: &ZeroSlice<u32> = zeroslice![];Á¬®úü°®.+ let empty: &ZeroSlice<u32> = zeroslice![];Áüß®TQ let nums = zeroslice!(u32; <u32 as AsULE>::ULE::from_unsigned; [1, 2, 3, 4, 5]);Áü´¯(% assert_eq!(nums.last().unwrap(), 5);Á<ݯ¼³å¯úüé¯-* Using a custom array-conversion function:Á—°ú<›°¼³ü£°FC use zerovec::{ule::AsULE, ule::RawBytesULE, zeroslice, ZeroSlice};Áê°úüî°:7 const fn be_convert(num: i16) -> <i16 as AsULE>::ULE {Áü©±&# RawBytesULE(num.to_be_bytes())Á,б›·Ö±úüÚ±'$ const NUMBERS_BE: &ZeroSlice<i16> =Áü‚²74 zeroslice!(i16; be_convert; [1, -2, 3, -4, 5]);Á<º²¼³(|²êJ é² ¾´ ï² ð²*ò² õ² ¢³, ÿ²8,€³'…³8 L‡³'³8š%L’³ ›³ œ³% £³ ©³ Ú³ , ª³8alignedÁ<«³& ²³8´³³% µ³, ·³8å<¸³& ¿³8$À³% ij Ƴ Ù³, dz ȳ г, ɳ8à ʳ& ˳8$̳$ ѳ Ò³, Ô³ Õ³ ׳$ Ö³- س*ܳ ß³ »´ , é³8,ê³'ï³8 Lñ³'ú³ ü³, ý³8Þæ
<þ³ …´'†´8ã/tˆ´ –´ µ´8,—´ ´ ´´ Ÿ´  ´ ²´, ¡´ ¢´ ¯´, £´8å<¤´ «´ ®´, ¬´8Ã ­´$ °´
±´% ¼´¤’¹üÁ´eb Creates a borrowed [`ZeroVec`]. Convenience wrapper for `zeroslice!(...).as_zerovec()`. The valueÁü§µVS will be created at compile-time, meaning that all arguments must also be constant.Áþµúü‚¶>; See [`zeroslice!`](crate::zeroslice) for more information.ÁÁ¶útŶ«²Ô¶ú<ض¼³üà¶0- use zerovec::{ZeroVec, zerovec, ule::AsULE};Á‘·úü•·pm const SIGNATURE: ZeroVec<char> = zerovec!(char; <char as AsULE>::ULE::from_aligned; ['a', 'y', 'e', '✌']);Áü†¸# assert!(!SIGNATURE.is_owned());Áª¸úü®¸+( const EMPTY: ZeroVec<u32> = zerovec![];ÁüÚ¸ assert!(!EMPTY.is_owned());Á<ú¸¼³(|‚¹ûJ §¹ åº ­¹ ®¹*°¹ ³¹ ع, ½¹8,¾¹'ù8¹ <Ź'̹8æ ι ѹ Ò¹% Ù¹ ß¹ º , à¹8Þæ
<á¹& è¹8´é¹% ë¹, í¹8å<î¹& õ¹8$ö¹% ú¹ ü¹ º, ý¹ þ¹ †º, ÿ¹8à €º& º8$‚º$ ‡º ˆº, Šº ‹º º$ Œº- Žº*’º •º ⺠, Ÿº8, º'¥º8Å<L§º °º ±º Ϻ, ²º8Þæ
<³º% ºº, ¼º8å<½º% ĺ ƺ κ, Ǻ Ⱥ ˺, ɺ8à ʺ$ ̺ ͺ к8Á/TѺ Ûº ܺ% ãº\€NüóF C Traits over unaligned little-endian data (ULE, pronounced "yule").Áº úü¾K H The main traits for this module are [`ULE`], [`AsULE`] and, [`VarULE`].ÁŠ úüŽ  See [the design doc](https://github.com/unicode-org/icu4x/blob/main/utils/zerovec/design_doc.md) for details on how these traitsÁÌ“ ܨˆN§çéÎ×ôø°µ¹º¿óëfj+²
¡È>6,¯¢œhw+Ì
£åEC,¥²i„+à
¦²i–+á
¦Fd,§ÈI_,Ó©«KZ,òª¡l²+ «¡lÄ+ «º  à%­×¥  `®ž ‰f¯È=º,·ÄêW´,¸Å  ²
³
†Bœ¸è®¿ßíð˜è<P—>4Ø §øA4ä ç¡B,ð éÄE,û ³
4† δM,’ ¶Q4 ×°ä.ô£Sæ.øêSè.È=ê.°÷Vì.µœWî.¹©Wð.ºêWò.¿È>ô.¯¢åEö.¥Fø.§ÈIú.Ó©«Kü.òªºƒà%­× `®ž‰f¯È=F/·ÄêWG/¸Åò­H/óœh2/Ì
£²i4/à
¦²iM/á
¦¡l:/ «¡lS/ «Ô±%œÑ´êd
¾ášÆ
üó *ü 
GD Converts a [`char`] to a [`CharULE`]. This is equivalent to callingÁìì
 [`AsULE::to_unaligned()`]ÁŽ úü– JG See the type-level documentation for [`CharULE`] for more information.Ád€ ¾á®W¿äÖü€
JG Converts this [`CharULE`] to a [`char`]. This is equivalent to callingÁìÏ
 [`AsULE::from_unaligned`]Áñ
úüù
Jé‚ ¾á
ÜÞ¾á±üŽ7t‘· ·àåÙœ §œ
´¡êžƒÃž¡Ãžžž›ª›ªœªCharTryFromErrorÁªˆ®1 &Y}ÒZŠƖœä ¡¢·¸¡¢ƒŸŸ¾áü¥"ŸŸ
¡ü‡/ĉ ŸŸ
¢ unalignedÁL™ÜÞ¾á¤ïߤü€7¸¹ ¸¾á ¹¾áΑ£ £
¤$¹
,–¤á¾á¦»¦üü'ÿº» º¾á »¾á“’¥ ƒ¥
¦$„¹
 ø¯Õ„õ
`§©½Ù
d“
§«¼)T¡
⧬œ ¼)㧬œ  
ħ­ž  ¹ <¸
¬§®Ÿ è<ÿ§¨—>°§§¨øA¯ç§¨¡B®é§¨ÄE­§¨³
¬Î§¨´M«§¨¶Qª×§¨°7ô§¨£S7ø§¨êS‘7§¨È=“7°§¨÷V•7µ§¨œW—7¹§¨©W™7º§¨êW›7¿§¨åE†7§¨¥Fˆ7§¨§ÈIŠ7Ó§¨©«KŒ7ò§¨ªº à%§¨­×  `§¨®ž ‰f§¨¯È=Ö7·§¨ÄêW×7¸§¨Åò­Ø7ó§¨ëfÙ7²
§¨¡œhÛ7Ì
§¨£²iÝ7à
§¨¦²iö7á
§¨¦¡lã7 §¨«¡lü7 §¨«
üâ#
w,
fiSV'*ü¥3
üœc
` Allows types to be encoded as [`VarULE`]s. This is highly useful for implementing [`VarULE`] onÁü€T
Q custom DSTs where the type cannot be obtained as a reference to some other type.ÁÕ
úüÙk
h [`Self::encode_var_ule_as_slices()`] should be implemented by providing an encoded slice for each field矁b
_ of the [`VarULE`] type to the callback, in order. For an implementation to be safe, the slices矬X
U to the callback must, when concatenated, be a valid instance of the [`VarULE`] type.Á
úü…L
I See the [custom `VarULEdocumentation`](crate::ule::custom) for examples.ÁÒ
úüÖ}
z [`Self::encode_var_ule_as_slices()`] is only used to provide default implementations for [`Self::encode_var_ule_write()`]ÁüÔ j
g and [`Self::encode_var_ule_len()`]. If you override the default implementations it is totally valid toÁü¿
o
l replace [`Self::encode_var_ule_as_slices()`]'s body with `unreachable!()`. This can be done for cases whereÁü¯ j
g it is not possible to implement [`Self::encode_var_ule_as_slices()`] but the other methods still work.Áš
úüž \
Y A typical implementation will take each field in the order found in the [`VarULE`] type,Áüû d
a convert it to ULE, call [`ULE::slice_as_bytes()`] on them, and pass the slices to `cb` in order.Áüà
i
f A trailing [`ZeroVec`](crate::ZeroVec) or [`VarZeroVec`](crate::VarZeroVec) can have their underlyingÁüÊ'
$ byte representation passed through.Áò
úüöj
g In case the compiler is not optimizing [`Self::encode_var_ule_len()`], it can be overridden. A typicalÁüát
q implementation will add up the sizes of each field on the [`VarULE`] type and then add in the byte length of theÁÜÖ
 dynamically-sized part.Áò
úüö!
 # Reverse-encoding [`VarULE`]Á˜
úüœO
L This trait maps a struct to its bytes representation ("serialization"), andÁüì\
Y [`ZeroFrom`](zerofrom::ZeroFrom) performs the opposite operation, taking those bytes and矃4
1 creating a struct from them ("deserialization").Áþ
úd
ãý
úü“F
C The safety invariants of [`Self::encode_var_ule_as_slices()`] are:ÁüÚ#
- It must call `cb` (only once)Áüþg
d - The slices passed to `cb`, if concatenated, should be a valid instance of the `T` [`VarULE`] typeÁüæY
V (i.e. if fed to [`VarULE::validate_bytes()`] they must produce a successful result)ÁüÀ;
8 - It must return the return value of `cb` to the callerÁü
úü€g
d One or more of [`Self::encode_var_ule_len()`] and [`Self::encode_var_ule_write()`] may be provided.Áüè{
x If both are, then `zerovec` code is guaranteed to not call [`Self::encode_var_ule_as_slices()`], and it may be replacedÁÔä
 with `unreachable!()`.Áÿ
úüƒ@
= The safety invariants of [`Self::encode_var_ule_len()`] are:矀D
A - It must return the length of the corresponding [`VarULE`] typeÁ
úüB
? The safety invariants of [`Self::encode_var_ule_write()`] are:ÁüÐT
Q - The slice written to `dst` must be a valid instance of the `T` [`VarULE`] typeÁ
¯¥°¯°Š­ü¥¤
Å» Å
³¾
¯Š­*Š­´·±´·´±·DFüƒK
üßJ
G Calls `cb` with a piecewise list of byte slices that when concatenated矨D
A produce the memory pattern of the corresponding instance of `T`.Á÷
úüÿT
Q Do not call this function directly; instead use the other two. Some implementors矯&
# may define this function to panic.瀠
¼ ¼î¨¢–§–¯£²³²³ ¢
¯Ú– Ÿ
ë–Ô­
½¾–"¢– ½
¾à嬲
½¾¢–ã± ˜"§– Æ
±î¨‘ѧ–¢–
cbÁ©
ˆŠüž%
üÔE
B Return the length, in bytes, of the corresponding [`VarULE`] typeÁ”¡
¿ ¿î¨¯ ´
¯
´î¨‘Ñ

´êµƒÃµ¡Ãµµ´µî¨‘Ñ 
àå
´êÂƒÃ¡Ã´î¨‘Ñ –´ü® 2
ü¦M
J Write the corresponding [`VarULE`] type to the `dst` buffer. `dst` shouldÁüø1
. be the size of [`Self::encode_var_ule_len()`]Á¤±
ÀÁ Àî¨ Áàå¯ Æ
¯
ᔬԄ
ݘÑ
lÉ!
·ê¸ƒÃ¸¡Ã¸¸·¸î¨‘Ñõ´  àåüÖ*7
¥ºº·ê â*
äê4å*
ÕÓ»±»ü”+J
Ä—+
 ÂÕÓ£¹£¼½¼½ ³+
¹Í솺 °+
Íìº Ô¾+
ÃÄ"º  Ã
Äàå¬Ã+
Ãĺ öº ˜"†º ×+
»ÕÓ†º º $´+
Á± º+
ŒŽˆŠü‹,;
8Å¥¿Å¿Å» —,
³¾4š,
ˆãÀ±ÀüÍ,J
ÄÐ,
Æ Æˆã¢–§–¾£ÁÂÂÁ ì,
¾Ú– é,
ë–Ô÷,
ÇÈ–"¢– Ç
鈌Ÿ,
ÇÈ¢–Û½ ˜"§– -
À8‘ѧ–¢–$í,
Á± ó,
ˆŠüÄ-?
8É8Ê¥ÄÄÉÊòä Ð-
”å4Ó-
ãűÅüŠ.J
Ä.
Ë Ëã£Ã£ÆÇÆÇ ©.
ÃÍìø¿ ¦.
Íìó¿ Ô´.
ÌÍ–"ó¿  Ì
Íà嬹.
ÌÍó¿ èÀ ˜"ø¿ Í.
Å88Ø×ø¿ ó¿ $ª.
Á± °.
˜üÍ:U
8Î¥ÉÉÎÿØ Ù:
Ù ,;
‘Ñ<š;
¸ãÊÍα´·ÊÎÍ<>ü©;I
Ĭ;
Ï Ï¸ã¢–§–È£ËÌËÌ È;
ÈÚ– Å;
ë–ÔÒ;
ÐÑ–"¢– Ð
Ñàå¬×;
ÐÑ¢–øÃ ˜"§– ë;
Ê8‘ѧ–¢–$É;
 Ï;
ˆüÝ<%
ӈ<
Ò Ò¸ãÈ ó<
È
Í8‘Ñ$ô<
ü¹=.
¤¼=
ÓÔ Ó¸ã ÔàåÈ Ñ=
È
Î8‘Ñ$Ò=
ݘØ=
ü¿D\
8Õ¥ÐÕÐÿØ ËD
Ù ,E
¨Â <“E
òÝÑÔÕ±´·ÕÔÑ9;ü¢EI
Ä¥E
Ö ÖòÝ¢–§–Ï£ÒÓÒÓ ÁE
ÏÚ– ¾E
ë–ÔËE
ר–"¢– ×
Øàå¬ÐE
ר¢–×È ˜"§– äE
Ñ8‘ѧ–¢–$ÂE
 ÈE
ˆüÖF%
”ÙF
Ù ÙòÝÏ ìF
Ï
Ô8‘Ñ$íF
ü§G.
¤ªG
ÚÛ ÚòÝ ÛàåÏ ¿G
Ï
Õ8‘Ñ$ÀG
ݘÆG
üËH”
8ܥרÙÙÜרŻ ×H
Íìãã ÚH
ƒå ÝH
³¾4œI
¯ãã‘ÑŒ´I
¹å„ÎI
ÝãÚÝÞ±´·ÞÝÚfhbdgiüæII
ÄéI
Ý ÝÝã£Ö£ÛÜÛÜ …J
ÖÍìÄÍ ‚J
Íì¿Í ÔJ
Þß–"¿Í  Þ
ßà嬔J
Þß¿Í ´Î ˜"ÄÍ ¨J
Ú8‘ÑããÞ×ÄÍ ¿Í $†J
 ŒJ
üßK%
ӉK
à àÝãÖ õK
Ö
Ý8‘ÑããÞ×$öK
üõL.
¤øL
áâ áÝã âàåÖ M
Ö
Þ8‘ÑããÞ×$ŽM
ݘ”M
üŸS„
8ã¥àááãàÅ» «S
Ö» ®S
³¾4úS
ÍÁ„’T
ñÕâåæ±´·âæåACFHüªTI
Ä­T
ä äñÕó¿ ø¿ ߣãäãä ÉT
ß±À ÆT
ÂÀ ÔÓT
åæ–"ó¿  å
æà嬨T
åæó¿ ÕÓ ˜"ø¿ ìT
â8‘Ñ—Ñø¿ ó¿ $ÊT
 ÐT
ŠŒüÞU%
ӇU
ç çñÕß ôU
ß
å8‘Ñ—Ñ$õU
ü½V.
¤ÀV
èé èñÕ éàåß ÕV
ß
æ8‘Ñ—Ñ$ÖV
ݘÜV
 Ñ,ü‹ üËb_ Given `Self` (`$aligned`), `Self::ULE` (`$unaligned`), and a conversion function (`$single` orÁü®[X `Self::from_aligned`), implement `from_array` for arrays of `$aligned` to `$unaligned`.ÁŠúüŽC@ The `$default` argument is due to current compiler limitations.ÁüÒ(% Pass any (cheap to construct) value.Á(|û K ¬
 ² ê, ³8Þæ
<´& »8´¼$ ¾, À8¤‰ & Ê8´Ë$ Í, Ï8>& ×8$ Ü, Þ8singleÁ& å8õ
*ì ï ƒ + ù ú ë8Óû ÿ8¨4  ˆ ê
7Convert an array of `Á¼‰$  8Ô « ¬ µ, ­8Þæ
$ 7` to an array of `Á¤¸$ Ì8Ô × Ø ã, Ù8¤‰ $ ä7`.Á8õ88 ÿ8îgT Œ8,8Ÿ & 8¬,  œ ¯8û‡&   ¢ ®, £8Þæ
% «8Ÿ ­(± ´ ¼8% ¹8Ÿ » ¾ ý8Ì8Ð8  Û Ý é, Þ8>% æ8Ÿ è% ê8ø8ü8´  7ˆ % + Ñ Ò ó8 Ù ò8'à8indexing_slicingÁ„â8%,8´  8Ÿ   à 8  ¥ §8´ ¦ ©, «8ÖÙ  ² ¹8û‡³  ¸8´ ·% º8´ ÌÎ7 Ñ% Ò8 %  Š  ´ , 8Þæ
& 8´$ , ˜ 8¤‰ L™ & ¢ 8´£ $ ¥ , § 8>& ¯ 8* ¹ 
8†BœÃ  Ö  ×  Š
 , Ø 8Þæ
$ à , â 8¤‰ $ ì , î 8>$ ö 8'ü 8Ž=%
%
  4ƒÌ
Í
e´ü 
éëÕ„¥ `éì¯ ½×æ  `éíè<ï4éê—> 4§éêøAŸ4çéê¡Bž4ééêÄE4éê³
œ4Îéê´M›4éê¶Qš4×éê°}côéê£ScøéêêScéêÈ=ƒc°éê÷V…cµéêœW‡c¹éê©W‰cºéêêW‹c¿éêÈ>c¯éê¢åEcéê¥F‘céê§ÈI“cÓéê©«K•còéꪺ7à%éê­ž
7‰féê¯È=Çc·éêÄêWÈc¸éêÅò­ÉcóéêëfÊc²
éꡲiµcà
éꦲiÎcá
éꦡl»c éê«¡lÔc éê« üÝ5  ì˜ þ éüÐL ÇBïÒBððïÇB„Õ Íìûä `ûä„ï Ãäñóöùûýþ=Û 46ü· > ü£Q N Compute the amount of bytes needed to support elements with lengths `lengths`Á¼¾ ÇBîî
ñÇBûälengthsÁ<Ö üÉ  üî V S Construct a partially initialized `MultiFieldsULE` backed by a mutable byte bufferÁüÐ & ôÁí ôàå ôÃäî÷ î
óÇBûäíì <„
»
)+ü´Ž ü›h e Given a buffer of size obtained by [`Self::compute_encoded_len_for()`], write element A to index idxÁˆ úd ãýä¡  - `idx` must be in rangeÁüÂ_ \ - `T` must be the appropriate type expected by the custom derive in this usage of this typeÁd êë êÃä ëüØî¥÷øø÷  îòä Ï ÎìüØ ã ”å ¯üØØ×Œæ
öÇBûäØ×üØ$ éÉž » `b\^ü½] üI F Validate field at `index` to see if it is a valid `T` [`VarULE`] typeÁë ú ãý úôŒ  - `index` must be in rangeÁtË ì ìÃäÙî¥úú î îòä Ú ”å
ùÇBûäØ× Ö .0ü¾F üë- * Get field at `index` as a value of type TÁ ú ãý úô¾ õó üáJ G - Element at `index` must have been created with the [`VarULE`] type TÁLÌ í íÃä íØ×î¥üü ê îòä Ö ”å
ûÇBûäØ× Ö .0ü„9 üÛ  Construct from a byte sliceÁÿ úd‡ ãýü˜Y V - byte slice must be a valid `VarZeroLengthlessSlice<[u8], Format>` with length `LEN`Á¤’ î îàå îÃäî ® î
ýÇBûä´ üƒ" üÛ!# Get the bytes behind this valueÁDŠ" ï ïÃä ïàåî “" î
þÇBûä$”" üÈ"[ ÇBÒBêë „Í" øë 4ß" ‰ì „ç" ÃäÀc#Ó" #%üª#4 ­# ðñò ðÃä ñ c cˆ¢cµ
 `£c `àB¤GS
ò­Œÿ ±# ÿ
ÇBûä$²# ± ¸# ÉEŒ‘& é®å}ÿJãeõ!Û®åÉE9é®åƒƒ
,£& 郃ü¬&6 ®åб´·Šüé&I Äì& ó ó®å££ˆˆ ˆ' ÍìØ€ …' ÍìÓ€ Ô’' ôõ"Ó€  ô
õà嬗' ôõÓ€ È ˜"Ø€ «'
Ø€ Ó€ $‰'  ' ˆü(% ” ( ö ö®å ³( 
Š$´( üí(/ ¤ð( ÷ø ÷®å øàå …) 
$†) _dstÁ$Œ) üó.^ ÇBÒBŽŽêë „ÿ. øë 4‘/ ‰ì „™/ ÃäÀÂ.…/ .0üà17 üØ/p m Note: `MultiFieldsULE` is usually used in cases where one should be calling .`validate_field()` directly forÁüÍ0< 9 each field, rather than using the regular `VarULE` impl.ÁŽ1 úü–17 4 This impl exists so that `EncodeAsVarULE` can work.Átã1 ù ùàåÙŒ ù1 Œ
ÇBûäž,ò1 í2 êćÃÇBûä ò‹üŽ35 ¤˜3 ú úàå úÃäŒ ´3 Œ
ÇBûä´,­3  2Fà
á
n$Ý Š n÷V,á µÈ=è °È=·Ä”Ï k,Ù IK8:üÞ$ üï^ [ The [`ULE`] types implementing this trait guarantee that [`NicheBytes::NICHE_BIT_PATTERN`]ÁüÎ? < can never occur as a valid byte representation of the type.ÁŽ úü’* ' Guarantees for a valid implementation.Áü½I F 1. N must be equal to `core::mem::sizeo_of::<Self>()` or else it willÁ¤‡  cause panics.Áüœb _ 2. The bit pattern [`NicheBytes::NICHE_BIT_PATTERN`] must not be incorrect as it would lead toÁ¼ÿ  weird behaviour.Áü—N K 3. The abstractions built on top of this trait must panic on an invalid N.Áüæ] Z 4. The abstractions built on this trait that use type punning must ensure that type beingÁÌÄ  punned is [`ULE`].Á Ÿ˜˜Š­üÞN î tó Š­!Š­'™& ù ü‰ Œ ŸüÂA ü®M J [`ULE`] type for [`NichedOption<U,N>`] where U implements [`NicheBytes`].Áüü1 . The invalid bit pattern is used as the niche.Á® úü² _ \ This uses 1 byte less than [`crate::ule::OptionULE<U>`] to represent [`NichedOption<U,N>`].Á
úl
两
ú
¼³ì°
 use core::num::NonZeroI8;ÁüÎ
# use zerovec::ule::NichedOption;ÁÌò
ë— Œ úü * ' let bytes = &[0x00, 0x01, 0x02, 0x00];Áü» 4 1 let zv_no: ZeroVec<NichedOption<NonZeroI8, 1>> =Áüð O L ZeroVec::parse_bytes(bytes).expect("Unable to parse as NichedOption.");ÁÀ úüÄ 6 3 assert_eq!(zv_no.get(0).map(|e| e.0), Some(None));Áüû C @ assert_eq!(zv_no.get(1).map(|e| e.0), Some(NonZeroI8::new(1)));Áü¿
C @ assert_eq!(zv_no.get(2).map(|e| e.0), Some(NonZeroI8::new(2)));Áüƒ6 3 assert_eq!(zv_no.get(3).map(|e| e.0), Some(None));Á ¼³ ¦œŸœè–
Ü î tô °æŸ °°æï öåšuV»<ãž NPS ú   ¥‘   °æüán ¦¢Ÿ£¢£è–
æ î t‘ ”™  ª™ ù ¿c°æ„ÿ öå¤Àc¤;=@  üÖD Ù ûüý ûöå ü c cˆ¢cµ
 `£c `àB¤GS
ý­Œ¡ Ý ¡
¤°æŸ ± ä üÀB ¦¦Ÿ§§¦è–
Å î tÝ ”™  ª™ Ø ö娩ª)+. ã ü¾" ü‰0 - New `NichedOptionULE<U, N>` from `Option<U>`ÁÅ Öö奥
¨°æŸoptÁÉ ìè ìÆ  Convert to an `Option<U>`Áï öåÖ¥¥
©°æŸ üÆ" ü¢  Borrows as an `Option<&U>`.Á4Í þ þöåÛ¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙ þ°æ¥ Ô ¥
ª°æŸ ü„K ¦¬Ÿ­­¬è–
 î t¡ ”™  ª™ œ öå "% § üÔL ¦¯Ÿ°°¯è–
Ù î tñ ”™  ª™ ì öå±Ù±+-0 ÷ ¼§  ÿ ÿöåöå® ° ®
±°æŸ üØ\ ¦³Ÿ´³´è–
Ý î t ”™  ª™ ð µß°æ°æ öåµ·ßµACF  ü»" ¾  öå öå² Á ²
µ°æŸ ¹
 üN ¦·Ÿ¸¸·è–
 î t¯ ”™ l• ª™ ¥ °æ« öå025 µ ü‡&Q Äà  Safety for ULE traitÁüùX U 1. `NichedOptionULE` does not have any padding bytes due to `#[repr(C)]` on a structÁüÒ "  containing only ULE fields.Áüõ W T `NichedOptionULE` either contains `NICHE_BIT_PATTERN` or valid U byte sequences.ÁüÍ!- * In both cases the data is initialized.Áüû!e b 2. `NichedOptionULE` is aligned to 1 byte due to `#[repr(C, packed)]` on a struct containing onlyÁ”á"  ULE fields.Áüô"O L 3. `validate_bytes` impl returns an error if invalid bytes are encountered.ÁüÄ#D A 4. `validate_bytes` impl returns an error there are extra bytes.Áü‰$< 9 5. The other ULE methods are left to their default impl.ÁüÆ$f c 6. `NichedOptionULE` equality is based on ULE equality of the subfield, assuming that `NicheBytes`Áü­%Y V has been implemented correctly (this is a correctness but not a safety guarantee).Á¦ºŸ»º»è–
“& î t«& ”™ l& ª™ ¦& öå¼±¼+-0 ±& üß&C tâ&  àåÙ¹ ø& ¹
¼°æŸ´,ñ& <Ð* ¼ê½ƒÃ½¡Ã½½¼½°æŸ–´Ùüú06 ¦¿ŸÀ¿Àè–
ÿ0 î t‚1 ÿæÁ´Á ˆ1 ¤·1 <º1 ÿæ¾¾
Á°æŸüê1\ ¦ÃŸÄÄÃè–
ï1 î tù1 µ°æ,ò1 °æŸl¸2 ÿæÅÆÇ·¸ÇÆZ\_ ÿ1 DÍ2 Ò2 ÂÂFžÄE ÑFšuV»<㜲 Ÿüù2" dü2 ÿæÿæÂÂ
ưæŸ$‰3 üã3/ tæ3 å³ ÿæÂÂ
ǰ柤‰ Lõ3 ü7; ¥ÉŸÊÊÉlj ¢7 î t¥7 ¸èËÌÍÉLÈLÊLÍ)+. «7 lß7 Dä7 ÈÈÍéÉLLš8 $Ÿ8 ÈÈÕÓü®8$ L±8 ¸è¸èÉLÈÈ
ÍÕÓŸ$»8 T‚ ¼\ÓÔòó®¿ßÎÐëµ\„ÎÑëµÎÑ‚ŽÑÛÎÒè<Ý]ÎÏ—>Ž]§ÎÏøA]çÎÏ¡BŒ]éÎÏÄE‹]Îϳ
Š]ÎÎÏ´M‰]Î϶Qˆ]×ÎϰôÎÏ£SøÎÏêSÎÏÈ=°ÎÏ÷VµÎÏœW¹ÎÏ©WºÎÏêW¿ÎÏÈ>¯ÎÏ¢åEÎÏ¥FŒÎϧºØ_à%ÎÏ­×Û_ `ÎÏ®žÞ_‰fÎϯÈ=›Œ·ÎÏÄêWœŒ¸ÎÏÅò­ŒóÎÏëfžŒ²
ÎÏ¡œh ŒÌ
ÎÏ£²i¢Œà
ÎϦ²i»Œá
ÎϦ¡l¨Œ ÎÏ«¡lÁŒ ÎÏ«œÝÌö
´•è´Fü®MJ This type is the [`ULE`] type for `Option<U>` where `U` is a [`ULE`] typeÁüúl€ä¸Žú\’Á¿Ìžë— ¸úü¼(% let z = ZeroVec::alloc_from_slice(&[Á”å Some('a'),Áœø Some('á'),ÁœŒ Some('ø'),Ál 
None,Áœ® Some('Å‚'),Á ]);ÁÊúüÎ+( assert_eq!(z.get(2), Some(Some('ø')));Áüú%" assert_eq!(z.get(3), Some(None));Á< ¼³¦ÕÕè–
¾øèÛEfµU­]OÔÖ×öŽøè´FUÎöŽøèÓÓ
Ô°ærtÎÓÓÎÓÓöŽÔÙ¦ÙÙè–
ÞŠ °æøèÚÛ ì üú! Obtain this as an `Option<T>`Á§øèÖØØ
Ú°æüâ "üŸ >; Construct an `OptionULE<U>` from an equivalent `Option<T>`Áé ÖøèØØ
Û°æÒ í ü­ 6¦ÝÝè–
² Ã ïš øèÞÀcÞ#%üê 8í ƒ ƒøè  c cˆ¢cµ
 `£c `àB¤GS
­ŒÜ ñ Ü
Þ°æ ± ø ü”(ü…30 zeroed or valid-T byte sequences to fill it)Á¦ààè–
 ª™ £øèá±áüÃ7 àåÙß Üß
á°æ´«áêÂâƒÃâ¡Ãââáâ°æ üÃ"¥äälj È؉ ,ËÍéåæç·¸çæ-/ñããÓÓÔÈIÖˆÎ×Î ÛEfµU­]OðÐüŽ*d‘Íé€Ë ãã
æÕÓüø3€Ë Íéãã
çÕÓ¹
üâ#¦ééè–
çà øèüŠ$¦ëëè–
à $’øèìÙì¼µ øèøèê ¾ê
ì°æ$¿üæ4¦îîè–
ëà ©¤ øèï·ßï$&ü¡"¤ˆ ˆøè øèí §í
ï°æ¹
üó&¦ññè–
øà ¨¦ øè^GüžJG A type allowing one to represent `Option<U>` for [`VarULE`] `U` types.ÁéúÁ¿üù# use zerovec::ule::OptionVarULE;Áä ߬º úü¾ B? let mut zv: VarZeroVec<OptionVarULE<str>> = VarZeroVec::new();Á!úü…!&# zv.make_mut().push(&None::<&str>);Áü¬!'$ zv.make_mut().push(&Some("hello"));ÁüÔ!'$ zv.make_mut().push(&Some("world"));Áüü!&ÙÑ £"úü§"2/ assert_eq!(zv.get(0).unwrap().as_ref(), None);ÁüÚ";8 assert_eq!(zv.get(1).unwrap().as_ref(), Some("hello"));Á<#¼³dž$¦ôôÎì°æ «$¿°æ4®$ÎêÇj¤»¿!¾óõö÷žàåÎê^GsΞàåÎêòò
ó°æŠŒt¿$Îòòž$Ï$Îòò$Õ$ÎòòàåüÝ$(¦ùù¨Õ â$¹Õ 4å$Îêúü³%"üŒ%" Obtain this as an `Option<&U>`Á4º%Š ŠÎêÛ¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙ Š°æø Á%ø
ú°æ$Â%üÇ'D¦üü¨Õ Ì'¹Õ 4Ï'ïš Tá'ÎêýÀcý#%ü’(8•(Œ Îê Œ c cˆ¢cµ
 `£c `àB¤GS
­Œû ™(û
ý°æ$š(±  (üš.:¦ÿÿ¨Õ ¦.¹Õ 4©.ÎêÀÂ&(üé.7tì.Ž ŽàåÙþ ‚/þ
°æž,û.üñ45¤û4 àå Îêþ —5þ
°æ´,5üæ6w¥ƒ¦ƒlj ò6Îìþë õ6¯ÕÓþ댳7¿þë4Í7Í鈱´·ˆ^`Z\üä7IÄç7 Í颖§–£ ƒ8Ú– €8ë–Ô8–"¢– 
à嬒8¢–‹à ˜"§– ¦8
ÕÓþë§–¢–$„8 Š8ŠŒü˜9%”›9 Íé ®9
ˆÕÓþë$¯9üð;.¤ó; Íé àå ˆ<
ÕÓþë$‰<ݘ<üó?B¦¨Õ ø?¹Õ 4û?©¤ L@Îꌷߌ$&ü¼@"¿@ Îê ÎêŠ Â@Š
Œ°æ$Ã@¹
,É@ü”A4¦ŽŽ¨Õ ™A¹Õ 4œA¨¦ ®AÎêüÍAD¦¨Õ ÒA¹Õ 4ÕAíß°æ°æTçAÎêïß13ü˜B7\B˜ ˜Îê ÎêΑ §B
°æ$¨B¹
,®BüŽC6¦¨Õ “C¹Õ 4–Cº°æ¨CÎê»+-üËC'ÎCš šÎê Îê“’ ÒC
°æ$ÓC¹
,ÙC Pu Æ ð ª ä †BœÛè Ęž   NonZeroI8ÁLè–š NonZeroU8ÁL¡¤”è<£v—>Tv§øASvç¡BRvéÄEQv³
PvδMOv¶QNv×°ô£SœøêS¯È=°÷VÕµœW蹩WûºêW¿È>!¯¢åE8¥FO§ÈIfÓ©«K}òªºÐxà%­×Óx `®žÖx‰f¯È=·ÄêW­¸Åò­ÇóëfÛ²
¡œhòÌ
£²ià
¦²iá
¦ÔÔ4„ô$ìïüÁ#ŸŸÁ잟 ÌüùD€œ œÁì œàåœ œ
žŸüÄ@ÄË àå 
Áìœ ëœ
ŸŸ´ü¿
2Ÿ¡¡”ï
Á좱¢ Ñ
ü†7t‰ž žàåÙ  Ÿ 
¢Ÿ´ü5Ÿ¤¤”ï t’Áì¦ë¦ ˜ü×"úíÁ죣
¦Ÿle_bytesÁDßüœ,ü© É ' Ï ø , Ð8unsignedÁ& Ù8´Ú$ Ü, Þ8Å
& å8´æ, é ê ö$ ë, í8floatÁ& ó8´ô- ÷*ú ý þ&"8,‡8 & Ž   8Ó4•  œ 8š<'¤ ¦, §8×ò  ° ± ²´8š'¾ À, Á8Å
 È É Ê, Ì Í þÎ8š'Ø Ú, Û8×ò  ä å æè8š'ò ô, õ8Éó  û ü ý- ÿ% 88¡l\‘ œ  8š'¦ ¨, ©8×ò  ² ³ ´ · ¹ Ù-+ Ç È ó8ÓÉ Í8¨ Õ Ö ò
7Gets this `RawBytesULE` as a `Áü× $ ÷8Ô  ƒ , 8×ò D…$ Ž7B`. This is equivalent to calling [`AsULE::from_unaligned()`] on [`ÁüD$ Ô8Ô ß à ê, á8×ò $ ë7`].Á+   8Ý88,8 ¡8ñn ³ ¹ ´8(», ¾8×ò D¿ È  Ú, Û8×ò  ä'å8
from_le_bytesÁ ô û8 ù7ˆ ú+ ˜  Â8Óš ž8¨ ¦ § Á
7Íø ü¨ $ È8Ô Ó Ô Þ, Õ8×ò $ ß7¸ù üáD$ ¥8Ô ° ± ¹, ²8Å
$ º7Çú + Ð Ñ Ø8Ý8æ88 ð8ˆo   8$(ˆ, 8Å
  Ò ¥, ¦8Å
 ­'®8Šü  ½ Ä8 Â7ˆ Ã, á â Á
+ ô õ š8Óö ú8¨  ƒ 
7Íø ü„ $ ¤8Ô ¯ ° ·, ±8Éó $ ¸7¸ù üºD$ þ8ÔL€  Š , 8Éó $ 7Çú ,”+ ¬ ­ ´8Ý8Æ88 Ð8Öq Û á Ü8(ã, æ8Éó  í ³ ƒ, 8Éó ,… Š'8Šü l š ¡8$› Ÿ7ˆ  - Â+ Ñ Ò ü8ÓÓ ×8¨ ß à û
7 Converts a `Á$ ï8Ô ú û , ü8×ò $ 7S` to a `RawBytesULE`. This is equivalent to calling [`AsULE::to_unaligned()`] on [`ÁüˆU$ Ý8Ô è é ó, ê8×ò $ ô7Çú + Š  8Ý8 88 ª8Ž=d­ ¹ Ê8»& ¿, Á8×ò (Ì8 Ô Œ8 ê þ8» ð8 to_le_bytesÁ ü ý8†Bœ› ® ¯ Î
, Á8×ò $ Ê8¡l ç è 8š'ñ ó, ô8×ò  ý þ ÿ $ ƒ8¡l\•   À ¡ ¿7ˆ ¢% £ ¥ ¾8š'® °, ±8×ò  º » ¼% Ï8öN¤ä ø ù 8Œp$ , 8×ò % 8×N¼  ´  µ  ¿ , 8×ò % À 8öN¤Ë  ß  à  õ 8q$ ì , î 8Å
% ö 8×N¼€! —! ˜!  !, ™!8Å
4š!% ¡!, ¬! ­! û&8öN¤š& ®& ¯& Â&8•tT°&$ º&, ¼&8Éó ,½&% Ã&8×N¼Ñ& è& é& ð&, ê&8Éó ,ë&% ñ&- ü&% ÿ&ü„'$¼‘' ©' ¤0 ¯' ¸', °'8baseÁ$±'& µ'8´¶'*º' ½' ¡08$Ç'8 LÌ' Õ', Ö'8ËŽ
$×' Û' Ý' 0<g This function can be used for constructing [`ZeroVec`](crate::ZeroVec)s in a `const` context, avoidingÁüë'j<ú” œâ(<ú)<R This cannot be generic over `T` because of current limitations in `const`, but ifÁü’)U<W this method is needed in a non-`const` context, check out [`ZeroSlice::parse_bytes()`]Áüô)Z< instead.ÁdÛ*<úô*<* See [`ZeroSlice::cast()`] for an example.Áü„+-8¾+8,Â+8 È+8¦ptË+ Ù+ æ+8´,Ú+& ß+ á+ â+ å+8Èã+(è+8Í4ë+ ñ+ ò+8$ó+$ ÷+8ò­Dù+ , ƒ, 08•,8™, ,8´,Ÿ, ¤,8¥, ¨, ©,% ª,8,¼,8¼p4Â,& È,8¬,Ê, Ð,8š<Ò,'Ù, Û,, Ü,8ËŽ
$Ý, á, â, ã,% ä,+ ö, ÷, -8«,ø, ý, -84þ,'„-8
modulo_oneÁT†-8£- ¦- Ó-8§-8¼p4ª-±-7 ´- ¶- ¼-8¸-8$¾- Ã- Ò-8Å- É-8¼p4Ë-Õ-7ˆ Ø- Ú- ±.8«ð- ò- Ÿ.8"4ó- ú- ž.8$ü-'€.8œ¤‚. . œ.8´,—.8$³. ¸. ƒ08Î. Ñ. ñ/8ò­DÒ.'Ú.8‚®lÜ. ê. ð/8´„/& †/8¨4ˆ/ Ž/ / ¼/7<const construct: Á¤/$ ¤/8ÔL¦/ ¯/ °/ ¶/, ±/8ËŽ
$²/$ ·/7¹/$ ½/8×/$ Ú/% ¢0ü§0!¤´0 É0 œ8 Ï0 ê0 , Ð08 single_fnÁLÑ0& Ú08¼,Û0$ à0, â08!$ã0& ç08´è0*ì0 ï0 ™88$ù08Š$þ0 1, ƒ18!$„1 ˆ18
Š18¡l\Ž1 ™1 š1 ¯18š<œ1'£1 ¥1, ¦18!$§1 «1 ¬1 ­1 °1 ²1 ¶2+ À1 Á1 È18Ý4Â18 Ö18÷$Ù1 Ý1 ê18»,Þ1& ã1, å18!$æ1(ì18$ï1 ô1 ¬28$†2 Š2 ž28»,2 28¡ˆ
\2 œ2 28$À28÷V,Å28
Ë2, Ï28!$Ð2 Õ2 ¶58!$ã28È=è2 ì28¡l\î2 ù2 ú2 38š<ü2'ƒ3 …3, †38!$‡3 3 Œ3 3 3% 3+ Ÿ3  3 §38Ý4¡38 µ38Ó=d¸3 Ä3 É38$Å3(Ë38$Î3'Ò38È=Ô3 Ø3 48¡l\ê3 õ3 ˆ48$ö3 ú38¡ˆ
\û3 †4 ‡4+ ¤4 ¥4 ¬48Ý4¦48 º48ç=t½4 Ë4 à48¤‰ LÌ4& Õ48$×4'Û48È=Ý4(â48$å4 ê4 ¬5 ü4, ý48!$þ4 5'ƒ58Šü l…5 ’5 ž58¤‰ L“5 œ57ˆ 58"4Å68$Ì68œW,Ñ68
×6, Û68!$Ü6 á6 â68$í68¡l\ò6 ý6 þ6 “78š<€7'‡7 ‰7, Š78!$7 7 7 7 ”7 7 “8 8¤78,¨78 ®7, ±78ˆ›
L²7 »7 Ä78Á ¼7& ½7, ¿78!$À7(Æ78$É7 Î7 ‰88¡l\à7 ë7 û78Á ì7 í78¡ˆ
\î7 ù7 ú7% š8´ˆ=¬±¬ü³=8t¶=Ÿ ŸàåÙ« Í=«
¬_bytesÁ4Å=Œ†>®¯°·¸¯°Dž>£>­­üÁ>"dÄ>­­
¯$Ñ>ü‹?/tŽ?´©
­­
°¤‰ L?Ä„@ì€Dæô³±³ü²D7tµD   àåÙ² ËD²
³´,ÄDŽE³ê´ƒÃ´¡Ã´´³´ÿÉ ÙÄ­Fæô·¸·¸¸·DÌFÑFµµæôüïF"dòFæôæôµµ
·$ÿFü¹G/t¼Gò¬
æôµµ
¸¤‰ LËGü†HæôüªH æô¼ ºHüÑH Œ×HººÞí ïH´«L¿±¿üÖL8tÙL¡ ¡àåÙ¾ ðL¾
¿À§
4èLŒ©MÁÂ÷¸ÂÃDÁMÆMÀÀüäM"dçMÀÀ
Â$ôMü®N/t±Nž°
ÀÀ
ä‰ LÀNħOÄÄOïõÆÇÈ·¸ÈÇDãOèOÅÅæôü‹P"dŽPïõïõÅÅ
Ç$PüÛQ/tÞQƒ²
ïõÅÅ
Ȥ‰ LíQÄîXʱÊü›Y7tžY¢ ¢àåÙÉ ´YÉ
Ê´,­Yœ›\ÌÍη¸ÍÎDµ\º\ËËüØ\"dÛ\ËË
Í$è\ü¢]/t¥]Å´
ËË
Τ‰ L´]Ô^´«bѱÑüÖb7tÙb£ £àåÙÐ ïbÐ
Ñ´,èbŒœdÓÔÕ·¸ÔÕD´d¹dÒÒü×d"dÚd
ÖÎר´MÕר¶QÔ×ר°ôר£Sœø×ØêS¯×ØÈ=Â°×Ø÷VյרœWè¹×Ø©Wûº×ØêW¿×ØÈ>!¯×Ø¢åE8ר¥FOר§ÈIfÓר©«K}òרªºà%ר­× `ר®ž‰fר¯È=·×ØÄêW­¸×ØÅò­ÇóרëfÛ²
ר¡œhòÌ
ר£²ià
ר¦²iá
ר¦¡l7‘ ר«¡l7‘ ר«ü²2¥ÚŸÛÛÚlj ¾î tưÕÓÁäöݱÝ+-0 Ìüù7¤ ¤àåÙÙ Ù
ÝÕÓŸ´,‹ü­/¥ßŸààßlj ²î t¼؉ ,µäöâäå·¸äå57: ÂèÞÞðПü"däöäöÞÞ
äÕÓŸ$üì/£Á
äöÞÞ
åÕÓŸ¤‰ üÐ 6¥çŸèèçlj Ü î tæ ¹ÕÓäö "% ì Ô¿ëíïÀÁÂïíëüî7¥ ¥àåÙê ê
ë´,€ÔëêÂìƒÃì¡ÃììëìÅÏÅÏ Utf8ErrorÁÆÏ valid_up_toÁ¯vÇÏ error_lenÁ¯vlÅooÛÜ èÆ–ü7¦ ¦àåÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
 ¦Æ–ê ³ê
í´ƒíêÂîƒÃî¡ÃîîíîçÄ
ü®5ü¬JG Invariant: must be safe to call when called on a slice that previouslyÁüû  succeeded with `parse_bytes`Á¤¸§ §àå §ê Ôê
ï´üú/üda Note: [`VarULE`] is well-defined for all `[T] where T: ULE`, but [`ZeroSlice`] is more ergonomicÁü‚2/ when `T` is a low-level ULE type. For example:Áµú
```no_runÁìÇ # use zerovec::ZeroSlice;Áô哹ô„ # use zerovec::ule::AsULE;Áü£  // OK: [u8] is a useful typeÁüÄ/, let _: VarZeroVec<[u8]> = unimplemented!();Áôúüø;8 // Technically works, but [u32::ULE] is not very usefulÁü´@= let _: VarZeroVec<[<u32 as AsULE>::ULE]> = unimplemented!();Áõúìù // Better: ZeroSlice<u32>Áü—96 let _: VarZeroVec<ZeroSlice<u32>> = unimplemented!();Á¼³ÙúüÝ# [`ZeroSlice`]: crate::ZeroSliceÁ¥ññlj Ͼ
¥¸ÛòóÀÂóò&(ü¾7¨ ¨àåÙð ×ð
òÕÓžü²5¤¼© ©àå ©¸Ûð Øð
óÕÓ´ ÌË ULE impls for tuples.Áåúüéqn Rust does not guarantee the layout of tuples, so [`ZeroVec`](crate::ZeroVec) defines its own tuple ULE types.ÁÛúüß\Y Impls are defined for tuples of up to 6 elements. For longer tuples, use a custom structÁü¼*' with [`#[make_ule]`](crate::make_ule).Áçú«²úú¼³̆ë—  ṳ́ // ZeroVec of tuples!Áü¾RO let zerovec: ZeroVec<(u32, char)> = [(1, 'a'), (1234901, '啊'), (100, 'अ')]Á|©¤Œ¡ .copied()Áœ³ .collect();ÁÇúüË74 assert_eq!(zerovec.get(1), Some((1234901, '啊')));Á¼³
˜
Á
Â
ö
÷
·×¤ `ôöè<£­ôõ—>§ôõøAçôõ¡BéôõÄEôõ³
Îôõ´Môõ¶Q×ôõ°ôôõ£SœøôõêS¯ôõÈ=°ôõ÷VÕµôõœWè¹ôõ©WûºôõêW¿ôõÈ>!¯ôõ¢åE8ôõ¥FOôõ§ÈIfÓôõ©«K}òôõªºЯà%ôõ­ž¾¯‰fôõ¯È=·ôõÄêW­¸ôõÅò­ÇóôõëfÛ²
ôõ¡œhòÌ
ôõ£²ià
ôõ¦²iá
ôõ¦¡l7‘ ôõ«¡l7‘ ôõ«,ó´ª Á ¿$ Ç ú , È8Ð & Í8¼$ Ó, Õ8Ö& Ù8«$ á ã ù, å æ õ, ç8¿ è& é8¼, ð8´ ñ& ò8¯ó$ ö ÷*ü ÿ ¼$Æ+  Š É8Ó 8¨4‘  ˜ È7ULE type for tuples with ÁÜ™$ ´, 8·$ º7
elements.Á+ Ó Ô ä8  Ù ã8 Ú$ Û8¿
+ î ï 8« õ 8'ü8exhaustive_structsÁ”þ8¥8, °8Ð  µ,  · º, ¸8¿ ¹$ » ¼ ½ ¾ Ê, ¿ À Ç8Á, Å8¿ Æ$ È É% Ë8"4´8 ¿, À Á É, Â8¿ Ã& Ä8È=Æ$ Ê Ë Ì8È=Î8
Ò, Ö8Ð  Û, Ü Ý à, Þ8¿ ß$ á â ã å á 8 ó8—'  8´,…& Š Œ  8ÈŽ(8Í4– œ  ž$ Ÿ8ò­ © « ×88 ule_bytesÁL‰ 7ˆ¬4•, œ  ¯ ž8š< '§ ©, ª8¿ « ¬ ­ ® °% ±8Ã8´ Ë8Ì Ï Ð Ò8ˆå
Þ7ˆ á ã ¼88 ƒ ©8ò­D„'Œ8ÉX' 8$—  œ ¨8´, ¢8£ ¦ §% ª8
Î8chunkÁ8Ø8´ à8chunksÁ ç ñ8ˆå
 ó ² 888´  7ˆ % , ¬ ­ Ÿ8Ç8µ Ë Í8´ Ï% Ð8´ êì8š'ö ø, ù8¿ ú û ü ý% þ+ ˜  º8   ¹8'§8àß „© æ, ç8¿ è é'ê8—' ú  û8©è
  8µ !ƒ8´ - ˆ%   8«Ä Æ É Ç È8 ð, ñ ò ü, ó8¿ ô& õ8÷V$ ý þ ÿ8÷V,8
  , Œ  , Ž8¿ $    ¿8!8È=¨ ¬, ®8Ð  ³, ´ µ ¿ , ·8¿ ¸ ¹'º8È=¼$ À Á Â% Ã+ Ò Ó Ú8Ý8 è8Ó= ÷ ü8(þ8$'8È=  ò, 8Ð  ¢ ä, £ ¤ á8 ¾, ¿8´ À Á8Ó= Î Ï$ â ã+   8Ý8 8ç= ¨ ½8¤‰ & ²8$´'¸8È=º(¿8 Ç µ Ù §, Ú Û ¤ ñ, ò8¿ ó ô'õ8ç=  8¤‰ L† , 8´ $ ¥ ¦8 Î, Ï Ð å, Ñ8¿ Ò& Ó8×Õ'Ø8p à8È=â$ æ ç è8×ê'í8p8
õ, ù8Ð  þ, ÿ  ƒ, 8¿ $    ˆ ˜
8 8× œ ¾
 8$ ¢8± ¤& ¥ §8¨8׬'¯8ˆ º:8» ½(À8Í É Ê Ë$ Ì8×Î'Ñ8Œ Ø Ú Ž ì ù, í î ö8 ó, ô8´ õ$ ÷ ø ú8×û þ 8± ÿ8 ù, ú û , ü8¿ ý& þ8²L€ Š8È=Œ$   8²L”8
ž, ¢8Ð  §, ¨ © ¬, ª8¿ «$ ­ ® ¯ ± ®8 ¿8Â Ä Ø Å8$ Ê8¹
& Ñ Ó8(Ú8º â ¤ ô , õ ö þ8 û, ü8´ ý$ ÿ  8ƒ     , ˆ  8¹
 , 8´ $  8 ½, ¾ ¿ Ì, À8¿ Á& Â8}Ä Ç8È=É$ Í Î Ï8}Ñ8
Ô, Ø8Ð  Ý, Þ ß â, à8¿ á$ ã ä å ç è8 ÷, ø ù Ž, ú8¿ û& ü8³ 8È=$   8³T“8
ž, ¢8Ð  §, ¨ © ¬, ª8¿ «$ ­ ® ¯ ± ×
8 ¿8ï
 Í á Î8$ Ó8¹
& Ú Ü8(ã8¬ ì8í'ñ8ó'ö8®   Í  ¡,   ž8$— , œ8´ $ Ÿ   ¢8ï
 ® ¿ ¯ ° ¾, ± ² »8¹
 ¸, ¹8´ º$ ¼ ½8 æ, ç è ö, é8¿ ê& ë8­í ñ8È=ó$ ÷ ø ù8­û8
ÿ, ƒ8Ð $„ ˆ,  Š , 8¿ Œ$ Ž      
8  8£ ¦ º §8$ ¬8¹
& ³ µ8(¼8í$¿'Ã8Å'È8® Ó  å ò, æ ç ï8 ì, í8´ î$ ð ñ ó8ô ÷ ˆ  ø ù , ú û 8¹
 , 8´ ƒ $  8 ¯ , °  ±  ¹ , ² 8¿ ³ & ´ 8È=$ º  »  ¼ 8d8
Ä , È 8Ð  Í , Î  Ï  Ò , Ð 8¿ Ñ $ Ó  Ô  Õ  ×  «!8 å 8ƒ í  ó  î 8(õ 8 ý  ¡!
!8$!8$¶! º!, »! ¼! Ä!, ½!8¿ ¾!& ¿!8È=Á!$ Å! Æ! Ç!8n$É!8
Î!, Ò!8Ð $Ó! ×!, Ø! Ù! Ü!, Ú!8¿ Û!$ Ý! Þ! ß! á! â!+ í! î! …"8âï! ò! „"8»<ó! û!7¤<ý!8$" “":Š”"$ ", ˜" ™" ³", š"8¿ "& œ"8­ž" ¢"8÷V,¤" ª":7<¬"$ ´" µ" ¶"8,¸"'½"8Ø¿"'Â"8ù
LÄ" Í":ŠÎ" Ð"8
Ò" Ö" Þ", ×" Ø" Û", Ù"8¿ Ú"$ Ü" Ý" à" ¶$'8!$î"8 ContainerÁLó" ý"8,ÿ"'„#8¹ <†# #:ŠŽ#$ # # š#, “# ”# —#, •#8¿ #$ ˜# ™# #% œ#8!$ª#8Ù,¯# µ#8,·#'¼#8 L¾# Ç# È# Ð#, É# Ê# Í#, Ë#8¿ Ì#$ Î# Ï# Ñ#% Ò#8!$à#8GetTypeÁ<å# í#, ï#8Ð $ð# ô#, õ# ö# €$ ÷#, ø#8¿ ù# ú#'û#8È=ý#$ $ $ ƒ$% „$8!$$8 OwnedTypeÁL—$ ¡$ £$ «$, ¤$ ¥$ ¨$, ¦$8¿ §$$ ©$ ª$% ¬$% ½$„Ö üË
 [`VarULE`] impls for tuples.Áì
úüðc
` This module exports [`Tuple2VarULE`], [`Tuple3VarULE`], ..., the corresponding [`VarULE`] typesÁüÔ1
. of tuples containing purely [`VarULE`] types.Á
úüŠk
h This can be paired with [`VarTupleULE`] to make arbitrary combinations of [`ULE`] and [`VarULE`] types.Áö
úüú6
3 [`VarTupleULE`]: crate::ule::vartuple::VarTupleULEÁœ×íÍ»Ä`<Ø
Ð øû¹Ä`Ñ øû¹Õ„á
`øü½×þ
 `øýëµ\•
øþëµøþÕë

øÿÕë4øÿè<âÎøù—>“ΧøùøA’Îçøù¡B‘ÎéøùÄEÎøù³
ÎÎøù´MŽÎøù¶QÎ×øù°ôøù£SœøøùêS¯øùÈ=°øù÷VÕµøùœWè¹øù©WûºøùêW¿øùÈ>!¯øù¢åE8øù¥FOøù§ÈIfÓøù©«K}òøùªºÑà%øù­žýЉføù¯È=·øùÄêW­¸øùÅò­ÇóøùëfÛ²
øù¡œhòÌ
øù£²ià
øù¦²iá
øù¦¡l7‘ øù«¡l7‘ øù«
΀
fi
Ẋ
I”¦
$Ì»

 Õ
»U
 ½
 , ¾
8Ð $¿
& Ã
8¼
$ É
, Ë
8Ì
& Ï
8«
$ ×
 Ù
, Û
 Ü
, Ý
8¥ Þ
& ß
8¼
, æ
8¿ ç
& è
8¼
, ï
8T_altÁ
& õ
8¼
, ý
8´ þ
& ÿ
8¯
$ ƒ

*
 Œ
¸U
ï+

þ
8Ó˜
œ
8¨
 ¤
 ¥
ý
7VarULE type for tuples with Áô¦
$ Ä
, Æ
8Ç
$ Ê
7/ elements. See module docs for more informationÁüÌ
1
+ ˆ

8
 Ž
š
8ž\
+ ¥
 ¦
È
8«
 ¬
Ç
84­
'³
8¨à
”µ
8Ü
8
, ç
8Ð
 ì
, í
 î
ú
, ï
8¥ ð
& ñ
- ó
8Ø
$ ù
 û
8ÒB
& ƒ
8Õ„…
8Ä`<˜
 Ÿ
 ¡
´
 , ¯
 °
Å
 , ±
8¿ ²
& ³
8ëµ
 À
, Á
8¥ Â
 Ã
$ Ä
 Æ
8¡B,ˆ
& 
8œht
 
, ž
8Ÿ
$ ¢
8ÒB
 ª
8$¿
 Ã
, Ä
 Å
Ú
, Æ
8¥ Ç
& È
8êW
Ñ
- Ó
8Ø
$ Ù
 Û
8ÒB
& ã
8Õ„å
 õ
, ÷
8Ð 
 ü
, ý
 þ

, ÿ
8¥ 
$ 
 ƒ
8ÒB4…
 
 
Û
, 
 œ
Ð
 + ®
 ¯
à
8Ó°
´
8¨
 ¼
 ½
ß
7
Get field Á
$ Ê
, Ì
8´ Í
$ Î
7
of this tupleÁ
8ò
8 ö
, ù
8¿ ú
 û

 ü
8
(ƒ
 
, 
8¥ ˆ
 Š
À
8"
 á
®
 8
 ÿ
8¡B,€
 
8DL†
'
 
, 
8¥ 
 
 
˜
, 
8´ 
 Ñ
8"4
8
 ¦
, §
 ¨
½
, ©
8¥ ª
& «
8êW4­
´
- 
8Ø
$ ¼
 ¾
8ÒB
& Æ
8Õ„È
 Ø
8êW
8
á
, å
8Ð 
 ê
, ë
 ì
ð
, í
8¥ î
$ ï
 ñ
8ÒB
 ù
 ƒ
Ó"
8 
8—'t”
 ¢
¯
8´
& ¨
 ª
 «
®
8Ȭ
(±
8Í4´
 º
 »
¼
$ ½
8ò­D¿
 Ç
 É
¼
8î
8¡B
ø
 ú
8œh
 
, Š
8
$ Ž
8ÒB4
 
8˜
8êW4
 ¡
'¢
8Š
 ¯
µ
8´
- 
% ·
, É
 Ê

8"
 µ

 8¡B
 Ô
8ãC
'ã
 å
, æ
8¥ ç
 è
 é
ì
, ê
8´ ë
- í
% î

8«©
 «
®
 ¬
­
8"
8 Ò
8œ¤Õ
 é
ö
8´
& ï
 ñ
 ò
õ
8Èó
(ø
 û
8
 
É"
8§
8¡B
±
 ³
8œht´
 Â
, Ã
8Ä
$ Ç
8ÒB
 Ï
8Ñ
8êW
 Ú
'Û
8œ¤Ý
 ñ
÷
8´
% ø
 ì!

í!
 î!
»"
8¡B,ï!
8õ!
ø!
8,ù!
8œhtÿ!