core/target/debug/deps/libzerovec-187d4334a3106b07.rmeta

rust
�‰#rustc 1.93.0 (254b59607 2026-01-19)Á³VOÐêùÿ²?ÑL¼�§Ì±-a7a40eb546f9e2b0ÁzerofromÁ9’k,94äwâD~“ìF-e7a4aaab09db7e3aÁzerofrom_deriveÁb«íºê3
,³Vˆ�X-03b1dd1f2d87713aÁë&Gf·Ã ¬ëñq:¤»b-bb76018b1173caf6Ázerovec_deriveÁÎ¥ìóJÏ?æE²ËÖªÜl-f6b5d17a820a0cf7ÁyokeÁÌFÈ¯ÁrJ¬oahÌJ–i-17a2be691e559186Ástable_deref_traitÁ•Ú¨ûEmðYlØ?"e›§k-80e318edb62c0e9cÁyoke_deriveÁbŽÆÚÒ
Â¨à‹x 5Ë-5e7d4687001d5481Á‰á,ˆL¶<çKá<ñKŒçKBoxÁ«¶<…á<�Œ…ManuallyDropÁd‡¶<äá<îŒätestsÁ,ágà$ÖghashmapÁ<½L¶<ŸLÉL©LœŸL…
äL¶<ÌLá<ÖLŒÌLmap2dÁ,‡M¶<ïLá<ùLŒïLsamplesÁ<£Mà$”MY get_serializable_bytes_non_emptyÁüÅÇ ¶<ªÇá<´ÇŒªÇXownedÁ,÷¶<Ôá<ÞŒÔXdatabakeÁDÊ¶<¯±T¹¤¯XserdeÁ,ó¶<Û×<åŒÛXVarZeroVecOwnedÁ|ß¶<¼á<ÆŒ¼½±Dì¶<Ñ±TÛ¤Ñ½×,•¶<ý×<‡Œý¾à$–�à$‹�½€¢¶<ûá<…Œû½Ñ¶<á<·Œ½Ÿd»¶<—á<¡Œ—½¯,éºà$Þº’à$‡à$ü‘customÁ4Ì¡¾¥€ð¶<Èá<ÒŒÈ¥œ<õ¶á¥ä«¶<…á<�Œ…¥’4Ý¶<¶á<ÀŒ¶¥œ‹¶<ëá<õŒë¥•¶á¥memÁ¿¶<¡á<«Œ¡¥encode_varule_to_boxÁ¤”%¶<ù$á<ƒ%Œù$¥à$“Xà$ˆX’	ZeroMapKVÁLž	¶<ú	á<„	Œú	’	ZeroSliceÁLÏ	¶<¯	á<¹	Œ¯	’ZeroVecÁ<Ú	¶&á$"$‘
test_utilsÁTºà$«‹¯,ÈX
à$½X
‘õ
¤¼¶<˜á<¢Œ˜âZeroMapBorrowedÁ|ö¶<Òá<ÜŒÒâ¾L±¶<�á<—Œ�âZeroMap2dBorrowedÁŒè¶<Âá<ÌŒÂâZeroMapÁ<â¶<Âá<ÌŒÂâ	ZeroMap2dÁLë¶(á&$&âà$»Yà$�YŠ	¾Lõ¶<Ñá<ÛŒÑŠ	€<—¶<÷á<�Œ÷Š	¦L ¶áZeroHashMapÁ\äO¶<¶OÉLÀOœ¶O€<¤P¶<÷Oá<�PŒ÷O¦LâP¶<³Pá<½PŒ³P´	borrowÁ4óR¶<ÌRá<ÖRŒÌR´	boxedÁ,¬S¶<…Sá<�SŒ…S´	×,ÞS¶<¾S×<ÈSŒ¾SmapsÁ$ŠT¶<îSá<øSŒîS¶	ú|×b¶<¤bá<®bŒ¤b¯,Œ¥à$¨¤³cowÁ
VarZeroCowÁ
'aÁ
VÁ
@
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±CÐG¨G±Gencode_var_ule_as_slicesÁJRÁ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ÁYYYYYYYYVarZeroVecFormatÁaIndexÁaLenÁY
IntegerULEÁdTOO_LARGE_ERRORÁdSIZEÁd	MAX_VALUEÁd
iule_to_usizeÁdiule_from_usizeÁYj�jœYm�nmœpYr�srœuYw·wÍwØwèwüY}}·}Í}Ø}è}üY„„·„Í„Ø„è„üY‹¨‹™‹FÁ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¶¨¶™¶ð¶½¶¥¶	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ÁÖ™ÖAÁÖð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î����������	�
���
��VarZeroSliceÁ‘™‘ð‘‡
‘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ÁÛPÁÑtry_as_convertedÁÝ°2ÑfirstÁÑ¸	Ñ£	á¨Ñsplit_firstÁ¾ä¨ä™ä½ä¥äÖ¾ê¨ê™ê¾	¾î¨î™î	next_backÁ¾ò™ò§ô	¾ö™ö€ øimpl FnMut(T) -> OrderingÁø	¾û™û¯(û»¾ÿ™¾	�™�Õ¾
„™„Õ¾‡¨‡™‡Õ¾‹¨‹™‹Õ¾
�™�Í¾’™’¤¾•™•Ð¾˜™˜†¾›™›>½½½½½½½½½½	½
½½Žª¨ª™ª¨ª¿ªmarker2Á½°¨°™½³¨³™½¶¨¶™¶š¶‚½EyepatchHackVectorÁ»UÁ»á½¾¨8¾as_arbitrary_sliceÁÀ¨¾´-Â¨¾truncateÁ½Å¨Å™ÅÈ½É¨É™É†½Í™ÍÍ½Ð™½Ò¨Ò¤Ò™ÒÕ½	×™×Õ½
Ú™ÚÍÚÚÕÞ½à¨à™à>½ä¨ä™ä¤½
è¨è™èÐ½ì¨ì™ì†½ð¨ð™ðï½ô¨ô™ô•ô	const_lenÁôÖô©ô»ô´-ôûôas_maybe_borrowedÁôowned_capacityÁ½€¨½‚¨‚™½…¨…™…try_from_sliceÁˆ	½Š¨Š™ŠclearÁŠ	truncatedÁ½	zerosliceÁ½�0uleÁ‘charsÁ’’’’’—from_alignedÁ—to_charÁ’š¯(›	’�ULEÁ�to_unalignedÁ�from_unalignedÁ’¡¤’£Ð‘Î¥¥¥¥¥¥¥¥EncodeAsVarULEÁ™û¯š¯¢Ã²	³	Üµ	¥·™·û¹š¹¢¥¼™¼û¾š¾¢¥Á™ÁûÃšÃ¢¥Æ™ÆûÈšÈ¢ÆÃÆÜ¥Í™ÍûÏšÏ¢ÍÃÍÜ¥Ô™ÔEÁÔðÔûØšØ¢ÔÃÔÜ¥Ý™ÝðÝûàšà¢ÝÃÝÜ‘macrosÁåimpl_ule_from_arrayÁ‘multiÁçççççççîLENÁîFormatÁîcompute_encoded_len_forÁñî&new_from_lengths_partially_initializedÁó¨óîset_field_atÁö™öÓ!îvalidate_fieldÁù™î	get_fieldÁû™î»îŠçÿæCÿñCÿÍçBlankSliceEncoderÁƒ
ƒìç†û‡š‡¢†Ã†ÜçŒæCŒñCŒ¯(�	Œ»‘nicheÁ’’’’’’’
NicheBytesÁ™Í™NICHE_BIT_PATTERNÁ›’NichedOptionULEÁ�¨8�Í�ãF �validÁ’£¨8£Í£Í’§¨8§Í§•§ù§†’¨8Í’°¨8°Í°È’´¨8´Í´Õ’¸¨8¸Í’»¨8»Í»¯(¾	’À¨8ÀÍÀ>’Ä¨8ÄÍÄâ>Äí>Ä�?’	Ê™ÊÍÊIntoIterÁÊ½ÊŠ	‘äÐÐÐÐÐÐÐ	OptionULEÁ×
×¨8×ì×íÐÜ¨8ÜùÜ•Ðà¨8àÍÐã¨8ã¯(å	Ðç™çâ>çí>ç�?Ðì¨8Ðî¨8îÈÐñ¨8ñÕÐô¨8ÐOptionVarULEÁö
ö¨8öìöíöîÐü¨8ü†Ð	ÿ¨8ÿÍÐ
‚¨8‚¯(‚»Ð†™†¨8†û‰š‰¢†Ã†ÜÐŽ¨8ŽÕÐ
‘¨8Ð“¨8“¤Ð–¨8–Ð‘plainÁ™™™™™™™ Í Š Ã$™¤Í¤¯(™§Í§§ïª™impl_byte_slice_sizeÁ™impl_const_constructorsÁ™impl_byte_slice_typeÁ™impl_byte_slice_unsigned_typeÁ™impl_byte_slice_signed_typeÁ™±¯(™³â>³í>³�?™™¸¯(¹	™»â>»í>»�?™™	ÀÀ¨GÂ™
Ä¯(™Æâ>Æí>Æ�?™™
Ëâ>Ëí>Ë�?™Ïâ>ÐÏí>Ï�?™Ôâ>ÕÔí>Ô�?™™™Û¯(™Ýâ>Ýí>Ý�?™™â¯(™äâ>äí>ä�?™‘slicesÁééë™ëÍëë¯(éð™ðÍððâ>ôðí>ð�?éø™øÍøéü¯(ý	ü©ÿ	ü»é‚™‚¯(‚»‘�††††	tuple_uleÁ‘tuplevarÁ‹‹‹‹‹‹‹‹‹tuple_varuleÁ‘vartupleÁ••••••••••	• Ó! ± ¯( »•¥Ó!¥BÁ¥±¥û©š©¢¥Ã¥Ü•®¨®Ó!®¦W®±®‰‘‘‘‘‘‘‘‘‘‘	‘
‘‘‘
‘‘‘â>Ä¯(Äparse_bytes_to_sliceÁÄslice_from_bytes_uncheckedÁÄslice_as_bytesÁ‘AsULEÁÉâ>Éí>É�?‘EqULEÁ‘
SliceAsULEÁÎslice_to_unalignedÁ‘Ð™Ð„Z‘VarULEÁÓ¯(Ó©Ó»ÓŠ‘‘‘ÚÍ‘ÜparseÁÝ™ÜlengthÁß™‘
yoke_implsÁââââââââââì¨ì™ìØì	transformÁìtransform_ownedÁìmakeÁì
transform_mutÁóðó¤âö¨ö™öØöˆ\ö™\ö°\ö¼\ýðý¤â€	¨€	™€	Ø€	ˆ\€	™\€	°\€	¼\‡	ð‡	¤zerofrom_implsÁŠ	Š	Š	Š	Š	Š	Š	Š	Š	“	'zfÁ“	™“	‰Š	—	½^—	™—	‰Š	›	½^›	™›	‰Š	Ÿ	½^Ÿ	™Ÿ	ðŸ	‰Š	¤	½^¤	™¤	ð¤	‰Š	©	½^©	™©	‰__zerovec_internal_reexportÁ´	vecsÁ¶	¶	¶	¶	¶	¶	¶	¶	¶	¶		¶	
¶	¶	¶	VarZeroVec16ÁÄ	¨Ä	™¶	VarZeroVec32ÁÇ	¨Ç	™¶	VarZeroSlice16ÁÊ	™¶	VarZeroSlice32ÁÌ	™	YIndex8ÁÐ	
YYYÔ	ÈYÖ	ÍYØ	¢Ù	µYYÜ	ÕYÞ	˜Yà	¤Yâ	ÐYIndex16Áä	
YYYè	ÈYê	ÍYì	¢í	µYY ð	ÕY!ò	˜Y"ô	¤Y#ö	ÐYIndex32Áø	
Y$Y%Y&ü	ÈY'þ	ÍY(€
¢�
µY)Y*„
ÕY+†
˜Y,ˆ
¤Y-Š
ÐYVarZeroVecComponentsÁŒ
¨Œ
™Œ
ðŒ
¾	Œ
indicesÁŒ
thingsÁŒ
‡
Y.”
¨”
™”
ð”
ÍYVarZeroSliceIterÁ™
¨™
™™
ð™
Ì™
ö™
start_indexÁY/ 
¨ 
™ 
ð 
ÍéVarZeroVecFormatErrorÁ¥
MetadataÁ¦

¥
ValuesÁ¨

¨
ìé«
ÍîVarZeroLengthlessSliceÁ
™
ð
‡

‰&î²
™²
ðîµ
™µ
ðµ
Õî¹
™¹
ð¹
˜¾
ZeroSliceIterÁ½

½
¨½
™½
ì¾Â
¨Â
™Â
Í’CharULEÁÆ

Æ
ìÈ
’Ê
Í’’Í
Õ’Ï
˜Ð
’	’
Ó
ÈÔ
’’×
¢Ø
µ—
from_arrayÁÚ
ÍÚ
Ú
Ú
Ú
çMultiFieldsULEÁà

à
æCà
ñCà
ìçå
æCå
ñCå
çé
æCé
ñCé
é
Õí
çï
æCï
ñCï
ï
˜’NichedOptionÁô

ô
¨8ô
Íô
ì’
ù
¨8ù
Íù
ù
Í’þ
¨8þ
Íþ
’‚¨8‚Í‚‚È†’
ˆ¨8ˆÍˆ’Œ¨8ŒÍŒŒÕ�’’¨8’Í’’˜’—¨8—Í——¢›µ’�¨8�Í��¤¡’£¨8£Í££Ð§™RawBytesULEÁ©
©Í©ì¬™®Í®®Í™²Í²™µÍµµÕ¸™ºÍºº˜½™¿Í¿™ÂÍÂÂÈÅÅ™ÈÍÈ™ËÍËË¤Î™ ÐÍÐÐÐÓ™!ÕÍÕÕ¢Øµ™"ÚÚas_unsigned_intÁÚ¨>Ú·jÞÍÞÞÞÞ™#ää³qä¨>ä·jèÍèèèè™$îî³qî¨>î·jòÍòòòò™%øø³qø¨>ø·jüÍüüüü™&‚‚ï™'…â>†…í>…�?™(™)‹‹
from_unsignedÁ™*ŽŽï™+‘â>’‘í>‘�?™,™-——ós™.ššï™/�â>ž�í>��?™0™1££ós™2¦¦ï™3©â>ª©í>©�?™4™5¯¯ós™6²²ï™7µâ>¶µí>µ�?™8™9»»from_signedÁ™:¾¾ï™;Áâ>ÂÁí>Á�?™<™=ÇÇ¬v™>ÊÊï™?Íâ>ÎÍí>Í�?™@™AÓÓ¬v™BÖÖï™CÙâ>ÚÙí>Ù�?™D™Eßß¬v™Fâtry_from_bytesÁ™Gä¥x™Hæ¥x™Iè¥x™Jê¥x™Kì¥x†	Tuple2ULEÁî
îÓ!î¦Wîìîí†ôÓ!ô¦Wô¯(†øÓ!ø¦Wøâ>øí>ø�?†þÓ!þ¦WþÍ†‚
Ó!‚
¦W‚
Õ††
Ó!†
¦W†‰
Ó!‰
¦W‰
¤†�
Ó!�
¦W�
Ð†‘
Ó!‘
¦W‘
È†•
Ó!•
¦W†	Tuple3ULEÁ˜
˜
Ó!˜
¦W˜
k˜
ì˜
í˜
î†	 
Ó! 
¦W 
k 
¯(†
¥
Ó!¥
¦W¥
k¥
â>¥
í>¥
�?†¬
Ó!¬
¦W¬
k¬
Í†±
Ó!±
¦W±
k±
Õ†
¶
Ó!¶
¦W¶
k†º
Ó!º
¦Wº
kº
¤†¿
Ó!¿
¦W¿
k¿
Ð†Ä
Ó!Ä
¦WÄ
kÄ
È†É
Ó!É
¦WÉ
k†	Tuple4ULEÁÍ
Í
Ó!Í
¦WÍ
kÍ
DÁÍ
ìÍ
íÍ
îÍ
ï†×
Ó!×
¦W×
k×
í~×
¯(†Ý
Ó!Ý
¦WÝ
kÝ
í~Ý
â>Ý
í>Ý
�?†å
Ó!å
¦Wå
kå
í~å
Í†ë
Ó!ë
¦Wë
kë
í~ë
Õ†ñ
Ó!ñ
¦Wñ
kñ
í~†ö
Ó!ö
¦Wö
kö
í~ö
¤†ü
Ó!ü
¦Wü
kü
í~ü
Ð†‚Ó!‚¦W‚k‚í~‚È†ˆÓ!ˆ¦Wˆkˆí~†	Tuple5ULEÁ�
�Ó!�¦W�k�í~�—B�ì�í�î�ï�ð†™Ó!™¦W™k™í~™—B™¯(† Ó! ¦W k í~ —B â> í> �?†©Ó!©¦W©k©í~©—B©Í†°Ó!°¦W°k°í~°—B°Õ†·Ó!·¦W·k·í~·—B† ½Ó!½¦W½k½í~½—B½¤†!ÄÓ!Ä¦WÄkÄí~Ä—BÄÐ†"ËÓ!Ë¦WËkËí~Ë—BËÈ†#ÒÓ!Ò¦WÒkÒí~Ò—B†	Tuple6ULEÁØ
ØÓ!Ø¦WØkØí~Ø—BØðØìØíØîØïØðØñ†$æÓ!æ¦Wækæí~æ—Bæðæ¯(†%îÓ!î¦Wîkîí~î—Bîðîâ>îí>î�?†&øÓ!ø¦Wøkøí~ø—BøðøÍ†'€Ó!€¦W€k€í~€—B€ð€Õ†(ˆÓ!ˆ¦Wˆkˆí~ˆ—Bˆð†)�Ó!�¦W�k�í~�—B�ð�¤†*—Ó!—¦W—k—í~——B—ð—Ð†+ŸÓ!Ÿ¦WŸkŸí~Ÿ—BŸðŸÈ†,§Ó!§¦W§k§í~§—B§ð‹Tuple2VarULEÁ®Ó!®¦W®ñC®aÁ®bÁ®¶C´‹¶Ó!¶¦W¶ñC¶˜Œ¶¡Œ‹¼Ó!¼¦W¼ñC¼¯(À¼»ÂÂ‹ÅÓ!Å¦WÅñCÅÍ‹ÊÓ!Ê¦WÊñCÊÕ‹ÏÓ!Ï¦WÏñC‹ÓÓ!Ó¦WÓñCÓ¤‹ØÓ!Ø¦WØñCØÐ‹ÝÓ!Ý¦WÝAEÁÝBEÁÝñCÝûãšã¢ÝÃæÝÜè‹ê¨êÓ!ê¦WêèŽêòŽêñCê‰‹Tuple3VarULEÁòÓ!ò¦WòkòñCò˜Œò¡ŒòŠò¶Cú‹	üÓ!ü¦WüküñCü˜Œü¡ŒüŠ‹
„Ó!„¦W„k„ñC„¯(‰„»‹‹‹ŽÓ!Ž¦WŽkŽñCŽÍ‹”Ó!”¦W”k”ñC”Õ‹
šÓ!š¦WškšñC‹ŸÓ!Ÿ¦WŸkŸñCŸ¤‹¥Ó!¥¦W¥k¥ñC¥Ð‹«Ó!«¦W«k«èŽ«òŽ«CEÁ«ñC«û³š³¢«Ã¶«Ü¸‹º¨ºÓ!º¦WºkºèŽºòŽºÒ“ºñCº‰‹Tuple4VarULEÁÄÓ!Ä¦WÄkÄí~ÄñCÄ˜ŒÄ¡ŒÄŠÄÞÄ¶CÎ‹ÐÓ!Ð¦WÐkÐí~ÐñCÐ˜ŒÐ¡ŒÐŠÐÞ‹ÚÓ!Ú¦WÚkÚí~ÚñCÚ¯(àÚ»ââ‹åÓ!å¦Wåkåí~åñCåÍ‹ìÓ!ì¦Wìkìí~ìñCìÕ‹óÓ!ó¦Wókóí~óñC‹ùÓ!ù¦Wùkùí~ùñCù¤‹€Ó!€¦W€k€í~€ñC€Ð‹‡Ó!‡¦W‡k‡í~‡èŽ‡òŽ‡Ò“‡DEÁ‡ñC‡û‘š‘¢‡Ã”‡Ü–‹˜¨˜Ó!˜¦W˜k˜í~˜èŽ˜òŽ˜Ò“˜£™˜ñC˜‰‹Tuple5VarULEÁ¤Ó!¤¦W¤k¤í~¤—B¤ñC¤˜Œ¤¡Œ¤Š¤Þ¤¿¤¶C°‹²Ó!²¦W²k²í~²—B²ñC²˜Œ²¡Œ²Š²Þ²¿‹¾Ó!¾¦W¾k¾í~¾—B¾ñC¾¯(Å¾»ÇÇ‹ÊÓ!Ê¦WÊkÊí~Ê—BÊñCÊÍ‹ÒÓ!Ò¦WÒkÒí~Ò—BÒñCÒÕ‹ÚÓ!Ú¦WÚkÚí~Ú—BÚñC‹ áÓ!á¦Wákáí~á—BáñCá¤‹!éÓ!é¦Wékéí~é—BéñCéÐ‹"ñÓ!ñ¦Wñkñí~ñ—BñèŽñòŽñÒ“ñ£™ñEEÁññCñûýšý¢ñÃ€ñÜ‚‹#„¨„Ó!„¦W„k„í~„—B„èŽ„òŽ„Ò“„£™„æŸ„ñC„‰‹Tuple6VarULEÁ’Ó!’¦W’k’í~’—B’ð’ñC’˜Œ’¡Œ’Š’Þ’¿’þ’¶C ‹$¢Ó!¢¦W¢k¢í~¢—B¢ð¢ñC¢˜Œ¢¡Œ¢Š¢Þ¢¿¢þ‹%°Ó!°¦W°k°í~°—B°ð°ñC°¯(¸°»ºº‹&½Ó!½¦W½k½í~½—B½ð½ñC½Í‹'ÆÓ!Æ¦WÆkÆí~Æ—BÆðÆñCÆÕ‹(ÏÓ!Ï¦WÏkÏí~Ï—BÏðÏñC‹)×Ó!×¦W×k×í~×—B×ð×ñC×¤‹*àÓ!à¦Wàkàí~à—BàðàñCàÐ‹+éÓ!é¦Wékéí~é—BéðéèŽéòŽéÒ“é£™éæŸéFEÁéñCéû÷š÷¢éÃúéÜü‹,þ¨þÓ!þ¦Wþkþí~þ—BþðþèŽþòŽþÒ“þ£™þæŸþ›§þñCþ‰•VarTupleÁŽÓ!Ž¦WŽëŽvariableÁ•“Ó!“¦W“Í•—Ó!—¦W•šÓ!š¦WšÕ•žÓ!ž¦Wž˜•¢Ó!¢¦W¢¤•¦Ó!¦¦W¦Ð•	ªÓ!ª¦WªÈ•VarTupleULEÁ®Ó!®±®ë®‰©•
³Ó!³±³Í•·Ó!·±•ºÓ!º±ºÕ•
¾Ó!¾±¾˜•ÂÓ!Â±Â¤•ÆÓ!Æ±ÆÐ‘UleErrorÁÊ
InvalidLengthÁË”Ë¾	Ê
ParseErrorÁÎ”‘‘‘ÒÈ‘ÔÍ‘‘	×Õ‘
Ù˜

%
&
)
*
/
7
7
7
;
;
B
B
F
F
J
J
J
M
N
N
“
°
»
¼
Á
Æ
Æ
È
È
Î
Î
Ð
Ð
Ô
Ô
Ö
Ö
Ú
Ú
Þ
ä
í
í
í
ü
ý
þ
ÿ
€
œ
�
ž
¡
¢
£
«
«
¬
¬
°
°
²
²
·
¹
º
¿
Ã
Ã
Ê
Ê
Î
Î
Ò
Ò
Ò
Ö
ñ
ò
õ
õ
õ
û
ÿ
ƒ
‹
Œ
”
”
™
™
�
�
�
Ÿ
¥
¥
¬
¬
±
±
É
Ê
Ë
Ì
Í
Î
Ï
Ð
Ó
Ô
Ù
Ú
Û
Ý
ß
à
ã
è
é
í
ñ
ô
ô
ø
ý
þ
ƒ
ƒ
†
†
Š
Š
Ž
Ž
‘
‘
‘
”
”
—
—
˜
š
›
º
À
Ä
È
Ì
Í
Ï
Ï
Ï
Ð
Ö
Ö
×
×
Ù
Ù
Ù
Ú
Þ
Þ
ç
ç
ë
ë
ï
ø
ü
ý
þ
ÿ
�
›
¢
¢
¤
¤
¯
¯
¯
²
µ
µ
¹
¹
¹
¼
¾
¾
¾
Á
Á
Ã
Ã
Ã
Æ
È
È
È
Ë
Ì
Ì
Í
Ï
Ï
Ï
Ò
Ó
Ó
Ô
Ø
Ø
Ø
Û
Ü
Ü
Ý
à
à
à
ã
ä
ä
ö
ö
ù
û
ý
þ
‚
‚
‚
‡
‡
‡
Š
‹
‹
�
‘
¦
¦
¦
¬
³
·
·
¾
â
â
â
å
ð
ó
ó
þ
�
�
�
„
…
‰
‰
‰
Œ
�
�
�
�
•
•
˜
˜
¢
£
¦
²
¹
Å
Ü
ã
ï
ý
ÿ
�
„
…
£
¤
©
©
©
¬


Å
Æ
Ç
È
Ï
Ò
Ô
Õ
Ö
×
Û
Û
Û
“	
–	
¤	
¨	
Õ	
×	
×	
×	
Ù	
Ù	
Ý	
Ý	
ß	
á	
á	
ã	
ã	
é	
ë	
ë	
ë	
í	
í	
ñ	
ñ	
ó	
õ	
õ	
÷	
÷	
ý	
ÿ	
ÿ	
ÿ	
�

�

…

…

‡

‰

‰

‹

‹

˜

˜

˜

¤

¤

¤

¬

¬

¬

¸

¸

¼

Å

Å

Å

Ë

Ë

Ë

Î

Î

Ð

Ô

Ø

Ø

í

í

ó

ý

ý

ý

†
�
�
–
›
›
¡
¡
§
§
±
±
±
¸
¸
½
Å
Î
Î
Ó
Ó
Ø
Ø
Ü
æ
ð
ú
ã
å
ç
é
ë
í
÷
�

�

�

…

…

Œ

Œ

�

�

”

¤

°

°

°

µ

µ

¾

¾

Ã

Ã

È

Ü

ê

ê

ê

ð

ð

û

û

�
�
‡
Ÿ
¯
¯
¯
¶
¶
Ã
Ã
Ê
Ê
Ñ
í
ÿ
ÿ
ÿ
‡
‡
–
–
ž
ž
¦
º
»
À
Â
É
É
É
Î
Î
×
×
Ü
Ü
ã
ã
ã
æ
è
è
�
‚
ƒ
‰
‹
“
“
“
™
™
¤
¤
ª
ª
³
³
³
¶
¸
¸
Ö
×
Ø
Ù
à
â
ë
ë
ë
ò
ò
ÿ
ÿ
†
†
‘
‘
‘
”
–
–
¹
º
»
¼
½
Å
Ç
Ñ
Ñ
Ñ
Ù
Ù
è
è
ð
ð
ý
ý
ý
€
‚
‚
ª
«
¬

®
¯
¸
º
Å
Å
Å
Î
Î
ß
ß
è
è
÷
÷
÷
ú
ü
ü
–
–
–
�
�
¡
¥
¥
©
©

¶
¶
¶
½
½
Á
Å
Å
É
É
Ó
Õ
Õ
Õ
Ø
Ø
Ú
ad™ÄÉÍÎÓ¨âÍáuê\ŠØ…ÅÄ„£ÆÞ£ÆÞ

—@¿#à›6¢¨±ìéÆúéÆ¨¡Çà`éÆžéÆéÆ£éÆÉéÆéÆÃéÆéÆ¡Ç
éÆ¨¡Ç


—@¿#à›6¢¨±¨

—@¿#à›6¢¤èÈþÐ	Ð	Ñ	“baŠQ9æà�õá·ÉÞ·Éà`·É»b·É¬â·Éž·É·É£·ÉÉ·É·ÉÃ·Éþä	ä	å	�cÁÀ;A®Î)áÏÊÞÏÊà`ÏÊ»bÏÊ¬âÏÊžÏÊÏÊ£ÏÊÉÏÊÏÊÃÏÊþø	ø	ù	ˆd–·>è{z.;áçËÞçËà`çË»bçË¬âçËžçËçË£çËÉçËçËÃçËa·ÉaÏÊaçËdd©©ªên¬ìÖ±ËúÇÒOUd©©ªên¬ìÖ±ËúÇÒOUà`Œ
Œ
ƒe�
¾	Y‘
¿eY’
ÎeY“
‡
Y2fm?Ž~�¨™ðþªÎÞªÎÄªÎà`™
™
‡f�
ÌYž
öYŸ
ÇfY€�Š5½Uf¨ýÎƒÏÞK±Ï©K±Ïà`¥
¦
§
›g¨
©
°gª
ìßzþáJÇÏžÐå`žÐ¬â

Øg°
‡
î±
‰&î(£Tªt_™ðžúÐúÐ£úÐÓ‘‘Ý%”‡
�•‰&�Ž6Òß�ñ’K³Ñ¹Ñ¦˜àÑžàÑàÑ£àÑÉàÑàÑÃàÑà`àÑñàÑàÑÞààáÔ*åì6
ä>(ùOè¨ýÎƒÏà`ààáÔ*åì6
ä>(ùOè8ýÎƒÏú…Ó¨‘‘Ý%”‡
�•‰&�Ž6Òß�ñ’KýÎƒÏÄÊÓìÊÓžààáÔ*åì6
ä>(ùOè¨™ðààáÔ*åì6
ä>(ùOè¤Õ³Õ£…ÓžààáÔ*åì6
ä>(ùOè8Õð8
Ó!žààáÔ*åì6
ä>(ùOè8ýÎ³ÕÓ!ÍÉ…Ó…ÓÃ…Óà`½
½
¾
åhÁ
ì¾žóP¾7Šyô¨ýÎÞKÆ×©KÆ×òJÆ×ÓÂÂÃæÅì¾ÈE(�mÇ³Ñ£©Øž©Ø©Øž©Ø
³ÑžÂÂÃæÅì¾ÈE(�mÇýÎªªŽ¨½®¿½¯°7½Ê˜!ÚÆdG
¨ýÎžÄÙ�Ùà`©ØÉ©Ø©ØÃ©Øñ8
ýÎÊ�ÙÄ8�Ù¨âÄÙ„ÄÙìÄÙÞÄÙñÄÙ�Ùà`ªªŽ¨½®¿½¯°7½Ê˜!ÚÆdG
8ýÎ£¸ÛžªªŽ¨½®¿½¯°7½Ê˜!ÚÆdG
¨ÕªªŽ¨½®¿½¯°7½Ê˜!ÚÆdG
¤ÕžªªŽ¨½®¿½¯°7½Ê˜!ÚÆdG
8Õ8
Õž¸ÛýÎÍÄÄÙÉÄÙÄÙÃÄÙñÄÙÓÚúÄÙ¨ÓÚà`Æ
Æ
Ç
´iÈ
ì’fð°m8â›Æ¬âüÞžüÞüÞ£üÞáüÞÞüÞþüÞ»büÞÄüÞÉÉüÞüÞÃüÞ³Ñ³Ñ8ýÎýÎ88ÕÕ8
ýÎ�Ù¸Û�Ù8
—B‘‘Ý%”‡
�•‰&�Ž6Òß�ñ’KýÎ³ÕÊÓ˜Ô¬âà
à
á
åjä
ìç¹ƒ}@e`ýÄæCñCžýáýá£ýáà`ýáƒƒ„æE…ìç¸þøaŸþ„
Óýáà`��ÆG ãF’¢úG’8ª´¼”Œ0¨8ÍþãÞãžãã£ãÄãà`ô
ô
õ
ûkø
ì&Ð†
¸‰ôPæãÍþ´äÞ´ä¬â´äž´ä´ä£´ä»b´äÉ´ä´äÃ´äÄ´äÉ´ä®Jô
ô
õ
ûkø
ì&Ð†
¸‰ôP³ÑÍà`××ØûJÚìÐÛíÐÉZ_Û#ŸåúæãÄ©æÉø°ú°û°Ðü°ý°�þ°ìH�ËˆXêE>³Ñþ©æÞ©æž©æ©æ£©æà`öö÷ÞLùìÐúíÐûîÐFé4yÊdîæãÓüçýæöö÷ÞLùìÐúíÐûîÐFé4yÊdî¨8žüçüç£üçÉüçüçÃüçà`©©ªên¬ìÖ±ËúÇÒOUÍ¬âëéžëéëé£ëéáëéÞëéþëéÉëéëéÃëé»bëéÄëéúëéÍú¥ÍÉÍúçÍÉÍú©©ªên¬ìÖ±ËúÇÒOUÉÍú©©ªên¬ìÖ±ËúÇÒOUÉÍú¥ÍÉÍúçÍÉÍúõëÉÍúÏìÉÍÄÉÍÄ£	£	¤	Ï¦	ì€	™‘‹ÖqËîÉÏîÍÏî™ÏîÄÉÍÉ£	£	¤	Ï¦	ì€	™‘‹ÖqËîÉÉÍÍÄÉÍÄÉÍÄ³ÑÍÉóðÍóðÓÓƒÙÄîîïüxòìóít!KìL Ó!¦WÉæñìñà`®ñž®ñ®ñ£®ñÉ®ñ®ñÃ®ñÞ®ñþ®ñÄ˜
˜
™
·{�
ìž
íŸ
îEÕAŸH>ÕÕæñìñkÉæñìñ§óà`ÞòžÞòÞò£ÞòÉÞòÞòÃÞòÞÞòþÞòÄÍ
Í
Î
À~Ó
ìÔ
íÕ
îÖ
ï¾N@Rze¶æñìñ§óí~Éæñìñ§óñôà`›ôž›ô›ô£›ôÉ›ô›ôÃ›ôÞ›ôþ›ôÄ��Ž¢‚”ì•í–î—ï˜ð	pŠÄ‘ƒæñìñ§óñô—BÉæñìñ§óñôÍöà`éõžéõéõ£éõÉéõéõÃéõÞéõþéõÄØØÙÛ†àìáíâîãïäðåñ©úþXZŒTæñìñ§óñôÍöðÉæñìñ§óñôÍö¹øà`È÷žÈ÷È÷£È÷ÉÈ÷È÷ÃÈ÷ÞÈ÷þÈ÷Ó®®ì‹²˜Œ‹³¡Œ‹´¶C‹+MéãîDæñìññCà`·ùž·ù·ù£·ùÉ·ù·ùÃ·ùèŽòŽ®®ì‹²˜Œ‹³¡Œ‹´¶C‹+MéãîDæñìññC
èŽòŽ¨®®ì‹²˜Œ‹³¡Œ‹´¶C‹+MéãîDÓ!¦WñCÓòòõ�÷˜Œ‹ø¡Œ‹ùŠ‹ú¶C‹Ñ&?)œ
óæñìñ§óñCà`´üž´ü´ü£´üÉ´ü´üÃ´üÀûÆûÒ“òòõ�÷˜Œ‹ø¡Œ‹ùŠ‹ú¶C‹Ñ&?)œ
óæñìñ§óñC
èŽòŽÒ“¨òòõ�÷˜Œ‹ø¡Œ‹ùŠ‹ú¶C‹Ñ&?)œ
ó›ü¡ükñCÓÄÄå”Ê˜Œ‹Ë¡Œ‹ÌŠ‹ÍÞ‹Î¶C‹tüþèe '·æñìñ§óñô²ûà`äÿžäÿäÿ£äÿÉäÿäÿÃäÿÝþãþéþ£™ÄÄå”Ê˜Œ‹Ë¡Œ‹ÌŠ‹ÍÞ‹Î¶C‹tüþèe '·æñìñ§óñôñC
èŽòŽÒ“£™¨ÄÄå”Ê˜Œ‹Ë¡Œ‹ÌŠ‹ÍÞ‹Î¶C‹tüþèe '·›ü¡üÒÿí~	ñCÓ¤¤Çš«˜Œ‹¬¡Œ‹Š‹®Þ‹¯¿‹°¶C‹ŠÛƒÁäwæñìñ§óñôÍö§üà`ÌƒžÌƒÌƒ£ÌƒÉÌƒÌƒÃÌƒ®‚´‚º‚À‚	æŸ¤¤Çš«˜Œ‹¬¡Œ‹Š‹®Þ‹¯¿‹°¶C‹ŠÛƒÁäwæñìñ§óñôÍö
ñC
èŽòŽÒ“	£™
æŸ¨¤¤Çš«˜Œ‹¬¡Œ‹Š‹®Þ‹¯¿‹°¶C‹ŠÛƒÁäw›ü¡üÒÿ¹ƒ—BñCÓ’’›¡š˜Œ‹›¡Œ‹œŠ‹�Þ‹ž¿‹Ÿþ‹ ¶C‹*êX¶v”·æñìñ§óñôÍö¹øÏþà`í‡ží‡í‡£í‡Éí‡í‡Ãí‡¹†¿†Å†Ë†Ñ†›§’’›¡š˜Œ‹›¡Œ‹œŠ‹�Þ‹ž¿‹Ÿþ‹ ¶C‹*êX¶v”·æñìñ§óñôÍö¹øñC
èŽòŽ	Ò“
£™æŸ›§¨’’›¡š˜Œ‹›¡Œ‹œŠ‹�Þ‹ž¿‹Ÿþ‹ ¶C‹*êX¶v”·›ü¡üÒÿ¹ƒÚ‡ð
ñCà`ŽŽá¨‘ë’‰©›ì›);i´àæñìñ¬âÇŒžÇŒÇŒ£ÇŒÉÇŒÇŒÃÇŒÞÇŒà`®®Üª±ë²‰©ˆÿ‹§�@æñ¡Ç¬âÖ�žÖ�Ö�£Ö�ÉÖ�Ö�ÃÖ�ÓÖ�ÇŒ®®Üª±ë²‰©ˆÿ‹§�@æñèÈ
ŽŽá¨‘ë’‰©›ì›);i´à›ü¡ü¨®®Üª±ë²‰©ˆÿ‹§�@›ü±Î³ÑþÊËÆ¬Ì”Í¾	Îë¬Ï”é|ú?�Õ}·áÀ�ÞÀ�à`À�¬âÀ�žÀ�À�£À�å`À�ÏÀ�ÀªªŽ¨½®¿½¯°7½Ê˜!ÚÆdG
ýÎ¨ÀààáÔ*åì6
ä>(ùOèýÎÏÊ¨À

—@¿#à›6¢ýÎ¨
ªªŽ¨½®¿½¯°7½Ê˜!ÚÆdG
½^Õ½^½Ý
ªªŽ¨½®¿½¯°7½Ê˜!ÚÆdG
½^ýÎ½^�Ù
½^�Ù½^�Ù
ààáÔ*åì6
ä>(ùOè½^ýÎƒÏ½^˜Ô
ààáÔ*åì6
ä>(ùOè½^Õ³Õ½^ààáÔ*åì6
ä>(ùOè8Õ³Õ
½^‘‘Ý%”‡
�•‰&�Ž6Òß�ñ’KýÎÏÊ½^…—°ª³ª
Ô	Ð	è	ä	ü	ø	�Œ
íàÅªÓ
Æ
°�‚ô
î×Â©‘
îÄ
˜
‚Í
Ë�ŸØªŽÒÊ+
ÿà¶ª0
öàðª§©‚©Ž©š©¦©²©¾©Ê©Ö©4
Ö	Ð	ê	ä	þ	ø	”
Œ
 
™
«
¥
Ï‘òàÂ
½
�ÂÍªÊ
Æ
ÿà
£�ù
ô
à×ÿö®©þî¬
˜
å
Í
©�øØÅ®ŽòåÄÊ¤½’“Ž³®ÔÊ8
Ü	Ð	ð	ä	„
ø	µ

À‘�à™àŸà�Â„Â‡Â‹ªÒª×ªÚªÍ
Æ
é
à
´�Œô
ñ×Žöµ©‚
î±
˜
ë
Í
°�€ØÊ®”òìÄÒ¤Æ’šŽº®×Ê<
Þ	Ð	ò	ä	†
ø	¹

Ä‘•àÿÂÐªÏ
Æ
ï
à
¸�’ô
ô×‘öº©†
î¶
˜
ñ
Í
·�ˆØÏ®šòóÄÚ¤Ï’žŽ¾®ÙÊ?
à	Ð	ô	ä	ˆ
ø	Ç‘¨à’Âäª¡Æ
�ô
“öË©‰
îº
˜
ö
Í
½��ØÓ®ŸòùÄá¤×’¢ŽÂ®C
â	Ð	ö	ä	Š
ø	Ë‘à•Âèª£Æ
£ô
–öÐ©�
î¿
˜
ü
Í
Ä�—ØØ®¥ò€Äé¤à’¦ŽÆ®G
·¼
Á
Æ
ÍªÔ
Ýà†ƒ†ø°Ý
«
‡
ñ
é
¥ŽO
S
ê
º
˜
„
þ
®Ž“	ª—	ª›	
Ÿ	à¤	à©	
Ò	Ð	æ	ä	ú	ø	‹Œ
Ö
Æ
�þ
ô
ì×È©•
îÉ
˜
ˆÍ
Ò�§ØÐÊÓ	Ð	ç	ä	û	ø	Ò
Æ
¿©ÑÊØ	Ð	ì	ä	€
ø	×
Æ
—ô
Õ©Û	Ð	ï	ä	ƒ
ø	²

Ì
Æ
å
à
ˆô
²©—Ž·®ÖÊjÐ	mä	rø	w}©„©”Œ
ûà›
àªÀô
¶™
ä½
½™
ê½
ë¥
áÊì¥
ÚÊ´‘ûÂŒà
‚öü‚	¼®„òÚÄ¾¤°’ ®»‘Ó‘˜
Éªìªî½
šÆ
»�ã×¤©±¸£	ÄÛâ
ëôî 
˜
×
Í
™�æØ�Äô
çø°…‘�©µÁÍÙ³»£	ÆË£	ÏÔÝä
ðø
¥

Ý

 
î
Êô
Š–¢®ºÆÒÞ·¿£	ÊÙÚáè
øÀ£	Ðìªöà€	
¨âì„Þìˆúà` Rž$Þ£úÉÉÃ¦¦
YþPái»b*¬â*aMdÄÞK!©KÏå`Ó¦˜NñòJÄÉ]®JƒÍ™PÎÀÃ/üï/!¤ï/,ï/—ã�0üØ/9

´Ø/
¢—ã\,	�0£0å1ü©0–
¾2�3œ€3
	t€3
'¡Ç7,’3œ3£3 üŸ.„ü¿/ÞüŸ0þ

—@¿#à›6¢¡Ç$Ü.—ã,È.��Î�Ãóî�Á üæ«é—ã¸¥«¹—ã»£Æ]ú^£Æ5bytesÁvá@—üÐB\êB
‰¡Çü�B¸

¡ÇÇCÎC'üÑAý¯$�B£ÆêA£Æ—‰‰ŠPhantomDataÁÑ{·Ë…YÚÁ¯¼@Ko2Á2Á4Á4Á\…"Attempted to build VarZeroVec out of elements that \
                                     cumulatively are larger than a u8 in size"Á´¸
	¤¸
˜$ü¤+y,°$_Átë<ëÖÇüÔ&zå$;ÖÇ_Á2Á]Ø±†"Attempted to build VarZeroVec out of elements that \
                                     cumulatively are larger than a u16 in size"Á´°$
	¤°$
˜¥Í%üœ$+€,¨$%_Á|ã$Dã$ðÈüÌ$'�Ý$%<ðÈ_Á4Á]Ø±†"Attempted to build VarZeroVec out of elements that \
                                     cumulatively are larger than a u32 in size"Á´ó)
	¤ó)
˜çÍ%üß)+‡,ë)%_ÁD¦*
‰Êü�* ˆ *%B‰Êu32::MAXÁ,ž
¬�
	úÐ£
ª
üü�©
¬º,Â
í,±
íeã9”ñ
—ãˆ
‰
ÿüºO
í,á
¬º,×
íd6dœ"œ"™³Ñ¹Ñ<Idíž"}ä�"	àÑ¨"°"±"™ü“!ž¬½l¯!íÞíæÍ¼àÍ¼èÏ¼�"Í¼úK
)™ƒÍ¼EÏ¼^U,ß'¬Ð'	¬½ä'ë'œüÉ&¢¬½,ƒ'í,ò&íbã9”¼D—ãÓDÔD£üŒDHí,¬D¬½,¢Díd6üþF$˜G
æ³Ñ¹ÑœGüóF+
à³Ñ¹Ñ�G¤G¤ü¨F|ààáÔ*åì6
ä>(ùOè³Ñ¹Ñ¤ÔF¬½DÇFæêëº+ììµáùý�³Ñ¹Ñ¬½S¬üå<4Ìÿ<
¼ÿ<
™ýÎƒÏ6:P
æýÎƒÏ˜=üà<:
àýÎƒÏ™=Ÿ= =ˆü»<eààáÔ*åì6
ä>(ùOèýÎƒÏ$Ñ<æêëº+ììµáùý�ýÎƒÏ?˜ÔB‹ÆK¢
ü€EwüšE\	,ðE$	‹Æ3õEQ
æýÎƒÏöEüûD}
àýÎƒÏ÷EýEþEŠü¯DÏŒÅ$ìDí,ØDÌÅß‹ÆÞ‹Ææíßã-Q
Ì›°È³Ñ³ÑÊFS`
þÈ²…
Œ¤›
Ì³Ñž®²³¹ºÈüç
S©Ølƒ»Ê¾ÉûÈ
ûÈýÈ±ûÈ)R
þÈKZÈ‹ûÈvýÈ`†<‚ÀÉ ôì

	¬ì

ù³ÑR-‰��Éü±
_ªªŽ¨½®¿½¯°7½Ê˜!ÚÆdG
³ÑtÓ
»Ê,É
¾Éê¾Éò…	üð£ü…�
ü®	t®,®
$4´
‡q4D´	»aþÈrÌüÛ,	\Û
,Û
$á
Ýp4
,áåôé
äé
˜þÈ,‹
—«	

»		
†
m
uÜ…
îoþÈ�	 ¥‘	Ë
Ó¤ðâÉÞñö’˜™ËüÔÅ»Ê,Ží,ý»ÊV¾ÉU¾É^üÎWüÎ`[í\öõíö´ãu™
üá$üã"Œä,ä0©Ø„R_Œ�Ìü’û»Ê,Ã¾É,®»Ê¶’ÔµÀÉ¶�Õ¾î.R<�"ÀÉ©"ª"Îüå!E¾ÉL‰"»Ê,ÿ!¾Éd6œý&$ý&#
*d‚'
Î³Ñ5t‚'Q�'Ìý&
	‘'
ÝpþÈˆ,‘'•'›'œ'ÏüÒ&J,í&»Ê,ã&¾ÉÚ¾Éâ»ÊÜ#EœÅ+$Å+#
*dÊ+ùÖ/tÊ+K×+ôÅ+
	DÙ+
ÞpþÈ‚TÙ+â+è+é+Ðü–+S$¶+»Ê,¬+¾ÉÓ¾ÉÛ»ÊÕ#DüÏF3œîF$îF#
*dóFùÖ/tóFK€Gi
pôÏF
Ì°2ƒ”˜�G‡GˆGÛüêEžÂÂÃæÅì¾ÈE(�mÇÓÛl‰F»Ê,ÿE©Ü%¾É%¾É.»Ê)/‡üú*#üü*!	Œý*Dý*��Î�Ãóî�Á üæ«é
æãO
V4†+
®“ÞgD†+	Œ“Þ�+«ÑÞœ+ËØ¤+¥+Âü�*¤“Þ<¤*»»Ž8½á½K'L)óî1#æãD—*Âß\ÑÞ\ÑÞe“ÞaæÝb:‘	¿P÷ýÎÔÚAN[ÓÚÁP¼¬P
	”¬P
ùýÎœ-ÂPÈPÉP÷ü‡PBªªŽ¨½®¿½¯°7½Ê˜!ÚÆdG
ýÎ$�P¼á*€á3€á<‚áÀP€áO�
ÔÚq€÷Æ€áœ‚á`¬´ÖQ\ÖQ»»Ž8½á½K'L)óî1#ÔÚU
\DâQ
ÂÔÚgTâQƒëQäÖQ
	íQ
ÝpÔÚº,íQñQ÷QøQøü¥QS,ÆQ©â,¼Q¼á¼á±ä)N,Ò]üú]	œú],ú]6ÓÚG˜^üã]7

´ã]
¢ÓÚ~,™^œ^üÁ^…,ë^
»ÔÚÅ_\Ý_		
‰ÔÚ\ÿ_


‰ÔÚü¦^ï
ªýÎ	
”`
	š`›`ùü�\ŽüÎ]Í©â$¿\¼á,§\��Î�Ãóî�Á üæ«éÓÚÐ›çÑ›çÚÓÚÖ¹êß±äWñéV‰‰ŠÁ¯Ñ{·Ë…YÚÔÚR‰‰ŠÁ¯Ñ{·Ë…YÚêèdîØî~üôm�
ü�n	t�n,�n
$4£nÏÎ/D£n	ªn\ÔÚm»nüÊn,\Ên	,Ên


$ÐnÎÏ
/	,ÐnÔn
ôØn
äØn
˜ÔÚ,†’¦		¶		õn	c
kÜôm
îoÔÚwý•š€oüám¡
”ámááÕ(�o‡oˆoûüÃlÅ
©â$€mí,ìl¼á.¼á7Þì0Þì9õÒ3í4ÓÒíÓ–óãk�,‚}´•}\•}±ä"
)D¡}õä4T¡}Jª}«}üµ} ,Ï}
%Ìµ}
ÌýÎ6GKÔ}Ú}Û}üüÆ|•üþ|]�Ùlæ|‹æ,Ü|¼á¼á ªæ!‘óË¼áÊ6îXr3Á3Á3ÁÄÀTÀÁÉ9
@\Ë
‹ËNlË×±µ¹Ødç	è

ìðA	

ò
”â
Æ
	ó	ùú˜üó‡ü¨R
üÞ$™�B3$ÜÜÛ11&Šu0ÁÇu1Á¾u2Áµ_u3ÁãPPÐdü4�‚2
Æ
‡hPÝÍPé(PüP„øP�`(P‡P‡				P‹Í:	xP«
0P³P·	
)Í7	
AÍSi
p8P«
˜}
ŽP¹P¦	HPŸÍ	'ÍØPŸ
f
Pº	0PÌPÑ&	(LøP�Tààç
ï	»	øà�`<BPà0PîPý	PþÚ
øPõ‰øPÌ²øPø†~üÞÍHP´ÍP�ÌÿEüÞE§øFìÎxÉÈüÞŒŠ‰™¯&.5arrÁ Û
ç»€,Í
ÍÍ|ÍˆÍ3Á2Á˜œ�(œ�

&Xœ–
òÉ4hœ–œ¢Èœ‹
©œ£œ²ÝøœÅm¥Í œô(œßÑÎ˜*PP¢Ð¸œ¥Pœ±
œ²8
©œ»h¢ÝÍ¢é(¢ü¢„ø¢�`
(¢‡¢‡	
		¢‹Í= 	x¢«
0¢³¢·

+Í9	
CÍUl
s8¢«
Ý€
’¢¹¢¦
H¢ŸÍ	(ÍØ¢Ÿ
j
¢º
0¢Ì¢Ñ(	)Nø¢�T
âà÷
ÿ	È	øâ�`<B¢à0¢î¢ý
¢þÞø¢õ‰ø¢Ì²ø¢ø†•¥ÍÍH¢´Í¢�åŠz¥ÍyÙƒxè~âà¥Í¢ ž¯!Û€»/7>€€žÛ
»™@ÍÍ(Í‰Í•Í2Á4Á˜¦�(¦�

&X¦–ƒõ1h¦–¦¢È¦‹
©¦£¦²çø¦ÅmçÍ ¦ô(¦ß‚øÁ¾˜CP¬Ð¸¦¥P¦±
¦²8
©¦»h¬ÝÍ¬é(¬ü¬„ø¬�`
(¬‡¬‡	
		¬‹Í= 	x¬«
0¬³¬·

+Í9	
CÍUl
s8¬«
ç€
’¬¹¬¦
H¬ŸÍ	(ÍØ¬Ÿ
j
¬º
0¬Ì¬Ñ(	)Nø¬�T
äà÷
ÿ	È	øä�`<B¬à0¬î¬ý
¬þèø¬õ‰ø¬Ì²ø¬ø†•çÍÍH¬´Í¬�î•zçÍy‚øxè~âàçÍ¢ ž¯!Û€»/7>€€žÛ
»™@ÍÍ(Í‰Í•Í4Á8Á˜°�(°�

&X°–
¤Ì4h°–°¢È°‹
©°£°²ñø°Åmõë °ô(°ßÑÎ˜*PP¶Ð¸°¥P°±
°²8
©°»h¶ÝÍ¶é(¶ü¶„ø¶�`
(¶‡¶‡	
		¶‹Í= 	x¶«
0¶³¶·

+Í9	
CÍUl
s8¶«
ñ€
’¶¹¶¦
H¶ŸÍ	(ÍØ¶Ÿ
j
¶º
0¶Ì¶Ñ(	)Nø¶�T
æà÷
ÿ	È	øæ�`<B¶à0¶î¶ý
¶þòø¶õ‰ø¶Ì²ø¶ø†•õëÍH¶´Í¶�‡¡zõëyû™xè~âàõë¢ ž¯!Û€»/7>€€žÛ
»™@ÍÍ(Í‰Í•Í8Á16Á˜º�(º�

&Xº–
½Í4hº–º¢Èº‹
©º£º²ûøºÅmÏì ºô(ºßÑÎ˜*PPÀÐ¸º¥Pº±
º²8
©º»hÀÝÍÀé(ÀüÀ„øÀ�`
(À‡À‡	
		À‹Í= 	xÀ«
0À³À·

+Í9	
CÍUl
s8À«
û€
’À¹À¦
HÀŸÍ	(ÍØÀŸ
j
Àº
0ÀÌÀÑ(	)NøÀ�T
èà÷
ÿ	È	øè�`<BÀà0ÀîÀý
ÀþüøÀõ‰øÀÌ²øÀø†•ÏìÍHÀ´ÍÀ�¡¬zÏìy•¥xè~âàÏì¢ ž¯!Û€»/7>€€žÛ
»™@ÍÍ(Í‰Í•Í16Á2Á2Á2ÁxÅ¡(Å¡(

&XÅ£(Í‚1hÅ£(Å¯(àÅ•(
©Å°(Å¿(�øÅÙ'f¥Í Åþ'Åñ'ÙƒÁ¾vÁD4Á4Á4ÁxÇ¡(Ç¡(

&XÇ£(ƒõ1hÇ£(Ç¯(àÇ•(
©Ç°(Ç¿(™øÇÙ'fçÍ Çþ'Çñ'‚øÁ¾ç¯D8Á8Á8ÁxÉ¡(É¡(

&XÉ£(ï˜1hÉ£(É¯(àÉ•(
©É°(É¿(¥øÉÙ'fõë Éþ'Éñ'û™Á¾ç¯D16Á16Á16ÁxË¡(Ë¡(

&XË£(‰¤1hË£(Ë¯(àË•(
©Ë°(Ë¿(±øËÙ'fÏì Ëþ'Ëñ'•¥Á¾ç¯D2Á2Á2ÁxÍ¡(Í¡(

&XÍ£(
ÖÂ4hÍ£(Í¯(àÍ•(
©Í°(Í¿(½øÍÙ'f¥Í Íþ'Íñ'ÙƒÄÁç¯D4Á4Á4ÁxÏ¡(Ï¡(

&XÏ£(
ðÃ4hÏ£(Ï¯(àÏ•(
©Ï°(Ï¿(ÉøÏÙ'fçÍ Ïþ'Ïñ'‚øÄÁç¯D8Á8Á8ÁxÑ¡(Ñ¡(

&XÑ£(
ŠÅ4hÑ£(Ñ¯(àÑ•(
©Ñ°(Ñ¿(ÕøÑÙ'fõë Ñþ'Ññ'û™ÄÁç¯D16Á16Á16ÁxÓ¡(Ó¡(

&XÓ£(
¤Æ4hÓ£(Ó¯(àÓ•(
©Ó°(Ó¿(áøÓÙ'fÏì Óþ'Óñ'•¥ÄÁç¯DÔê(Ôð
XÔð
ÔöÎÏ7(ÔöÔúPÔÃXÔ½Ô½
Ö.<P	`
DÔÇ’ÔÌ¶&øÔç,øÔð!	(Ô‹


"
)ÐÔð
Ë
9	LP	Ô�
øÔä0
ê³ÂÂÃæÅì¾ÈE(�mÇÀ�Ô“Ô¥	øÔº²øÔÆ“Ô¿ 
!
ÊøÕü)Ø±ÔØ øÔÂ˜
ê³ÈÄÀ�ÔÙ ’Ôë Ôù Ôú ãøÔ�ëøÔæ”Ø
ê³í³î³Òï³ìð³ñ³“ò³ìäs{©¶‘ÈÄÀ�¸Ô¼í(Ô«PíOÈÄ[ÈÄYíWÀ�…�ãj¾	¼Öê(Öð
XÖð
ÖöÎÏ7(ÖöÖúPÖÃXÖ½Ö½
ø.<P	`
DÖÇ’ÖÌ¶&øÖç,øÖð!	(Ö‹


"
)ÐÖð
Ë
9	LP	Ö�
øÖä0
ê³ÂÂÃæÅì¾ÈE(�mÇÀ�Ö“Ö¥	øÖº²øÖÆ“Ö¿ 
!
Êø×ü)Ø±ÖØ øÖÂ˜
ê³›ÌÀ�ÖÙ ’Öë Öù Öú åøÖ�ëøÖæ”Ø
ê³í³î³Òï³ìð³ñ³“ò³ìäs{©¶‘›ÌÀ�¸Ö¼í(Ö«PíO›Ì[›ÌYíWÀ�…�ãj¾	¼Øê(Øð
XØð
ØöÎÏ7(ØöØúPØÃXØ½Ø½
š/<P	`
DØÇ’ØÌ¶&øØç,øØð!	(Ø‹


"
)ÐØð
Ë
9	LP	Ø�
øØä0
ê³ÂÂÃæÅì¾ÈE(�mÇÀ�Ø“Ø¥	øØº²øØÆ“Ø¿ 
!
ÊøÙü)Ø±ØØ øØÂ˜
ê³îÓÀ�ØÙ ’Øë Øù Øú çøØ�ëøØæ”Ø
ê³í³î³Òï³ìð³ñ³“ò³ìäs{©¶‘îÓÀ�¸Ø¼í(Ø«PíOîÓ[îÓYíWÀ�…�ãj¾	¼Úê(Úð
XÚð
ÚöÎÏ7(ÚöÚúPÚÃXÚ½Ú½
¼/<P	`
DÚÇ’ÚÌ¶&øÚç,øÚð!	(Ú‹


"
)ÐÚð
Ë
9	LP	Ú�
øÚä0
ê³ÂÂÃæÅì¾ÈE(�mÇÀ�Ú“Ú¥	øÚº²øÚÆ“Ú¿ 
!
ÊøÛü)Ø±ÚØ øÚÂ˜
ê³ÁÛÀ�ÚÙ ’Úë Úù Úú éøÚ�ëøÚæ”Ø
ê³í³î³Òï³ìð³ñ³“ò³ìäs{©¶‘ÁÛÀ�¸Ú¼í(Ú«PíOÁÛ[ÁÛYíWÀ�…�ãj¾	¼Üê(Üð
XÜð
ÜöÎÏ7(ÜöÜúPÜÃXÜ½Ü½
ß/<P	`
DÜÇ’ÜÌ¶&øÜç,øÜð!	(Ü‹


"
)ÐÜð
Ë
9	LP	Ü�
øÜä0
ê³ÂÂÃæÅì¾ÈE(�mÇÀ�Ü“Ü¥	øÜº²øÜÆ“Ü¿ 
!
ÊøÝü)Ø±ÜØ øÜÂ˜
ê³”ãÀ�ÜÙ ’Üë Üù Üú ëøÜ�ëøÜæ”Ø
ê³í³î³Òï³ìð³ñ³“ò³ìäs{©¶‘”ãÀ�¸Ü¼í(Ü«PíO”ã[”ãYíWÀ�…�ãj¾	¼Þê(Þð
XÞð
ÞöÎÏ7(ÞöÞúPÞÃXÞ½Þ½
ü0<P	`
DÞÇ’ÞÌ¶&øÞç,øÞð!	(Þ‹


"
)ÐÞð
Ë
8	KO	Þ�
øÞä0
ê³ÂÂÃæÅì¾ÈE(�mÇÀ�Þ“Þ¥	øÞº²øÞÆ“Þ¿ 
!
Êøßü)Ø±ÞØ øÞÂ˜
ê³æêÀ�ÞÙ ’Þë Þù Þú íøÞ�ëøÞæ”Ø
ê³í³î³Òï³ìð³ñ³“ò³ìäs{©¶‘æêÀ�¸Þ¼í(Þ«NíMÿæêYæêWíUÀ�…�ãj¾	º1Á4ú?
$û?ü×?*Â<ð?3_Á1Á4Á8Á2Á2Á2Á2Á2Á2Á3Á3Á3Á3Á3Á3Á4Á4Á4Á4Á4Á4Á5Á5Á5Á5Á5Á5Á6Á6Á6Á6Á6Á6Á4¢
¥
©
%žÐ1À�9@ü¹+1
àýÎƒÏ#á0ŒÅ<ÌÅDKD•-
æýÎƒÏ"ë/ÌÅ;‹ÆCJôí	
Â³ÑÃ)©Ø5ÀÉ=Dü�f&
½
ýÎ¾
,½
½
¾
åhÁ
ì¾žóP¾7ŠyôýÎkÙiÙiIterÁÜi÷®iÝi
end_or_lenÁ®iÞi_markerÁ®it¸%ýN(ÔÚÏÖ”ï	
Æ
Ç
%üÞ1§ø9@ü¸E
à
æC´â#á
0ýá<

Øg°
‡
î±
‰&î(£Tªt_—ã´â�ˆÄÆ$
ƒ„%æâ18?üÛ0*	
ô
æãÍ#õ
0´ä<ø°ú°û°Ðü°ý°�þ°ìH�ËˆXêE>æãˆ�¼±
×æãØ,©æ8>�Ò�ÒMaybeUninitÁ�ÒuninitÁü�Ò˜ügÇ@ÇeÉRæã”›ü¸$+
öæã#÷0üç<‰‰ŠÁ¯Ñ{·Ë…YÚæãjp—ãxü‹&
©Íª,ëé8¡ë@Gøà '
îæñìñ&ï3®ñ?æñGìñOVøâ '
˜
æñìñ§ó-™
:ÞòFæñNìñV§ó^eøä '
Í
æñìñ§óñô4Î
A›ôMæñUìñ]§óeñômtøæ '
�æñìñ§óñôÍö;ŽHéõTæñ\ìñd§ólñôtÍö|ƒøè '
Øæñìñ§óñôÍö¹øBÙOÈ÷[æñcìñk§ósñô{Íöƒ¹ø‹’X½‘âŠ	´	¶	³ß=LÑ²��0<�¹�›Cœ˜æ—T¤O
	Ý%d�Q‘¯	Ô*T£Qà°	Ô*á°	æ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ÁûËtÿ # ExamplesÁŽËü’PM 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"Á<¦#æ¡®#Ëü²#'$ Use custom types inside of ZeroVec:ÁÚ#Ë\Þ# ```rustÁüê#:7 # #[cfg(all(feature = "serde", feature = "derive"))] {Áü¥$0- use zerovec::{ZeroVec, VarZeroVec, ZeroMap};ÁÌÖ$ use std::borrow::Cow;Áüð$+( use zerovec::ule::encode_varule_to_box;Áœ%Ëü %-* // custom fixed-size ULE type for ZeroVecÁüÎ%! #[zerovec::make_ule(DateULE)]Áüð%`] #[derive(Copy, Clone, Par
     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>,ÁÄÙ,ú£üò,96     birthdays_to_people: ZeroMap<'a, Date, PersonULE>Á,¬-¸¥²-Ë¶-ËÔº- let person1 = Person {ÁüÕ-.+     birthday: Date { y: 1990, m: 9, d: 7},Áü„.!     favorite_character: 'Ï€',Áü¦.     name: Cow::from("Kate")Á4Æ.Ä§ÔÍ. let person2 = Person {Áüè./,     birthday: Date { y: 1960, m: 5, d: 25},Áü˜/"     favorite_character: 'å†‡',Áü»/      name: Cow::from("Jesse")Á4Ü/Ä§ã/Ëüç/�� 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}]);Áüø0C@ let important_people = VarZeroVec::from(&[&person1, &person2]);Áü¼1KH let mut birthdays_to_people: ZeroMap<Date, PersonULE> = ZeroMap::new();Áüˆ2ZW // `.insert_var_v()` is slightly more convenient over `.insert()` for custom ULE typesÁüã2B? birthdays_to_people.insert_var_v(&person1.birthday, &person1);Áü¦3B? birthdays_to_people.insert_var_v(&person2.birthday, &person2);Áé3Ëüí3OL let data = Data { important_dates, important_people, birthdays_to_people };Á½4ËüÁ41. let bincode_bytes = bincode::serialize(&data)Áüó463     .expect("Serialization should be successful");Áüª5)& assert_eq!(bincode_bytes.len(), 160);ÁÔ5ËüØ5A> let deserialized: Data = bincode::deserialize(&bincode_bytes)Áüš68Ö©Ó6Ëü×6EB assert_eq!(deserialized.important_dates.get(0).unwrap().y, 1943);Áü�7MJ assert_eq!(&deserialized.important_people.get(1).unwrap().name, "Jesse");Áüë7LI assert_eq!(&deserialized.important_people.get(0).unwrap().name, "Kate");Áü¸8_\ assert_eq!(&deserialized.birthdays_to_people.get(&person1.birthday).unwrap().name, "Kate");Á˜9Ëüœ9#  } // feature = serde and deriveÁ<À9æ¡È9ËŒÌ9 # PerformanceÁÞ9Ëüâ9a^ `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 |Áüè>IF | Binary search vec of 500 strings 10 times | 466.09 ns | 790.33 ns |Á²?Ëü¶?ÝÚ \* *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`.*Á”AËü˜AEB | Operation | `HashMap<K,V>`  | `LiteMap<K,V>` | `ZeroMap<K,V>` |Á¬ÞA |---|---|---|---|ÁüôA>; | Deserialize a small map | 2.72 Î¼s | 1.28 Î¼s | 480 ns |Áü³B=: | Deserialize a large map | 50.5 ms | 18.3 ms | 3.74 ms |ÁüñBEB | Look up from a small deserialized map | 49 ns | 42 ns | 54 ns |Áü·CGD | Loo
Î<º�ZeroFromÁDÑ
îØ5üÏ.ãåÏÑÀÂL´ŸÌÃ‘„™p”¯c”ÇNüë$üÜ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.ÁTö¨±ªâ¡Ç…¡Ç¨Ü×
éÆ#à›6¢�24”¿
¿


£ÆI<×


‰‰ŠÁ¯Ñ{·Ë…YÚ½Ç¤Žl•£Æuê\ŠØ…ÅÄ”ÔÔúüû"£Æü¡"£ÆäÈ£Æß¼ë,îÛÛ£Æ£Æô
$õüæ!/¨±‡äï!éÆßë!¼œ",Ÿ"ÜÜéÆéÆ¥"
¨¡Ç$¦"üç#.¨±‡äð#Ó¡Ç4ó#éÆ !ì#$&üî$=üœ$MJ Construct from a slice. Errors if the slice doesn't represent a valid `V`Á\õ$¨—ãê³í³î³Òï³ìð³ñ³“ò³ìäs{©¶‘éÆÀ�
¨¡Çã,�%üŸ.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()`.Á¤³.úééÆ
 ¨¡Çãt–üè6'ü·6,) Construct a new borrowed version of thisÁdï6½ÇéÆ
!¨¡Ç–ü6üÔ=%¨#±$#$‡äÝ=éÆ%&'Ù=ô¥>ü€>  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üƒFDŠFàà£Æà—ã(“F(
*$”FüþF8¨,±-,-‡ä‡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à`¡ÇT¶KéÆ7á`7�K/1üéKCìKâãäâéÆãÁ`Á`œÃ`èÁ]Ä`áÁ]Ê\É:•äê³í³î³Òï³ìð³ñ³“ò³ìäs{©¶‘Ñ¼Ñ¼Ò¼”štÀ.4ðK4
7¨¡Ç$ñKþ÷KüžMH¨9±:9:‡ä§MØè4ªMž¡Ç¡ÇL¼MéÆ; ;£M35üíM"ðMåæåéÆæéÆ8óM8
;¨¡Ç$ôMî,úMüÂN:¨=±>>=‡äËNØè4ÎN£¡ÇàNéÆÇN&(ü�OJ¨@±AA@‡äŠOØè4�OÉ¡Ç¡ÇTŸOéÆBËB†O35üÒOB\ÕOçèçéÆèéÆø°ú°û°Ðü°ý°�þ°ìH�ËˆXêE>üÕýÕþÕLessÁÿÕ€Ö�Ö’‚ÖƒÖ„ÖGreaterÁ…ÖiÒ6’<Ë?á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ü¯
í—ã¬ÝTìíþ‚íƒ› ƒƒñT
J¨¡Çƒƒþ‚$ÏTÕT�‘‹�üãU%”æUîîéÆGùUG
M¨¡Ç$úUüÂV.¤ÅVïðïéÆð—ãGÚVG
N¨¡Ç$ÛVdstÁáVüÞdB¨P±QPQ‡äçdØè4êdéÆR
Rãd üµe"L¸e½ÇéÆOO
R¨¡Çî,Âeü…fV¨T¤U±VUVTªâèÈ’fÓèÈ4•f°ÈW
WŠfŽf,.üðf2Lóf¨ôÈ°ÈSS
W¨¤èÈî,ýft¬MT°MYéî�×Ý%d‹‘³¯	Ô*T™à´°	Ô*á´°	ƒe¤ÊŒ
µ�c<öä	·�cå	·ˆd<ÿø	¸ˆdù	¸“b4ˆÐ	¹“bÑ	¹‡f„�™
ºù„¢a»þf¬€¥
¼Ì‚T‘adÖÚÞäŒ
™
ä	å	ø	ù	Ð	Ñ	þf¬Ö¥
YZ¼ÕD�üÕY\¤<¬�Y]Á¯\Ç‰Y^Á¯ŠY^Ó
ÞÕY_æ,òÎ˜Y`�,Ï†Y[æUDÞ‹Y[²VDð•Y[â>·ÄY[ÀY,§4ÉY[åY,ÞAÍY[òYT„CÎY[³Z4ÝdÓY[Ü?tâY[µŽGT¡™Y[¸ÆG|»�Y[ºûJLÞ×Y[¼ÞLdéöY[½â>÷ƒ·Y[Ø³Z4É†¸Y[Ù¶¬DØ‡ÊY[´i<‰Æ
Y[´åjt�à
Y[¶ûkdô
Y[¹ûkõ
Y[¹ên\‡©Y[¾ênªY[¾äÏjTñœ„^´�QÌ¹DLØ$„çüÐ+üúC@ This trait allows switching between different possible internalÁü¾" representations of 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.Á„Úaa©â,öÀ•<ìa¸•"Ê•¸•.Ê•)bcbc©âÀ•b¼“d‰–TŸ�–˜–©âÀ•c¬À	d¼–TÊ	´–Ë–´“ü‚*' The type to use for the indexing arrayÁ±Ëü¹B? Safety: must be a ULE for which all byte sequences are allowedÁ¡‚…Œ8°4†t€,˜aa¤À	ü¯*' The type to use for the length segmentÁÞËüæB²–¡¯	²	¹	8°4³	t	Å	aaüÌ ¡¿ÂÉ8°4Ãt½TÝddªâÀ•üÌŒÄÀ•éd÷™)Šš÷™5Šš)efghiefghihiü¿#¡®±¸8°4²t¬|ÅddŒ¡
¡�
“
š
8°4”
tŽ
$§
dd¤Œ¡û
þ
…8°4ÿ
tù
L’ddüš ¡‰Œ“8°4�t‡l�À•dd
hÀ•$«üÓ-¡ÂÅÌ8°4ÆtÀ|Öø°ú°û°Ðü°ý°�þ°ìH�ËˆXêE>À•dd
iÀ•xÁæü³ ·ÉklbcTÚ,ßjjDïôjjü�!ÏÊnpbcT©,®mm¥ÍÂDÊÏmm¥Íáüè!çËsubcT�,•rrçÍ©D±¶rrçÍÈìÏxyz{|efghi|{üó#|ùww’›Œ¤$ªww¤ÔLÚwwü� l� ww
{$ž üÝ ,|à ø°ú°û°Ðü°ý°�þ°ìH�ËˆXêE>ww
|uÁð üº")¥Í€�‚ƒefghiƒ‚á"üê"#|ð"}}’›Œœ$$¢$}}¤Ì$LÒ$}}ü†%l‰%¥Í}}
‚$—%üè%,|ë%ø°ú°û°Ðü°ý°�þ°ìH�ËˆXêE>¥Í}}
ƒõ¡û%üý')çÍ†‡ˆ‰ŠefghiŠ‰¤(ü(#|³(„„’›Œß)$å)„„¤�*L•*„„üÂ*lÅ*çÍ„„
‰$Ó*ü¤+,|§+ø°ú°û°Ðü°ý°�þ°ìH�ËˆXêE>çÍ„„
Šõ¡·+ü‹5>¨Œ™�ðŽŒŽ�ªâýÎ”5©âƒÏŸ5ªÎ�5!üÍ5?¨�™‘ð’’�‘â¨Ö5ó¨á5ªÎ“ß“Ò5!#&(¼“6,–6ññªÎªÎ�œ6�
“¨ýÎƒÏ$�6üÄ6J¨•™–ð—–•—â¨Í6ó¨á6ÓýÎ4Ð6ªÎ˜Å˜É61368¤£7<¦7ªÎ””
˜¨ýÎƒÏü×7>¨š™›ðœ›œšâ¨à7ó¨ô7Ï«4ã7ªÎ�Ü7!#&(¤ª8±8ªÎ™™
�¨ýÎƒÏüÊ9P¨Ÿ™ ð¡Ÿ ¡â¨Ó9ó¨ç9Ï«4Ö9aƒÏ„ê9ªÎ¢¥¦§¨©ª«¬®¯°Ï9TVY[ü¥@J\¬@úéê³í³î³Òï³ìð³ñ³“
ƒÏbžÃŽž
°¨ýÎƒÏ$ÄŽüÔ–L¨²™³ð´´³²â¨Ý–ó¨ñ–Ï«4à–ç®„ô–±ÏµÙ–.024ü§—1ª—YªÎ±Ï±±
µ¨ýÎƒÏŠ®—ü‹™Y¨·™¸ð¹¹·¸â¨”™ó¨¨™Ï«4—™ç®„«™±Ïº»¼ßKàKäK»¼�™HJLNLë™$ð™¶¶Á·üƒš($†šóó±Ïø°ú°û°Ðü°ý°�þ°ìH�ËˆXêE>±ÏßK¶‹š¶
»¨ýÎƒÏ$�šü±§-L´§ôô±Ïø°ú°û°Ðü°ý°�þ°ìH�ËˆXêE>¶¾§¶
¼¨ýÎƒÏ$¿§üË¨b¨¾™¿ðÀÀ¿¾â¨Ô¨ó¨è¨Ï«4×¨ç®„ë¨±ÏÁªKÁÐ¨68:<´´©·©õõ±Ï½»©½
Á¨ýÎƒÏ$¼©ü�ªv¨Ã™ÄðÅÅÃÄâ¨Šªó¨�ªÏ«4¼ªÃýÎÚªç®„æªªÎÆÈ†ªBDFHü²¬?l¹¬ö÷öªÎ÷ýÎê³í³î³Òï³ìð³ñ³“ò³ìäs{©¶‘ÂÇ¬Â
Æ¨ýÎƒÏ$È¬needleÁ4Î¬<’Æ‚°Ç›°Ç¹°ÇÇÆÇýÎƒÏýÎñþýÎü¸„´¿øùøªÎùýÎ†¹ø°ú°û°Ðü°ý°�þ°ìH�ËˆXêE>�ÇÂßÂ
È¨ýÎƒÏ$à“Ç4îrangeÁ,‚®<æ®È‚°É›°É¹°ÉÉÈÉýÎƒÏ€É˜Éü‘¯j¨Ë™ÌðÍÍËÌâ¨š¯ó¨�¯Ï«4Ì¯ç®„ê¯ªÎÎÐÔ–¯468:ü¾±]„Å±úúªÎ˜ �ÇÊ˜ ÏÏÖ±Ê©â¥ÍÔè±û– ¥ÍûýÎ¬í±û¥ÍõÍ› ñþDú±
Î¨ýÎƒÏ¥Í$×±	predicateÁLÝ±y{üƒ´¢ÌŠ´üüªÎ¥Í†¹ëÉÊ˜ ÑÑ´ÊÓÍÔÇ´ý– ¥ÍýýÎ¬Ì´ý¥ÍäÏ› ñþDÙ´
Ð¨ýÎƒÏ¥Í$®´ÈÍL¼´ïÉ,ë´{}‚¹Ð‚°Ò›°Ò¹°ÒÒÐÒýÎƒÏ¥Í°¹Ð‚°Ó›°Ó¹°ÓÓÐÓýÎƒÏ¥ÍºÑÇÑü¹º¨üÃº YþþªÎ¥Í†¹�ÇÊ˜ ÕÕíºÊÓÍÔ‹»ÿ– ¥ÍÿýÎ¬�»ÿ¥ÍºÓ› ñþD�»
Ô¨ýÎƒÏ¥Í$îºÈÍL€»ïÉ,¯»{}üŸÎ«ü¦Î'€�€
›ü�—ã™×Ó!ØðÙÙ×ØáÎªâ³ÑÎÎ©â›üÑÎó¨ÔÎÓ³Ñ4‡Ï›ü³ÑŒŸÏç®„¹Ï
Ö³Ñ›üƒÏelementsÁD×ÎoutputÁ4çÎ€‚{}�ü¶àœÄ½à‚ƒ‚äÔƒ—ã™ÛÓ!ÜðÝÜÛÝéà¶ÕÖàÈÕÙàó¨ÜàãÕ4�áôÕŒ§áç®„Áá
Ú³Ñ›üƒÏ¤ÕDßàµÕ4ïàWY[]_aüÕæ§üÜæ'„„äÔø°ú°û°Ðü°ý°�þ°ìH�ËˆXêE>™ßÓ!àðáàáß—ç¶Õ„çÈÕ‡çó¨ŠçãÕ4¹çôÕŒÑçç®„ëç
Þ³Ñ›üƒÏ¤ÕD�çMOQSUW‰ëÞ‚°â›°â¹°ââÞâ³Ñ›üƒÏ›ü©Ù4ÑëÞ‚°ã›°ã¹°ããÞã³Ñ›üƒÏ©Ù©Ùü�í˜Ä–í……äÔ©Ù™åÓ!æðçåæçÂí¶Õ¯íÈÕ²íó¨µíãÕ4äíôÕŒüíç®„–î
ä³Ñ›üƒÏ¤ÕD¸íMOQSUWïîä‚°è›°è¹°èèäè³Ñ›üƒÏ¤�,¬¥
‹<Úå`éê”ÏüÃ1žÐüù&žÐíæ`íü¦D©†‡ˆ†žÐ‡Á`Á`œÃ`èÁ]Ä`áÁ]Ê\É:•ˆ˜ùìì
í$®þ´Ì³TÂ
ƒe¤â
Œ
îïÁ¯\«
‰îòÁ¯ŠîòÓ
Â
ÕîóÌœ+Yîð¦#éîðÉ#ˆîîðî,��îðœ£×îð�P+†îñæUQ+‹îñ²VR+•îñâ>S+ÄîñÀYT+ÉîñåYU+ÍîñòYV+Îîñ³ZW+ÓîñùÆ,aîð»Ü?o+îñµŽGp+™îñ¸ÆGq+�îñºûJr+×îñ¼ÞLs+öîñ½â>t+·îñØ³Zt+¸îñÙÝ%[.‘îð³¯	Ô*a.àîð´°	Ô*}.áîð´°	¶¬Ê+Êîñ�cp.ä	îð·�cˆ.å	îð·ˆd~.ø	îð¸ˆd–.ù	îð¸“bŒ.Ð	îð¹“b¤.Ñ	îð¹‡fš.™
îðºþf�.¥
îð¼´i�,Æ
îñ´åj‘,à
îñ¶ûk’,ô
îñ¹ûkª,õ
îñ¹ên–,©îñ¾ên®,ªîñ¾üÏ'
â,ü
TŠ
Ì�
ÛL¼
·ü»J
™õðöõö¶ÕÀ
©â¹ÑÔ
ãÕ4Ã
a¹Ñ„×
úÐ÷ùüýþÿ€EGACü³	\
lÈ	
øøúÐŒ
Œ
ƒe�
¾	Y‘
¿eY’
ÎeY“
‡
Y2fm?Ž~�ø³Ñ¹ÑôÖ	
ô
÷³Ñ¹Ñ$Þ	
¾	ä	
%'üþO
\…

úú—ãê³í³î³Òï³ìð³ñ³“ò³ìäs{©¶‘úúÐÀ�ô‘

ô
ù³Ñ¹Ñ¾	•

î,Ÿ

&(·
ù‚°û›°û¹°ûûùû³Ñ¹ÑžÐÀ�ü�F
¤œ
‰‰—ã‰úÐô¸
ô
ü³Ñ¹ÑãçœüÂL
Ä×
ŠŠ—ãŠúÐô÷
ô
ý³Ñ¹Ñã,ð
üÁE
lÖ
‹‹úÐ‹³Ñôä
ô
þ³Ñ¹Ñ$å
¾	ë
ø¶õ
üº,
DÎ
ŒŒúÐŒ—ãô×
ô
ÿ³Ñ¹Ñ$Ø
üã S
„ø 
��úÐ�—ãô‰!
ô
€³Ñ¹Ñ$Ž!
¾	”!
ø¶ž!
¤þ=‘‡f„ã™
�ƒƒe¤õŒ
�„‹+|œæ�…ÔÞÃ�‰ÔÈ�‰ÕDãüÕ�ŠÜTíÉ�‹ÜØ�‹Í„Á]�ŒÁ¯\›‰��Á¯Š��Ó
²Õ�Ž�,Ç¦˜��æ,ÝÎ˜��ÌF5Y�†¦#)é�†É#2
î�†î«	��†œª	×�†�ù4†�‡æUú4‹�‡²Vû4•�‡â>ü4Ä�‡ÀYý4É�‡åYþ4Í�‡òYÿ4Î�‡³Z5Ó�‡ùo6a�†»Ü?5�‡µŽG5™�‡¸ÆG5��‡ºûJ5×�‡¼ÞL5ö�‡½â>5·�‡Ø³Z5¸�‡ÙÔ*î7à�†´°	Ô*
8á�†´°	¶¬W5Ê�‡�cý7ä	�†·�c8å	�†·ˆd8ø	�†¸ˆd#8ù	�†¸“b8Ð	�†¹“b18Ñ	�†¹þf8¥
�†¼´i6Æ
�‡´åj6à
�‡¶ûk6ô
�‡¹ûk6õ
�‡¹ên6©�‡¾ên#6ª�‡¾üÏ;€ƒqtÜ�f,±T¿üÒ&ad>A.1LþÌ�L¬Ü„¼Î„Ò¿üþ/üå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.Á›ËtŸá ®Ë¤² ## 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<_>>()ÁT‹     })Áì–     .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Áü¢RO [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")]);Á<€æ¡d‰™’ð“’“¶Õ–»ê\¡àÑŽ6Òß�ñ’K”•'),¡ÏÊÜ´4´�‘‘‰‰ŠÁ¯Ñ{·Ë…YÚ¹Ñ³Ñ”Š dŠ �‘‘—ãü¡ @™—ð˜—˜¶Õ¦ »êº ãÕ4© Ôê„½ àÑ™šœ�žŸ¡¢£¤¦ACFHü“!)üè &# Construct a new empty VarZeroSliceÁL !àÑ––
™³Ñ¹Ñü’#Kl #››àÑŒ
Œ
ƒe�
¾	Y‘
¿eY’
ÎeY“
‡
Y2fm?Ž~�›³Ñ¹Ñ–®#–
š³Ñ¹Ñ$¶#üÉ&?ü‘%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ž-��àÑ–§-–
ž³Ñ¹Ñ$¨-üñ17üë-1. Obtain an iterator over this slice's elementsÁ¡.Ël©.®£».Ë\Ã.ÃôÓ.Ú£ö.Ëüþ.4Œ¤ü·/0É¤ì/Ëüô/;8 let mut iter_results: Vec<&str> = vec.iter().collect();Áü´0'$ assert_eq!(iter_results[0], "foo");Áüà0'$ assert_eq!(iter_results[1], "bar");ÁüŒ1'$ assert_eq!(iter_results[2], "baz");Áü¸1(% assert_eq!(iter_results[3], "quux");Á<å1æ¡$ø1  àÑ™
™
‡f�
ÌYž
öYŸ
ÇfY€�Š5½Uf ³Ñ¹Ñ–ý1–
Ÿ³Ñ¹Ñ$…2ü7+üÚ2TQ Get one of this slice's elements, returning `None` if the index is out of boundsÁ³3Ël»3®£Í3Ë\Õ3Ãôå3Ú£ˆ4Ëü�44Œ¤üÉ40É¤þ4Ëü†5;”ªüÆ5(% assert_eq!(vec.get(0), Some("foo"));Áüó5(% assert_eq!(vec.get(1), Some("bar"));Áü 6(% assert_eq!(vec.get(2), Some("baz"));ÁüÍ6)& assert_eq!(vec.get(3), Some("quux"));Áüû6! assert_eq!(vec.get(4), None);Á<¡7æ¡´7‘‘àÑø°ú°û°Ðü°ý°�þ°ìH�ËˆXêE>‘³Ñ–¸7–
¡³Ñ¹Ñ$¹7ø¶¿7ü†=4üŒ8$! Get one of this slice's elementsÁµ8Ëd½8âêÎ8ËäÖ8 `index` must be in rangeÁ÷8Ëlÿ8®£‘9Ë\™9Ãô©9Ú£Ì9ËüÔ94Œ¤ü�: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ÁÂ@ËüÊ@<9 The bytes can be passed back to [`Self::parse_bytes()`].Á‹AËü“ADA To take the bytes as a vector, see [`VarZeroVec::into_bytes()`].ÁÜAËläA®£öAË\þAÃôŽBÚ£±BËü¹B,) let strings = vec!["foo", "bar", "baz"];ÁüêB0- let vzv = VarZeroVec::<str>::from(&strings);ÁŸCËü§CFC assert_eq!(vzv, VarZeroVec::parse_bytes(vzv.as_bytes()).unwrap());Á<òCæ¡D™D““àÑ“—ã–¢D–
£³Ñ¹Ñ$£Dü¨F@üÚD:7 Get this [`VarZeroSlice`] as a borrowed [`VarZeroVec`]Á™EËü¡EDA If you wish to repeatedly call methods on this [`VarZeroSlice`],ÁüêE96 it is more efficient to perform this conversion firstÁlµF¥¥àÑààáÔ*åì6
ä>(ùOè¥³Ñ¹Ñ–ÃF–
¤³Ñ¹Ñ$ËF!üÊHEüªG?< Parse a VarZeroSlice from a slice of the appropriate formatÁîGËüöGOL Slices of the right format can be obtained via [`VarZeroSlice::as_bytes()`]Á\ÑH§§—ãê³í³î³Òï³ìð³ñ³“ò³ìäs{©¶‘§àÑÀ�–ÝH–
¦³Ñ¹Ñî,áH üÈIf™©ðª©ª¶ÕÍI»êÐIãÕ4óIÃ³Ñ‘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`].ÁÐKËlØK®£êKË<òKæ¡ôþKÚ£¡LËü©L+( let strings = vec!["a", "b", "f", "g"];ÁüÙL0É¤ŽMËü–M.+ assert_eq!(vec.binary_search("f"), Ok(2));ÁüÉM/, assert_eq!(vec.binary_search("e"), Err(2));Á<ýMæ¡‰NËü‘N^[ [`binary_search`]: https://doc.rust-lang.org/std/primitive.slice.html#method.binary_searchÁl‰O”•”àÑ•³Ñ�Ç¨—O¨
«³Ñ¹Ñ$˜OŸ�žOüú[üøOZW Binary searches a `VarZeroVec<T>` for the given element within a certain sorted range.Á×PËüßPZW 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.ÁÔRËlÜR®£îRË<öRæ¡ô‚SÚ£ü¥S:7 let strings = vec!["a", "b", "f", "g", "m", "n", "q"];ÁüäS0É¤™TËü¡TLI // Same behavior as binary_search when the range covers the whole slice:ÁüòTC@ assert_eq!(vec.binary_search_in_range("g", 0..7), Some(Ok(3)));ÁüºUDA assert_eq!(vec.binary_search_in_range("h", 0..7), Some(Err(4)));ÁƒVËü‹V*' // Will not look outside of the range:ÁüºVDA assert_eq!(vec.binary_search_in_range("g", 0..1), Some(Err(1)));ÁüƒWDA assert_eq!(vec.binary_search_in_range("g", 6..7), Some(Err(0)));ÁÌWËüÔW>; // Will return indices relative to the start of the range:Áü—XC@ assert_eq!(vec.binary_search_in_range("g", 1..6), Some(Ok(2)));ÁüßXDA assert_eq!(vec.binary_search_in_range("h", 1..6), Some(Err(3)));Á¨YËü°Y85 // Will return `None` if the range is out of bounds:ÁüíY@= assert_eq!(vec.binary_search_in_range("x", 100..200), None);Áü²Z>; assert_eq!(vec.binary_search_in_range("x", 0..200), None);Á<õZæ¡�[Ëü‰[^çÆ´�\–—–àÑ—³Ñ†¹ëÉ¨¡\¨
¬³Ñ¹Ñ$¢\Ÿ�°\ïÉ,¿\üÃ]Z™®ð¯¯®¶ÕÈ]»êË]ãÕ4î]Ôê„Œ^àÑ°²&(+-ü c]ü¤^_\ Binary searches a sorted `VarZeroVec<T>` for the given predicate. For more information, seeÁüˆ_74 the standard library function [`binary_search_by`].ÁÄ_ËlÌ_®£Þ_Ë<æ_æ¡ôò_Ú£ü•`+•ÅüÅ`0É¤ú`Ëü‚aDA assert_eq!(vec.binary_search_by(|probe| probe.cmp("f")), Ok(2));ÁüËaEB assert_eq!(vec.binary_search_by(|probe| probe.cmp("e")), Err(2));Á<•bæ¡¡bËü©bda [`binary_search_by`]: https://doc.rust-lang.org/std/primitive.slice.html#method.binary_search_byÁ„§c˜˜àÑ˜ �Ç˜ ±±¸c©â¿ÛÔÊc™– ¿Û™³Ñ¬Ïc™¿Û�Ü› ñþDÜc
°³Ñ¹Ñ¿Û$¹cÈÍL¿cfhü˜s¢üÄd\Y Binary searches a `VarZeroVec<T>` for the given predicate within a certain sorted range.Á¥eËüeZµÉüŒfG˜ÊØfËüàf=óÊ¢gËlªg®£¼gË<Ägæ¡ôÐgÚ£üóg:óËü²h0É¤çhËüïhLÎÌ|Ài assert_eq!(ÁüÔi<9     vec.binary_search_in_range_by(|v| v.cmp("g"), 0..7),Áœ•j     S
×ßµ�c[{ä	×ß·�cs{å	×ß·ˆdi{ø	×ß¸ˆd�{ù	×ß¸“bw{Ð	×ß¹“b�{Ñ	×ß¹‡f…{™
×ßºþfz{¥
×ß¼´i{yÆ
×Ø´åj|yà
×Ø¶ûk}yô
×Ø¹ûk•yõ
×Ø¹ên�y©×Ø¾ên™yª×Ø¾TÏüã&ÿÜßÌÏ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).ÁðËlô®£‚Ë\†Ãä’Ç—¯Ëü³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),Á4�Ä§ˆË¼ŒÒ§ü¤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),Á4ÎÄ§ÕË¼ÙÒ§üñ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.Á¢*Ëü¦*vs See [the design doc](https://github.com/unicode-org/icu4x/blob/main/utils/zerovec/design_doc.
ä>(ùOèáåæêëº+ììµáùý�¨ýÎƒÏ…Ó•ÜË¹®…Óàà
á¨ýÎƒÏÏ+ÙÛÞÞ+ÏÊüë+$àà¹®ü“,;|£,¨ç™èðééçèâ¨·,ó¨\Â,€®R�®Y¹®µáùý�êëëì’Ô¹®³,KMPÂ,ÏÊvÝ{Ýææ
ë¨ýÎƒÏ¡Ý¤Ý’Ô¹®ææÎ±ææ’Ôüº-5¨î™ïðððïîâ¨Ã-ó¨Î-…Óñßñ¿-!#&(¼ö-,ù-ªª…Ó…Óíÿ-í
ñ¨ýÎƒÏ$€.üÕ/j8«™óðô«óôâ¨Ú/ó¨î/Ï«4Ý/ç®„ñ/à`ýÎT´0ÊÓõá`õ;=@BüÆ08É0¬®¬ÊÓÁ`Á`œÃ`èÁ]Ä`áÁ]Ê\É:•®˜ùòÍ0ò
õ8ýÎƒÏ$Î0þÔ0üŒ3L¨÷™øðù÷ùøâ¨•3ó¨ 3…Óúüú‘3!#&(üß3.$â3’Ô…Óöö
ú¨ýÎƒÏî,ç3ü�7N8¯™üðýýü¯â¨¢7ó¨¶7Ï«4¥7ç®„¹7ÊÓþÅþ+-02¤€8<ƒ8ÊÓûû
þ8ýÎƒÏü´8L8°™€ð��€°â¨¹8ó¨Í8Ï«4¼8ç®„Ð8ÊÓ‚ƒíîƒ2479\‡94Œ9ÿÿ˜Ôü9&,°9±±ÊÓ±˜Ôÿ¶9ÿ
ƒ8ýÎƒÏ$·9ü÷9F¨…™†ð‡†‡…â¨€:ó¨”:Ï«4ƒ:ç®„—:…Óˆ‰Š‹Œ�ü98:=?Ô»<üÄ:)& Creates a new, empty `VarZeroVec<T>`.Áò:Ëtú:á �;Ë<•;æ¡ä¡;Ç—Â;ËüÊ;1. let vzv: VarZeroVec<str> = VarZeroVec::new();Áä€< assert!(vzv.is_empty());Á<¡<æ¡È<…Ó„„
ˆ¨ýÎƒÏüµ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");Áüà@ assert_eq!(&vec[2], "baz");Áü„A  assert_eq!(&vec[3], "quux");Á<©Aæ¡\¼Aúéê³í³î³Òï³ìð³ñ³“ò³ìäs{©¶‘…ÓÀ�„„
‰¨ýÎƒÏî,ÈAü¯DAüùBHE Uses a `&[u8]` buffer as a `VarZeroVec<T>` without any verification.ÁÆCËdÎCâêßCËüçCC¹¡¤ÃDúé…Ó„„
Š¨ýÎƒÏã…£ü½V-ü†V2/ Obtain this `VarZeroVec` as a [`VarZeroSlice`]ÁDÄV²²…Ó²˜Ô„ÍV„
‹¨ýÎƒÏ$ÎVôúaü±`GD Return whether the [`VarZeroVec`] is operating on owned or borrowedÁüý`IF data. [`VarZeroVec::into_owned()`] and [`VarZeroVec::make_mut()`] canÁüËa*' be used to force it into an owned typeÁD�b³³…Ó„Šb„
Œ¨ýÎƒÏ$‹büäcD¡ÓcÖcÝc8°4×ctÑclëcŽŽ…ÓŒ
Œ
ƒe�
¾	Y‘
¿eY’
ÎeY“
‡
Y2fm?Ž~�ŽýÎƒÏ„ùc„
�¨ýÎƒÏ$�d#%üŒmš¨�¤‘™’ð““‘’�ªâÕ™m©â³ÕœmÓÕ4åmžÕÕLƒna³Õ„•n÷Ô” ”‘m•mce_aü»n2¾n´µ´÷Ôµ¹Õ�Án�
”¨¤Õ³Õ$Ânî,Ènü–sr¨–™—ð˜˜–—â¨Ÿsó¨¢sÏ«4Îs£ýÎìsç®„÷s…Ó›s68;=üŽt“8¶8·™šÓ!›ðœ·œ¶š›’Ì“t©âÎÖ–t©âÂÖ™t´Ì4ÕtÄÌLítñÎÖÕDÿtaÂÖ„�u‰Ö� �hjdf`bü¶u"¹u¸¹º¸‰Ö¹ºÍÖ™¼u™
�88ÕÎÖÂÖ$½uî,Ãuƒv�‚°ž›°ž¹°žž�žÕÎÖÂÖÎÖÕü�v¢8»™ Ó!¡ð¢Í£¢ ¡£»â¨¢v©âš×¥v£Ì¨vÍt«vÏ«4óvžýÎýÎL‹wñš×ýÎD�wØÌ„®wÜÖ¥ ¥rtnpsur±vüÔw$×w¼½¼ÜÖ½™×ŸÚwŸ
¥8ýÎš×³ÕÍ$Ûwî,áw£x¥‚°§›°§¹°§§¥§ýÎš×³ÕÍš×šÉü½xb¨©™ªð««ª©â¨Æxó¨çxÏ«4ÉxÉýÎýÎTÛxç®„êx…Ó¬Ë¬ÂxEGJLü¦y7\©y¾¿¾…Ó¿…Óþ¨µy¨
¬¨ýÎƒÏ$¶yî,¼yü—zT¨®™¯ð°°®¯â¨ zó¨ºzÏ«4£z‚Æµzç®„½z…Ó±Ä±œz9;>@üòz'õzÀÁÀ…ÓÁ…Óñþùz
±¨ýÎƒÏ$úzî,€{üƒ!©©ÿ¨©ü¾ Ü¨üéJÒ¨Õ¨´¨·¨–¨™¨x¨{¨l¨o¨äùe¨\¼M<ÀM¾ª»æL¸ÂžåhlÒ½
ŸÔæÃ½¢ÔÈ½¢ÕDëüÕ½£ÜTõÉ½¤ÜØ½¤ÍŒÁ]½¥Á¯\Û‰½¦Á¯Š½¦NonZeroUsizeÁd÷º’½§†,”ì½¨Î<ª�½©�Ñ¨†½ æUÒ¨‹½ ²VÓ¨•½ â>Ô¨Ä½ ÀYÕ¨É½ åYÖ¨Í½ òY×¨Î½ ³ZØ¨Ó½ Ü?Ù¨½ µŽGÚ¨™½ ¸ÆGÛ¨�½ ºûJÜ¨×½ ¼ÞLÝ¨ö½ ½â>Þ¨·½ Ø³ZÞ¨¸½ Ù¶¬Þ¨Ê½ ´iÞ¨Æ
½ ´åjß¨à
½ ¶ûkà¨ô
½ ¹ûkø¨õ
½ ¹ênä¨©½ ¾ênü¨ª½ ¾L�,¡½ÂÃ½
¾
ÕDèüÕ¾Àæ,�Î˜¾Áî>¾¾¿Ž<Œª¾¿Ž8”„%»¾¿�B«†¾¿ æUG«‹¾¿ ²VL«•¾¿ â>Q«Ä¾¿ ÀYV«É¾¿ åY[«Í¾¿ òY`«Î¾¿ ³Ze«Ó¾¿ Ô&Ã¾¿¢Ô>È¾¿¢ÜÉ¾¿¤Ü0Ø¾¿¤Í Á]¾¿¥Á¯#‰¾¿¦Á¯<Š¾¿¦÷Ü º’¾¿§†#ì¾¿¨Î&�¾¿©Ü?b¬¾¿ µŽGg¬™¾¿ ¸ÆGl¬�¾¿ ºûJq¬×¾¿ ¼ÞLv¬ö¾¿ ½â>{¬·¾¿ Ø³Z¬¸¾¿ Ù¶¬ƒ¬Ê¾¿ ´i‡¬Æ
¾¿ ´åjŒ¬à
¾¿ ¶ûk‘¬ô
¾¿ ¹ûk¬õ
¾¿ ¹ên�¬©¾¿ ¾ên¹¬ª¾¿ ¾,ÏœÝ±„ö¢pùü‰=: 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.ÁÿËtƒá ’Ëü–'$ 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,Ád—		     ]));Á¤	Ëü¨	'$ assert_eq!(DATA.get(1), Some(281));Á<Ð	æ¡Lø	™ÄÄ©â³Ñ‚
É³Ñ,…
©ØÈE(�mÇÃÅÀÉ©Øûh¾ÀÉ©ØÂÂ
Ã³Ñz|DŒ
¾ÂÂÀÉü˜
(™ÇÇ½ð�
Îð,º
©ØÈÉÊËÌÍÎÏÐ+-üç
)ÜÇ
 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¾
ÂÂ©ØªªŽ¨½®¿½¯°7½Ê˜!ÚÆdG
Â³ÑÆÉ
Æ
É³Ñ$Ê
ü•;ü–PM Attempt to construct a `&ZeroSlice<T>` from a byte slice, returning an errorÁüë%" if it's not a valid byte sequenceÁ\œÃÃ—ãê³í³î³Òï³ìð³ñ³“ò³ìäs{©¶‘Ã©ØÀ�Æ¯Æ
Ê³Ñã,¨üÔ?ü¤EB Uses a `&[u8]` buffer as a `ZeroVec<T>` without any verification.ÁîËdöâê‡Ëü�@= `bytes` need to be an output from [`ZeroSlice::as_bytes()`].Á¤èÄÄ—ãÄ©ØÆ„Æ
Ë³ÑãÂ¨ü’6üŸ52 Construct a `&ZeroSlice<T>` from a slice of ULEs.ÁÙËüáTQ This function can be used for constructing ZeroVecs 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.ÁŒËl”®£¦Ë<®æ¡Ìº 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());Á<¬ æ¡DÍ ÆÆ©ØÆ—ãÆÖ Æ
Í³Ñ$× üå!-ü§!+( 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(),Áüæ%B?     zerovec.len() * std::mem::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£+ÉÉ©ØÆ¬+Æ
Ð³Ñ$+üí+(™ÒÒ½ðò+Îð,�,©ØÓÔÙÚÛÝßàáã.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¿ÿü·3ç„üÛ39�…Ì™4 let array: [u16; 4] =Áü·4DA     zerovec.get_as_array().expect("should be 4 items in array");Á€5Ëôˆ5 assert_eq!(array[2], 421);Á<«5æ¡d¾5ËË©Øø°ú°û°Ðü°ý°�þ°ìH�ËˆXêE>óðÑÍÕÕÛ5ÑÍtË5
Ô³ÑÍ$Ü5Ñ5Þ6Ô‚°Ø›°Ø¹°ØØÔØ³ÑÍþÈ³Ñüñ;Hü„7SP Gets a subslice of el
½
¾
åhÁ
ì¾žóP¾7Šyôâ³ÑÑÊ\Ñ
á³Ñ$Ò\üÞ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ÿÞüƒb<9 assert_eq!(EXPECTED_VALUE, DATA.split_first().unwrap());Á<Äbæ¡\åbÒÒ©Øø°ú°û°Ðü°ý°�þ°ìH�ËˆXêE>³ÑÇ¼ÑñbÑ
ã³Ñ$òbüåf4¨å™æåæ©âýÎîfÉýÎ,ñfÆ×çèéßKàKäKèéêf;=L g$¥gääýÎü³g$¶gÓÓÆ×ø°ú°û°Ðü°ý°�þ°ìH�ËˆXêE>ýÎä»gä
è¨ýÎ$Àgü–h-L™hÔÔÆ×ºÂä£hä
é¨ýÎ$¤hüêh=¨ë™ìëìñ½óh‚¾,öhÆ×íªKíïh!#´®i±iÕÕÆ×êµiê
í¨ýÎ$¶iüåi?¨ï™ððïñ½îi‚¾,ñiÆ×ñóJñêi!#ü«j$L®jÖÖÆ×‘¿î¸jî
ñ¨ýÎ$½jü–k.™óó½ð›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æ¡ÌŠmºþ¨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ô‚°õ›°õ¹°õõôõ³ÑþÈñþ³Ñüˆr(™÷÷½ð�rÎð,ª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ÙÙ©Ø°4�Çö°4ùù•xö©âþÍÌ³x– þÍ³Ñ¤¸xþÍÇÎ› ñþDÄx
ø³ÑþÍ$–xÈÍL¨xNP<¨yø‚°ú›°ú¹°úúøú³ÑþÍŸÉþÍüÁ7™üü½ðÍÎð,Ð·é<Ø©ØýþÔÖýþ.0ü�€7t�€ÚÚ—ãºêû¦€û
ý³Ñã,Ÿ€ü†�5¤��ÛÛ—ãÛ©Øû¬�û
þ³Ñã,¥�ü�‚/™€€½ð”‚Îð,´‚ãò¼‚©ØüÃ‚P™‚‚½ðÈ‚Îð,�ƒØðL‰ƒ©Øƒ ƒ&(ü¨ƒ*«ƒÜÝÜ©ØÝ©Ø�®ƒ�
ƒ³Ñ$¯ƒî,µƒü�„G™……½ð•„Îð,Å„ØðLÍ„©Ø† †&(üì„!ï„ÞßÞ©ØßƒÙ„ò„„
†³Ñ$ó„î,ù„üÇ…V¨ˆ™‰ˆ‰ñ½Ð…‚¾,‹†¶ÔL“†�ÙŠ ŠÌ…-/ü²†,µ†àáà�ÙáÄÙ‡¸†‡
Š¨ýÎ$¹†î,¿†üŽ‡V¨Œ
Ëü¨
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),Á4¾Ä§¼ÅÒ§üÝ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ÁTý value.ÁˆËüŒyv Benchmarks can be found in the project repository, with some results found in the [crate-level documentation](crate).Á†ËüŠv“«ùH¨«™¬«¬ñ½˜‚¾,¨ÔÚ¨üü ÄÙÊ˜!ÚÆdG
®¯”?Aüµ"4µ½ªª±ääÚ<Ú½ªªßên<ü½ªª‰‰ŠÁ¯Ñ{·Ë…YÚ¨ÔÚü�K¨±™²±²ñ½ ‚¾,£¨âÔÚ$Ð„ÔÚ$×ÄÙœ79ü™D¨´™µµ´ñ½©‚¾,¬Ì÷$ÙÄÙ¥ üâ+¨·™¸·¸ñ½ë‚¾,îÄÙ¹ºíîºç(*\” 4™ ¶¶�ÙüÂ  ,Å îîÄÙîÄÙí¶Ë ¶
º¨ýÎ$Ì äý$ K½¨8¼¼©âæã—%ÑßK'L)óî1#½Œê&ê&½»»æÝìí'¨8¿¿àúò'ÑßÀÂÄüò(2”ü(½ïïÑß¨“Þ¾¨ÁÁ“)¾
Àæã¨$”)�)ü�**DŠ*½ÃÃÑßÃ“Þ¾“*¾
Âæã$›*ü‹1"DŽ1½ððÑß¾—1¾
Äæã$œ1maxÁ¢1ü´9+¨Æ™ÇÆÇñ½½9‚¾,À9ÄÙÈßÈ¹9!#¼æ9,é9ññÄÙÄÙÅï9Å
È¨ýÎ$ð9ü—=9¨Ê™ËÊËñ½ =‚¾,£=ÄÙÌóÌœ=!#ü×=!4Ú=òòÄÙò�ÙÉá=É
Ì¨ýÎ$â=üœ>F8ó™ÎóÎñ½¡>‚¾,Ï>ì´T×>¸ÛÏá`Ï#%üé>4ì>ôõöô¸ÛõÁ`Á`œÃ`èÁ]Ä`áÁ]Ê\É:•ö˜ùÍð>Í
Ï8ýÎ$ñ>þ÷>ü¯A18÷™ÑÑ÷ñ½´A‚¾,ÖAòÎÞA¸ÛüåA\¨Ó¤Ô™ÕÔÓÕ©âÕòAÉÕ,¯BÄÌL·B˜ÜÖ ÖêAîA79üÖB,ÙBøùø˜ÜùçÜÒÜBÒ
Ö¨¤Õ$ÝBî,ãBüêCJ8ú8û™ØúûØè„	ïCù„	,¢DÄÌLªD½ÝÙ Ù#%üÉD"ÌDüýþü½Ýýþ�Þ×ÏD×
Ù88Õ$ÐDî,ÖDü¥E\8ÿ™ÛÍÜÜÛÿñ½ªEÍtE‚¾,ïE¶ÔL÷E¸ÛÞ Þ130³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
¨ü²üÙ¿.¨ƒ™„ƒ„ñ½â¿‚¾,�ÀÄÙÞ¿üÌÊ.¨†™‡‡†ñ½ÕÊÍýÎ,ôÊÄÙˆÑÊ$&üªÐ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±Ð¨øàø°ú°û°Ðü°ý°�þ°ìH�ËˆXêE>ÄÙ……
ˆ¨ýÎî,ÀÐ\‹Ñˆ‚°‰›°‰¹°‰‰ˆ‰ýÎ¼á©âü¶Ù.¨‹™ŒŒ‹ñ½¿Ù‚¾,ÞÙÄÙ�Ž»Ù!¼ô„ü�„RO 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.,ÁüÞªEB   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]);Á<¬²æ¡&|´²PÛ²°´á²â²*ä²ç²”³,ñ²8,ò²'÷²8æLù²'‚³8²&L„³�³Ž³%•³›³Ì³,œ³8alignedÁ<�³&¤³8”¥³%§³,©³8ª<ª³&±³8ï$²³%¶³¸³Ë³,¹³º³Â³,»³8Ÿ�¼³&½³8ï$¾³$Ã³Ä³,Æ³Ç³É³$È³-Ê³*Î³Ñ³´,Û³8,Ü³'á³8æLã³'ì³î³,ï³8—É	<ð³÷³'ø³8û0tú³ˆ´§´8,‰´�´¦´‘´’´¤´,“´”´¡´,•´8ª<–´�´ ´,ž´8Ÿ�Ÿ´$¢´
£´%®´¤‚¹ü³´c` 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µ¶á Ä¶
´Ü?ð&µåj1&à
¶ŽGý&™¸ûk>&ô
¹ûkP&õ
¹ÆG'�ºûJ'×¼ÞL'ö½ênl&©¾ên~&ª¾÷ ã#‘ÀÍ¥Á]‘ÁÓ
ªÕ‘Âî,¯ªc‘Ãâ>‰'·Ø³Zƒ'¸ÙL,±‘Æ
Ç
›Cœ¸æ’”ÕDÜüÕ’•¤<ù�’–‚>P’’“Î4Ø¥’“�C4äå’“¶C,ðç’“ãF,û’’“ä4†Ð’“çN,’™’“ôS4�é’“�³)†’“æUµ)‹’“²V·)•’“â>¹)Ä’“ÀY»)É’“åY½)Í’“òY¿)Î’“³ZÁ)Ó’“Ü?Ã)’“µŽGÅ)™’“¸ÆGÇ)�’“ºûJÉ)×’“¼ÞLË)ö’“½÷˜ã#’“ÀÍ›Á]’“ÁÓ
žÕ’“Âî¡ªc’“Ãâ>-*·’“Ø³Z.*¸’“Ù¶¬/*Ê’“åj*à
’“¶ûk*ô
’“¹ûk4*õ
’“¹ên!*©’“¾ên:*ª’“¾,£Ô±=œÑ-´ê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€üÞ——¢üŠ\»äÖü€
JG Converts this [`CharULE`] to a [`char`]. This is equivalent to callingÁìÏ
 [`AsULE::from_unaligned`]Áñ
Ëüù
J·å	<ÝüÞ——
™$åÜÞüÞ›Å›üŽ7t‘��—ãºêš§š
›ã, ¡›‚°œ›°œ¹°œœ›œèŸèŸéŸCharTryFromErrorÁêŸì�/%ÎlK°=�À�œäžŸ ÊËÌ ŸDþƒ��üÞü¥"d¨Ê��
Ÿ$µü‡/tŠˆì	��
 	unalignedÁL™ÜÞüÞ¢Ë¢ü€7\ƒŽ�ŽüÞ�üÞþ¡�¡
¢$�î,–¤áüÞ¤Ä¤üü'ÿ�‘�üÞ‘üÞñþ£ƒ£
¤$„î,ŠTÔþ‘ù„õa¥§»Ý%d“‘¥©¯	Ô*T¡à¥ª°	Ô*á¥ª°	æLÂ¥«²	žŽ<¸ª¥¬³	‚>	’¥¦Î¶¥¥¦�Cµå¥¦¶C´ç¥¦ãF³’¥¦ä²Ð¥¦çN±™¥¦ôS°é¥¦�b2†¥¦æUd2‹¥¦²Vf2•¥¦â>h2Ä¥¦ÀYj2É¥¦åYl2Í¥¦òYn2Î¥¦³Zp2Ó¥¦ŽG[2™¥¦¸ÆG]2�¥¦ºûJ_2×¥¦¼ÞLa2ö¥¦½÷.ã#¥¦ÀÍ1Á]¥¦ÁÓ
4Õ¥¦Âî7ªc¥¦Ãâ>Ã2·¥¦Ø³ZÄ2¸¥¦Ù¶¬Å2Ê¥¦´iÆ2Æ
¥¦´åjÈ2à
¥¦¶ûkÊ2ô
¥¦¹ûkã2õ
¥¦¹ênÐ2©¥¦¾êné2ª¥¦¾TÏüâ#�ü‹5‚lo@C),ü´3üÅ[X Allows types to be encoded as VarULEs. This is highly useful for implementing VarULE onÁü¡TQ custom DSTs where the type cannot be obtained as a reference to some other type.ÁöËüúkh [`Self::encode_var_ule_as_slices()`] should be implemented by providing an encoded slice for each fieldÁüæ^[ of the VarULE type to the callback, in order. For an implementation to be safe, the slicesÁüÅTQ to the callback must, when concatenated, be a valid instance of the VarULE type.ÁšËüžJG 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()`]Áüë	jg and [`Self::encode_var_ule_len()`]. If you override the default implementations it is totally valid toÁüÖ
ol replace [`Self::encode_var_ule_as_slices()`]'s body with `unreachable!()`. This can be done for cases whereÁüÆjg 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,Áü’
da convert it to ULE, call [`ULE::slice_as_bytes()`] on them, and pass the slices to `cb` in order.Áü÷
if A trailing [`ZeroVec`](crate::ZeroVec) or [`VarZeroVec`](crate::VarZeroVec) can have their underlyingÁüá'$ byte representation passed through.Á‰Ëü�jg In case the compiler is not optimizing [`Self::encode_var_ule_len()`], it can be overridden. A typicalÁüøtq 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Á«Ëü¯OL This trait maps a struct to its bytes representation ("serialization"), andÁüÿ\Y [`ZeroFrom`](zerofrom::ZeroFrom) performs the opposite operation, taking those bytes andÁüÜ41 creating a struct from them ("deserialization").Á‘Ëd•âê¢Ëü¦FC The safety invariants of [`Self::encode_var_ule_as_slices()`] are:Áüí#  - It must call `cb` (only once)Áü‘gd - The slices passed to `cb`, if concatenated, should be a valid instance of the `T` [`VarULE`] typeÁüùYV   (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Á�Ëü“gd 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:Áü×@= - It must return the length of the corresponding VarULE typeÁ˜ËüœB? The safety invariants of [`Self::encode_var_ule_write()`] are:ÁüßTQ - The slice written to `dst` must be a valid instance of the `T` [`VarULE`] typeÁtÅ™®®÷™ü´¤	â¨ÔÏ«4×÷™*÷™0¯²µ¯²µ²¯µDFü’KüîJG Calls `cb` with a piecewise list of byte slices that when concatenatedÁü½DA produce the memory pattern of the corresponding instance of `T`.Á†ËüŽTQ Do not call this function directly; instead use the other two. Some implementorsÁüç&# may define this function to panic.ÁÄ•’’À•þ‚ƒƒš°¢±°±±¶ƒ®ÇƒÔ¼“”™ þ‚“
”—ã¬Á“”þ‚í“
› ƒƒÕ
¯À•ýÎƒƒþ‚$²cbÁ¸ˆŠ��ü%üãEB Return the length, in bytes, of the corresponding [`VarULE`] typeÁ”°••À•Ã
²À•ýÎ$ÄDû²‚°³›°³¹°³³²³À•ýÎ
—ã–²‚°´›°´¹°´´²´À•ýÎíü½ 2üµMJ 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Õ÷¡
ò¡
$¯.Ë“
µ.–˜’”üÒ:U8¤™ÇÇ¤ñ½Þ:‚¾,—;ýÎ<Ÿ;óàÈËÌ¯²µËÈÌ<>ü®;IÄ±;¥¥óàþ‚ƒƒÆšÉ¢ÊÉÊÍ;Æ¶ƒÊ;ÇƒÔ×;¦§™ þ‚¦
§—ã¬Ü;¦§þ‚ö¥
› ƒƒð;
È8ýÎƒƒþ‚$Î;Ô;†ˆ‹�üâ<%”å<¨¨óàÆø<Æ
Ë8ýÎ$ù<üÉ=.¤Ì=©ª©óàª—ãÆá=Æ
Ì8ýÎ$â=·…è=üàD\8«™Î«Îñ½ìD‚¾,¬E§¤
<´E¸ÛÏÒÓ¯²µÒÏÓ9;üÃEIÄÆE¬¬¸Ûþ‚ƒƒÍšÐ¢ÑÐÑâEÍ¶ƒßEÇƒÔìE®™ þ‚
®—ã¬ñE®þ‚Òª
› ƒƒ…F
Ï8ýÎƒƒþ‚$ãEéE†ˆ‹�ü÷F%”úF¯¯¸ÛÍ�GÍ
Ò8ýÎ$ŽGüÈG.¤ËG°±°¸Û±—ãÍàGÍ
Ó8ýÎ$áG·…çGüìH”8²™Õ—BÖð×Ö²Õ×â¨øH©âžáûH£ÌþHÏ«4½IžáýÎŒÕIØÌ„ïI˜áØÛÜ¯²µÜÛØfhbdgiü‡JIÄŠJ³³˜á¢šÔšÙ¢ÚÚÙ¦JÔ©â¼¯
£J©â·¯
Ô°J´µ™ ·¯
´
µ—ã¬µJ´µ·¯
¬°
› ¼¯
ÉJ
Ø8ýÎžá³Õ¼¯
·¯
$§JJ—™“•ü€L%”ƒL¶¶˜áÔ–LÔ
Û8ýÎžá³Õ$—Lü–M.¤™M·¸·˜á¸—ãÔ®MÔ
Ü8ýÎžá³Õ$¯M·…µMüÀS„8¹™Þðß¹Þßâ¨ÌSó¨ÏSÏ«4›Tç®„³TÊÓàãä¯²µãàäACFHüËTIÄÎTººÊÓò¡
÷¡
Ýšá¢âáâêTÝ°¢
çTÁ¢
ÔôT»¼™ ò¡
»
¼—ã¬ùT»¼ò¡
Êµ
› ÷¡
�U
à8ýÎƒÏ÷¡
ò¡
$ëTñTŠŒ�‘üÿU%”‚V½½ÊÓÝ•VÝ
ã8ýÎƒÏ$–VüÞV.¤áV¾¿¾ÊÓ¿—ãÝöVÝ
ä8ýÎƒÏ$÷V·…ýVTàŠ,‘ü‹ üË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.Á&|ûr¬”
²ê,³8—É	<´&»8”¼$¾,À8çë	LÁ&Ê8”Ë$Í,Ï8><Ð&×8ï$Ø$Ü,Þ8singleÁ4ß&å8ª$æ*ìïƒ	+ùúë8¡ûÿ8ï4�	‡ˆê
7Convert an array of `Á¼‰$ 8µL¢	«¬µ,8—É	<®$¶7` to an array of `Á¤¸$Ì8µLÎ	×Øã,Ù8çë	LÚ$ä7`.Á$æ8õ8,ù8ÿ8·jT‚Œ8,�8Í“&”8‰,–›œ¯8€€�& ¢®,£8—É	<¤%«8Í(±´¼8$µ%¹8Í»¾ý8Ì8Ð8Û
4ÔÛÝé,Þ8><ß%æ8Íè%ê8ø8ü8»€‚7ì„%…+ÑÒó8ä4ÓÙò8Æ4Ú'à8indexing_slicingÁ„â8%,�8»‡‰8Í‹�à8Û
4Ÿ¥§8»¦©,«8Ä»
4¬²¹8€€³¶¸8»·%º8»ÌÎ7íÑ%Ò8Û
4î%„	Š	´	,‹	8—É	<Œ	&“	8””	$–	,˜	8çë	L™	&¢	8”£	$¥	,§	8><¨	&¯	8ï$°	*¶	¹	‘
8›CœÃ		Ö	×	Š
,Ø	8—É	<Ù	$à	,â	8çë	Lã	$ì	,î	8><ï	$ö	8$ø	'ü	8¨>dþ	%‹
%’
Lì¿3‘ƒ„à
á
Øg´ü
çéù„¥açêÃ	»ÍÂÁ]çìÓ
ÇÕçí‚>¸4’çèÎi4¥çè�Ch4åçè¶Cg4ççèãFf4’çèäe4ÐçèçNd4™çèôSc4éçè�ôE†çèæUF‹çè²VF•çèâ>-FÄçèÀY@FÉçèåYSFÍçèòYfFÎçè³ZyFÓçèÜ?ŒFçèµŽG£F™çè¸ÆGºF�çèºûJÑF×çè¼ÞLèFöçè½÷ú6ã#çèÀîÓ6ªcçèÃâ>ÿF·çèØ³ZG¸çèÙ¶¬2GÊçè´iFGÆ
çè´ûktGô
çè¹ûktGõ
çè¹ên¢G©çè¾ên¢Gªçè¾,ÏüÝ5!ì˜„»þïòüLæCïñCððïæC„²©â´â4Äa´â„Ìýáñóöùûýþ=¸46ü”	>ü€QN Compute the amount of bytes needed to support elements with lengths `lengths`Á¼›	æCîî
ñæC´âlengthsÁ<³	ü¤…üËTQ Construct a partially initialized MultiFieldsULE backed by a mutable byte bufferÁü«&ôËÏ
ô—ãôýáîÒî
óæC´â÷Î
<ßµÕ4þ*,üîŽüÕhe 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üÀÁÀýáÁÎÖî™÷Ó!øø÷Åî’Ì‰ªâÎÖ�´Ì4ŒÎÖÕŒ 
öæC´âÕÎÖ$Êø¶Ø˜,ì`b\^üó]ü×EB Validate field at `index` to see if it is a valid `T` VarULE typeÁ¡Ëd©âêºËôÂ - `index` must be in rangeÁt�ÂÂýáºêî™úú¤î’Ì�´Ì4“
ùæC´âÕ$¥ö,«.0üðFü¡-* Get field at `index` as a value of type TÁÓËdÛâêìËôôíÕ
ü—FC - Element at `index` must have been created with the VarULE type TÁLþÃÃýáÃÕî™üüœî’Ìˆ´Ì4‹
ûæC´âÕ$�ö,£.0ü²9ü� Construct from a byte sliceÁ±Ëd¹âêüÊUR - byte slice must be a valid VarZeroLengthlessSlice<[u8], Format> with length LENÁ¤ÀÄÄ—ãÄýáîÜî
ýæC´âã,ÕüÁ ü™ #  Get the bytes behind this valueÁDÈ ÅÅýáÅ—ãîÑ î
þæC´â$Ò ü†![æC€ñC��€öÍ
„‹!„Î
4�!•Î
„¥!ýá‚á`‚#‘!#%üè!4ë!ÆÇÈÆýáÇÁ`Á`œÃ`èÁ]Ä`áÁ]Ê\É:•È˜ùÿï!ÿ
‚æC´â$ð!þö!2ýŒÍ$çæâ¸þøaŸþ„„…æâ2ý7çæâƒƒ
„,ß$çƒƒüè$6æâ‡Š‹¯²µ‹Š‡ü¥%IÄ¨%ÉÉæâ¢š†šˆ¢‰‰ˆÄ%†©â²â
Á%©ââ
ÔÎ%ÊË™ â
Ê
Ë—ã¬Ó%ÊËâ
¢ã
› ²â
ç%
‡²â
â
$Å%Ë%†ˆ‚„üÙ&%”Ü&ÌÌæâ†ï&†
Š$ð&ü©'/¤¬'ÍÎÍæâÎ—ã†Á'†
‹$Â'_dstÁ$È'ü¯-^æC�ñCŽ�ŽöÍ
„»-„Î
4Í-•Î
„Õ-ýá�‘ÔÖ‘�.Á-.0ü”07ü”.li Note: MultiFieldsULE is usually used in cases where one should be calling .validate_field() directly forÁü…/:7 each field, rather than using the regular VarULE impl.ÁÄ/ËüÌ/52 This impl exists so that EncodeAsVarULE can work.Át—0ÏÏ—ãºêŒ0Œ
�æC´âî,¦0¡1�‚°�›°�¹°����æC´âÜúüÂ15¤Ì1ÐÐ—ãÐýáŒè1Œ
‘æC´âã,á1L÷ÁE‘™�ô
õ
$Þ	þ’”ÿ’”é<é	˜’•ÀY,ñ	É’—â>ø	Ä’˜â>·’˜ØüÏ"	dÖ	…dä	cœé	TVCEüî$	üÿ^	[ 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`].ÁTø	™Íš™š÷™üî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));Á<Ê	æ¡|Ü	¨8žÍŸŸžàúì	Ì”t„	™æãÍlï	Äæãÿ	ã8ª´¼”Œ0 ¢MORŠ	tí	,í	’��ƒó
Dà	,à	’��æãüín	¨8¤Í¥¤¥àúò	Ì”t�	Ýú
lõ	óú
…	à`æã„‹	ã¦á`¦;=@£	üâD	å	ÑÒÓÑãÒÁ`Á`œÃ`èÁ]Ä`áÁ]Ê\É:•Ó˜ù£é	£
¦æãÍ$ê	þð	üÌB	¨8¨Í©¨©àúÑ	Ì”té	Ýú
lÔ	óú
ä	ãª«¬)+.ï	üÊ"	ü•0	- New `NichedOptionULE<U, N>` from `Option<U>`ÁÑ	¿üã§§
ªæãÍoptÁÕ	ìÿ	ìÝ	 Convert to an `Option<U>`Á†	ã¿ü§§
«æãÍ$Š	üÝ"	ü¹	 Borrows as an `Option<&U>`.Á4ä	ÔÔãø°ú°û°Ðü°ý°�þ°ìH�ËˆXêE>Ôæã§ë	§
¬æãÍ$ì	ü›K	¨8®Í¯®¯àú 	Ì”t¸	Ýú
l£	óú
³	ã "%¾	üëL	¨8±Í²±²àúð	Ì”tˆ	Ýú
ló	óú
ƒ	ã³ß³+-0Ž	¼¾	,Á	ÕÕãã°Ç	°
³æãÍ$È	üï\	¨8µÍ¶µ¶àúô	Ì”t˜	Ýú
l÷	óú
‡	žæãæãL�	ã· ·?ADž	üÒ"	Õ	Ö×Öã×ã´Ø	´
·æãÍ$Ù	î,ß	ü¤N	¨8¹Íº¹ºàú©	Ì”tÆ	Ýú
l¬	óú
¼	£æãÂ	ã025Ì	üŽ&Q	Ä÷	 Safety for ULE traitÁü� V	S 1. NichedOptionULE does not have any padding bytes due to `#[repr(C)]` on a structÁüç "	    containing only ULE fields.ÁüŠ!S	P    NichedOptionULE either contains NICHE_BIT_PATTERN or valid U byte sequences.ÁüÞ!-	*    In both cases the data is initialized.ÁüŒ"c	` 2. NichedOptionULE is aligned to 1 byte due to `#[repr(C, packed)]` on a struct containing onlyÁ”ð"	    ULE fields.Áüƒ#M	J 3. validate_bytes impl returns an error if invalid bytes are encountered.ÁüÑ#B	? 4. validate_bytes impl returns an error there are extra bytes.Áü”$<	9 5. The other ULE methods are left to their default impl.ÁüÑ$b	_ 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).Á¨8¼Í½¼½àúš&	Ì”t²&	Ýú
l�&	óú
&	ã¾Å¾+-0¸&	üæ&C	té&	ØØ—ãºê»ÿ&	»
¾æãÍã,ø&	<â*	¾‚°¿›°¿¹°¿¿¾¿æãÍíºêü—16	¨8ÁÍÂÁÂàúœ1	Ì”tŸ1	´äÃÅÃ ¥1	¤Ô1	<×1	´äÀÀ
ÃæãÍü‡2\	¨8ÅÍÆÅÆàúŒ2	Ì”t–2	Éæã,�2	™æãÊÍlÕ2	´äÇÈÉÊËÌÈÉZ\_œ2	Dê2	ï2	ÄÄ��ÆG ãF’¢úG’8ª´¼”Œ0¸“Íü–3"	d™3	´ä´äÊÄÄ
ÈæãÍ$¦3	ü€4/	tƒ4	ÿ”´äÄÄ
ÉæãÍçë	L’4	üº7;	™ËÍÌËÌ½ð¿7	Ì”tÂ7	êåÍÎÏ°J¯J±JÏ)+.È7	lü7	D�8	ÊÊýæ°JL·8	$¼8	ÊÊ³ÑüË8$	LÎ8	êåêå°JÊÊ
Ï³ÑÍ$Ø8	T‚\‘×Øö÷ÕDèüÕÐÒÁ¯\„‰ÐÓÁ¯ŠÐÓÓ
$¡ÕÐÕêü\§�ÒÐÖ‚>P]’ÐÑÎ]¥ÐÑ�C]åÐÑ¶Cÿ\çÐÑãFþ\’ÐÑäý\ÐÐÑçNü\™ÐÑôSû\éÐÑ�ôE†ÐÑæUF‹ÐÑ²VF•ÐÑâ>-FÄÐÑÀY@FÉÐÑåYSFÍÐÑòYfFÎÐÑ³ZyFÓÐÑÜ?ŒFÐÑµŽG£F™ÐÑ¸ÆGºF�ÐÑº÷`_ã#ÐÑÀÍc_Á]ÐÑÁîQ_ªcÐÑÃâ>ÿF·ÐÑØ³ZG¸ÐÑÙ¶¬2GÊÐÑ´iFGÆ
ÐÑ´åj]Gà
ÐÑ¶ûktGô
ÐÑ¹ûktGõ
ÐÑ¹ên¢G©ÐÑ¾ên¢GªÐÑ¾,ÏœÝ2Ìö"ô•þ›ïòþü¶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));Á<¨æ¡L¼¨8ÙÙàúÆ©æÉZ_Û#ŸåúØÚÛÞý©æþSÐÞý©æ××
Øæãoq$ÉÐ××tÏÐ××ÞýÔá¨8ÝÝàúæþæã$é©æÞß ì¨ü‚! Obtain this as an `Option<T>`Á¯©æ¿üÜÜ
Þæã$³üê	"ü§	>; Construct an `OptionULE<U>` from an equivalent `Option<T>`Áñ	¿ü©æÜÜ
ßæã–ÿ
õ	üµB¨8ááàúº®¤$½·ü
„Ä©æâá`â#%üþD�ÙÚÛÙ©æÚÁ`Á`œÃ`èÁ]Ä`áÁ]Ê\É:•Û˜ùà…à
âæã$†þŒü´(ü¥30    zeroed or valid-T byte sequences to fill it)Á¨8ääàúÀóú
Ã©æåÅåüã7tæÜÜ—ãºêãüã
åæãã,õÐå‚°æ›°æ¹°ææåææãüè"™èè½ðíÎð,ðýæéêëÊËÌëê-/D‘–çç××ØûJÚìÐÛíÐÉZ_Û#ŸåúþÈü³*d¶ýæ˜¬çç
ê³Ñ$Ãü�3t ˜¬ýæçç
ë³Ñî,¯ü‡#¨8ííàúŒ®¤$�©æü¯$¨8ïïàú´®¤$·©æðßð¼Ú,ÝÝÝ©æ©æîãî
ðæã$äü‹4¨8òòàú�®¤$“ç…Lš©æó ó#%üÆ"ÉÞßÞ©æß©æñÌñ
óæã$Íî,Óü˜&¨8õõàú�®¤$ ã‡§©æÅþüÃ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Ã$¨8øøªâæãÐ$Óæã4Ó$üçFé4yÊdî÷ùúû…ÿ—ãüçÅþqÐ…ÿ—ãüçöö
÷æã‡‰tä$Ðöö…ÿ$ô$Ðöö$ú$Ðöö—ãü‚%(¨8ýý©¶‡%º¶4Š%üçþüØ%"ü±%" Obtain this as an `Option<&U>`Á4ß%ààüçø°ú°û°Ðü°ý°�þ°ìH�ËˆXêE>àæãüæ%ü
þæã$ç%üì'P¨8€€©¶ñ'º¶4ô'·ü
„†(üç�á`�#%üÃ(DÆ(áâãáüçâÁ`Á`œÃ`èÁ]Ä`áÁ]Ê\É:•ã˜ùÿÊ(ÿ
�æã$Ë(þÑ(ü×.:¨8ƒƒ©¶ã.º¶4æ.üç„…ÔÖ…„&(ü¦/7t©/ää—ãºê‚¿/‚
„æãî,¸/ü®55¤¸5åå—ãåüç‚Ô5‚
…æãã,Í5ü£7w™‡¨8ˆ‡ˆ½ð¯7ªâªé²7³ÑªéŒð7Óªé4Š8ýæ‰Œ�¯²µ�Œ‰^`Z\ü¡8IÄ¤8ææýæþ‚ƒƒ†šŠ¢‹‹ŠÀ8†¶ƒ½8ÇƒÔÊ8çè™ þ‚ç
è—ã¬Ï8çèþ‚�Á› ƒƒã8
‰³Ñªéƒƒþ‚$Á8Ç8…‡ŠŒüÕ9%”Ø9ééýæ†ë9†
Œ³Ñªé$ì9ü<.¤°<êëêýæë—ã†Å<†
�³Ñªé$Æ<·…Ì<ü°@B¨8��©¶µ@º¶4¸@ç…LÊ@üç� �#%üù@"ü@ìíìüçíüçŽÿ@Ž
�æã$€Aî,†AüÑA4¨8’’©¶ÖAº¶4ÙAã‡ëAüçüŠBD¨8””©¶�Bº¶4’BÉæãæãT¤Büç•Ë•/1üÕB7\ØBîïîüçïüçþ“äB“
•æã$åBî,ëBüËC6¨8——©¶ÐCº¶4ÓCÃæãåCüç˜Ä˜+-üˆD'‹Dðñðüçñüçñþ–�D–
˜æã$�Dî,–DLŽ„t‘©ª›CœÛæ™›æLûÂ™œ²	ž	NonZeroI8ÁL–í’™ž	NonZeroU8ÁL¡»�™Ÿ‚>Ïu’™šÎ€u¥™š�Cuå™š¶C~uç™šãF}u’™šä|uÐ™šçN{u™™šôSzué™š�ôE†™šæUF‹™š²VF•™šâ>-FÄ™šÀY@FÉ™šåYSFÍ™šòYfFÎ™š³ZyFÓ™šÜ?ŒF™šµŽG£F™™š¸ÆGºF�™šºûJÑF×™š¼ÞLèFö™š½÷xã#™šÀÍxÁ]™šÁÓ
xÕ™šÂîxªc™šÃâ>ÿF·™šØ³ZG¸™šÙ¶¬2GÊ™š´iFGÆ
™š´åj]Gà
™š¶ûktGô
™š¹ûktGõ
™š¹,ÆÔÔL„ô<üŠ!!üÁ#Í¡¡ÍtÆëé¢£ÌüùD€òòëéò—ã ‰ 
¢Í$ŠüÄ@ÄËóó—ãó
ëé ë 
£Íã,äüÅ
2Í¥¥“ÐtÑ
ëé¦Å¦×
üŒ7t�ôô—ãºê¤¥¤
¦Íã,žü“5Í¨¨“Ðt˜ëéªüªžüÝ"$à¡ëëé§§
ªÍle_bytesÁDåü¢!¤¯ÄÝÊæ	,Ë8unsignedÁDÌ&Ô8”Õ$×,Ù8è$Ú&Þ8Ø	<ß*èëÚ8$õ8ên\ú…,†8è$‡‹�Ô+›œÄ8¡�¡8ï4£	©ªÃ7Gets this `RawBytesULE` as a `Áü« $Ë8µLÍ	Ö×á,Ø8ÑÓDÙ$â7]`. This is equivalent to calling [`AsULE::from_unaligned()`] on the appropriately sized type.Áüä_+ÒÓÚ8þ4Ô8è8ì8³q|ïþ„ÿ8$€(†,‰8ÑÓDŠ“ê¥,¦8ÑÓD§8°,³8,´'¹8÷=»'¾8ÀY,ÀÅ'Æ8�?tÈÖÜ
×8$Ø+ùú¡8¡ûÿ8ï4�	‡ˆ 7Converts a `Át‰$—8µL™	¢£,¤8ÑÓD¥$®7n` to a `RawBytesULE`. This is equivalent to calling [`AsULE::to_unaligned()`] on the appropriately sized type.Áü°p+¯°·8þ4±8Å8,É8Ï8¨>dÒÞï8˜,ß&ä,æ8ÑÓDç(ñ8$ôù±8$‹�£8˜,� •8to_le_bytesÁ\–¡¢8›CœÀ	ÓÔÉ,æ8ÑÓDç$ï8ên\�Œ,�8è$Ž’$“8ên\¥°»±º7ì²%³,µ8è$¶%Ê%Ûüà$¼í…Œ!‹£	,Œ8baseÁ$�&‘8”’$”,–8è$—&›8Ø	<œ*¥¨‰!8$²8æL·À,Á8Œß$ÂÆÈƒ!<øúüÖT<Ôûœ·<Ë×<P This cannot be generic over T because of current limitations in `const`, but ifÁüçS<U this method is needed in a non-const context, check out [`ZeroSlice::parse_bytes()`]ÁüÇX<	 instead.Ád¬<ËÅ<* See [`ZeroSlice::cast()`] for an example.ÁüÕ-8�8,“8™8¥xtœª·8ã,«&°²³¶8¦´(¹8ý4¼ÂÃ8$Ä$È8¶¬DÊÒÔù 8æ8¾	êî8ã,ð õ8¾	öùú%û+�Ž¨8è,�”§8Æ4•'›8
modulo_oneÁT�8º8¾	½Á,Ã8è$ÄÉ7ìÌÎ¥8Òäæ“8"4çî’8$ð'ô8»¤öŠ�8ã,‹8$§¬ë 8“ÂÅÙ 8¶¬DÆ'Î8Æ¬lÐÞØ 8”ø&ú8ï4ü	‚ ƒ ¤ 7<const construct: Á¤„ $˜ ,š 8è$› $Ÿ 7>Á¡ $¥ 8¾	¿ $Â %Š!ü�!!¤œ!±!Ñ(·!á!,¸!8	single_fnÁL¹!&Â!8Û,Ã!$È!,Ê!8!$Ë!&Ï!8”Ð!$Ò!,Ô!8è$Õ!&Ù!8Ø	<Ú!*ã!æ!Î(!8$ð!8ž$õ!ù!,ú!8!$û!ÿ!8
�"8ên\…"�",‘"8è$’"–"˜"œ#+¦"§"®"8þ4¨"8¼"8ï$¿"Ã"Ð"8˜,Ä"&É",Ë"8!$Ì"(Ò"8$Õ"Ú"’#8$ì"ð"„#8˜,ñ" ö"8ýÜ\÷"‚#ƒ#8$¦#8ÀY,«#8
±#,µ#8!$¶#»#‹&8!$É#8â>Î#Ò#8ên\Ô#ß#,à#8è$á#å#%æ#+ô#õ#ü#8þ4ö#8Š$8í>d�$™$ž$8$š$( $8$£$'§$8â>©$$ë$8ên\¿$Ê$Ý$8$Ë$ Ï$8ýÜ\Ð$Û$Ü$+ù$ú$�%8þ4û$8�%8�?t’% %µ%8çë	L¡%&ª%8$¬%'°%8â>²%(·%8$º%¿%�&Ñ%,Ò%8!$Ó%×%'Ø%8
from_le_bytesÁlÚ%ç%ó%8çë	Lè% ñ%7ìò%8"4‹'8$’'8åY,—'8
�',¡'8!$¢'§'¨'8$³'8ên\¸'Ã',Ä'8è$Å'É'Ë'È(	8Ù'8,Ý'8ã',æ'8™éLç'ð'ù'8ç¯ñ'&ò',ô'8!$õ'(û'8$þ'ƒ(¾(8ên\•( (°(8ç¯¡( ¢(8ýÜ\£(®(¯(%Ï(üÔ(*ìá(ÿ(ç)…)�)	,†)8!$‡)&‹)8”Œ)$Ž),�)8è$‘)&•)8Ø	<–)*Ÿ)¢)ä)8žP¤¬)	À)Á)Ý)8óslÂ)$Ï),Ñ)8!$Ò)$Ö),Ø)8è$Ù)%Þ)%å)üê)(Ü÷)“*ù*™*±*	,š*8!$›*&Ÿ*8” *$¢*,¤*8è$¥*&©*8Ø	<ª**³*¶*ö*8žP¤À*	Ô*Õ*ï*8¬v\Ö*$á*,ã*8!$ä*$è*,ê*8è$ë*%ð*%÷*´4²Å²üØ48tÛ4õõ—ãºê±ò4±
²_bytesÁ4ê4Œ«5´µ¶ÊËÌµ¶DÃ5È5³³üæ5"dé5Ê³³
µ$ö5ü°6/t³6«ú³³
¶çë	LÂ6Ä©7ì†;Ïî¹Å¹ü¸;7t»;öö—ãºê¸Ñ;¸
¹ã,Ê;”<¹‚°º›°º¹°ºº¹º—«ºêÄ³=Ïî¼½¾ÊËÌ½¾DÒ=×=»»Ïîüõ="dø=ÏîÏîÊ»»
½$…>ü¿>/tÂ>åýÏî»»
¾çë	LÑ>üŒ?Ïîü°? ÏîÂ›À?ü×? ŒÝ?ÀÀ×ïõ?´±CÅÅÅüÜC8tßC÷÷—ãºêÄöCÄ
Å¸ø4îCŒ¯DÇÈÉÊËÌÈÉDÇDÌDÆÆüêD"díDÊÆÆ
È$úDü´E/t·EŽ�ÆÆ
Éçë	LÆEÄFÄÊF×ïÌÍÎÊËÌÍÎDéFîFËËÏîü‘G"d”G×ï×ïÊËË
Í$¡Gü·H/tºHñ‚×ïËË
Îçë	LÉH”×LÐÒÓÊËÌÒÓDðLõLÏÏçÍ‡Mü�M"d MÊÏÏ
Ò$Mü€N/tƒNÒ„ÏÏ
Óçë	L’N”óNÕ×ØÊËÌ×ØDŒO‘OÔÔõë£Oü¹O"d¼O
~™ÕéêÂî�™ªcéêÃâ>ÿF·éêØ³ZG¸éêÙ¶¬2GÊéê´iFGÆ
éê´åj]Gà
éê¶ûktGô
éê¹ûktGõ
éê¹ên¢G©éê¾ên¢Gªéê¾TÏü²2™ìÍíìí½ð¾Ì”tÆÄ³ÑÁóðïÅï+-0Ìüù7tüúú—ãºêë’ë
ï³ÑÍã,‹ü/™ñÍòñò½ð²Ì”t¼Îð,µóðôö÷ÊËÌ÷ö57:ÂDãèððþÈÍü�"d�óðóðÊðð
ö³ÑÍ$�üì/tï€–óððð
÷³ÑÍçë	LþüÐ	6™ùÍúúù½ðÜ	Ì”tæ	Í³Ñ,ß	óð "%ì	Ô¿ýÿ�ÔÕÖÿ�ýüî7tñûû—ãºêü‡ü
ýã,€Ôý‚°þ›°þ¹°þþýþƒÄƒÄ	Utf8ErrorÁ„Ävalid_up_toÁ›s…Ä	error_lenÁ›s8(JÒó]�ÄÀ�ü�7\ üü—ãê³í³î³Òï³ìð³ñ³“ò³ìäs{©¶‘üÀ�ü³ü
ÿã,¬ƒÿ‚°€›°€¹°€€ÿ€Á™ü®5ü¬JG Invariant: must be safe to call when called on a slice that previouslyÁüû  succeeded with `parse_bytes`Á¤¸ýý—ãýüÔü
�ã,Íüø/ü�b_ 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:Á³Ël·
 ```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Á™ƒƒ½ð„®“£ƒÙ„…ÔÖ„…&(ü¼7t¿þþ—ãºê‚Õ‚
„³Ñî,Îü°5¤ºÿÿ—ãÿƒÙ‚Ö‚
…³Ñã,ÏlÇÌË ULE impls for tuples.ÁåËüé]Z Rust does not guarantee the layout of tuples, so 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).ÁÓËt×á æË<êæ¡ÌòºþŒËÌ� // ZeroVec of tuples!ÁüªRO let zerovec: ZeroVec<(u32, char)> = [(1, 'a'), (1234901, 'å•Š'), (100, 'à¤…')]Á|ý�Œ�     .copied()ÁœŸ     .collect();Á³Ëü·74 assert_eq!(zerovec.get(1), Some((1234901, 'å•Š')));Á<ïæ¡ôEîï˜
™
Í
Î
�ŽØÙÍ�Á]†ˆÓ
ŸÕ†‰‚>”¦’†‡ÎE¦¥†‡�CD¦å†‡¶CC¦ç†‡ãFB¦’†‡äA¦Ð†‡çN@¦™†‡ôS?¦é†‡�ôE††‡æUF‹†‡²VF•†‡â>-FÄ†‡ÀY@FÉ†‡åYSFÍ†‡òYfFÎ†‡³ZyFÓ†‡Ü?ŒF†‡µŽG£F™†‡¸ÆGºF�†‡ºûJÑF×†‡¼ÞLèFö†‡½÷Ö¨ã#†‡Àî¯¨ªc†‡Ãâ>ÿF·†‡Ø³ZG¸†‡Ù¶¬2GÊ†‡´iFGÆ
†‡´åj]Gà
†‡¶ûktGô
†‡¹ûktGõ
†‡¹ên¢G©†‡¾ên¢Gª†‡¾,üLŠL™ú´¥L²¼Î$Âõ,Ã8ÿ
$Ä&È8Û,É$Î,Ð8¾	Ñ&Ô8Ø	<Õ$ÜÞô,àáð,â8tÁã&ä8Û,å,ë8»ì&í8�î$ñò*÷úË$Æ+„…Ä8¡†Š8ï4Œ	’“Ã7ULE type for tuples with ÁÜ”$¯,±8¾	²$µ7
 elements.Ád·+ÎÏß8Ñ
$ÐÔÞ8kÕ$Ö8ó4Ø+éêŒ8è,ëð‹8Æ4ñ'÷8exhaustive_structsÁ”ù8 84¤,«8ÿ
$¬°,±²µ,³8Ï±´$¶·¸¹Å,º»Â8¼,À8Ï±Á$ÃÄ%Æ8"4¯8$¶º,»¼Ä,½8Ï±¾&¿8â>Á$ÅÆÇ8â>É8
Í,Ñ8ÿ
$ÒÖ,×ØÛ,Ù8Ï±Ú$ÜÝÞàð8î8¯(tñÿŒ8ã,€&…‡ˆ‹8¦‰(Ž8ý4‘—˜™$š8¶¬Dœ¤¦æ8Š8	ule_bytesÁLŽ˜7ì‰4š,¡¢¹
£8Ó
¥'¨8é<ª'±³,´8Ï±µ¶·¸º%»8Í8ã,Ð Õ8¾	ÖÙÚÜ8¾¹LÞè7ìëíÆ84ƒ8“Š�³8¶¬DŽ'–8’[4˜'ž 8$¡¥¦²8ã,§ ¬8¾	°±%´8
Ø8chunkÁ,Ü8â8ã,å ê8chunksÁ4ëñû8¾¹LòýÁ	8“8—8»›�7ìŸ% ,¶·®8Ñ8jÁÕ×8»Ù%Ú8»ôö8Ó
ù'ü8é<þ'…‡,ˆ8Ï±‰Š‹Œ%�+§¨É8ä4©¯È8Æ4°'¶8ÎÁ
„¸õ,ö8Ï±÷ø'ù8¯(tû‰–Š8ó¼,‹�•8®¾‘!’8»”-—%˜¯8ÒÓÕØÖ×8$ûÿ,€�‹,‚8Ï±ƒ&„8ÀY,†$Œ�Ž8ÀY,�8
–š¢,›œŸ,�8Ï±ž$ ¡¤Î8!$²8â>·»,½8ÿ
$¾Â,ÃÄÎÅ,Æ8Ï±ÇÈ'É8â>Ë$ÏÐÑ%Ò+áâé8þ4ã8÷8í>dú†‹8$‡(�8$�'”8â>–š�,¬8ÿ
$±ó,²³ð8$É Í,Î8»Ï Ð8í>dÑÝÞ$ñò+�‘˜8þ4’8¦8�?t©·Ì8çë	L¸&Á8$Ã'Ç8â>É(Î8$ÑÖÄè¶,éê³€,�8Ï±‚ƒ'„8�?t†”¡8çë	L• ž,Ÿ8» $´µ8$ÙÝ,Þßô,à8Ï±á&â8Íä'ç8�,éï8â>ñ$õö÷8Íù'ü8�,þ8
„,ˆ8ÿ
$‰�,Ž�’,�8Ï±‘$“”•—§
8¥8Í¨«Í
¬8$$±8þ³&´¶8·8Í»'¾8œLÀÉ:8ÊÌ(Ï8ý4ÒØÙÚ$Û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ÜT�˜8â>š$žŸ 8ÜT¢8
,±8ÿ
$²¶,·¸»,¹8Ï±º$¼½¾Àæ
8Î8¤\ÑÜðÝ8$Þ$â8î,ä&éë8$ì(ò8Ó4õû8³$ü'€8Ð‚'…8ÕD‡�‘Ü£°,¤¥8$¦ ª,«8»¬$®¯ ±8¤\²½Î¾¿Í,ÀÁÊ8î,Â Ç,È8»É$ËÌ8$ñõ,ö÷…,ø8Ï±ù&ú8Ôü€8â>‚$†‡ˆ8ÔŠ8
Ž,’8ÿ
$“—,˜™œ,š8Ï±›$�žŸ¡¯ 
8¯8Ð²µÉ¶8$·$»8î,½&ÂÄ8$Å(Ë8³$Î'Ò8ÐÔ'×8ÕDÙâ¥ ô� ,õöþ8$÷ û,ü8»ý$ÿ€  ‚ 8Ðƒ † — ‡ ˆ – ,‰ Š “ 8î,‹  � ,‘ 8»’ $” • 8$º ¾ ,¿ À È ,Á 8Ï±Â &Ã 8â>Å $É Ê Ë 8u,Í 8
Ó ,× 8ÿ
$Ø Ü ,Ý Þ á ,ß 8Ï±à $â ã ä æ º!8ô 8È,÷ ü ‚!ý 8$þ („!8$‡!Œ!°!
ž!8$Ÿ!8$Å!É!,Ê!Ë!Ó!,Ì!8Ï±Í!&Î!8â>Ð!$Ô!Õ!Ö!8$Ø!8
Ý!,á!8ÿ
$â!æ!,ç!è!ë!,é!8Ï±ê!$ì!í!î!ð!ñ!+ü!ý!”"8¢þ!�"“"8¶<‚"Š"7á<Œ"8$ž"¢":¨£"$¥",§"¨"Â",©"8Ï±ª"&«"8Ô"±"8ÀY,³"¹":7<»"$Ã"Ä"Å"8,Ç"'Ì"8…
Î"'Ñ"8¾LÓ"Ü":¨Ý"ß"8
á"å"í",æ"ç"ê",è"8Ï±é"$ë"ì"ï"Å$'8!$ý"8	ContainerÁL‚#Œ#8,Ž#'“#8Ž<•#œ#:¨�#$Ÿ#¡#©#,¢#£#¦#,¤#8Ï±¥#$§#¨#ª#%«#8!$¹#8SliceÁ,¾#Ä#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ÁF®òÄ¤’�c<Ø
ä	‹Ž·�cå	‹Ž·ù„á
a‹�»Íþ
Á]‹�Á¯\•
‰‹‘Á¯Š‹‘Ó
¬
Õ‹’îØD¿

‹“îØ5‹“‚>5È’‹ŒÎæÇ¥‹Œ�CåÇå‹Œ¶CäÇç‹ŒãFãÇ’‹ŒäâÇÐ‹ŒçNáÇ™‹ŒôSàÇé‹Œ�ôE†‹ŒæUF‹‹Œ²VF•‹Œâ>-FÄ‹ŒÀY@FÉ‹ŒåYSFÍ‹ŒòYfFÎ‹Œ³ZyFÓ‹ŒÜ?ŒF‹ŒµŽG£F™‹Œ¸ÆGºF�‹ŒºûJÑF×‹Œ¼ÞLèFö‹Œ½÷wÊã#‹ŒÀîPÊªc‹ŒÃâ>ÿF·‹ŒØ³ZG¸‹ŒÙ¶¬2GÊ‹Œ´iFGÆ
‹Œ´åj]Gà
‹Œ¶ûktGô
‹Œ¹ûktGõ
‹Œ¹ên¢G©‹Œ¾ên¢Gª‹Œ¾,¶
üÄ.
¨«|Lø
nÌ‡
_L¦
;”µ
,ÌÊ
d×
ä
·U
Ì	
–

,Í	
8ÿ
$Î	
&Ò	
8Û,Ó	
$Ø	
,Ú	
8¾	Û	
&Þ	
8Ø	<ß	
$æ	
è	
•

,ê	
ë	
‘

,ì	
8™í	
&î	
8Û,ï	
,õ	
8Ï±ö	
&÷	
8Û,ø	
,þ	
8T_altÁ,ÿ	
&„

8Û,†

,Œ

8»�

&Ž

8��

$’

“

*˜

›

´U
ï+¥

¦

�
8¡§

«

8ï4

	³

´

Œ
7VarULE type for tuples with Áôµ

$Ó

,Õ

8¾	Ö

$Ù

7/ elements. See module docs for more informationÁüÛ
1
+—
˜
ª
8Ñ
$™
�
©
8þ\ž
+´
µ
×
8è,¶
»
Ö
8Æ4¼
'Â
8Ú´”Ä
8ë
84ï
,ö
8ÿ
$÷
û
,ü
ý
‰
,þ
8™ÿ
&€
-‚
8Œ,ƒ
$ˆ
Š
8ñC4Œ
&’
8ù„”
¥
8�c<§
®
°
Ã
,¾
¿
Ô
	,À
8Ï±Á
&Â
8Á¯\Ä
Ï
,Ð
8™Ñ
Ò
$Ó
Õ
8¶C,—
&œ
8åjtž
¬
,
8¾	®
$±
8ñC4³
¹
8$Î
Ò
,Ó
Ô
é
,Õ
8™Ö
&×
8³Z4Ù
à
-â
8Œ,ã
$è
ê
8ñC4ì
&ò
8ù„ô
„
,†
8ÿ
$‡
‹
,Œ
�
‘
,Ž
8™�
$�
’
8ñC4”
š
œ
ê
,ª
«
ß
+½
¾
ï
8¡¿
Ã
8ï4Å
	Ë
Ì
î
7
Get field ÁdÍ
$Ù
,Û
8»Ü
$Ý
7
of this tupleÁ|ß
8�
8…
,ˆ
8Ï±‰
Š
�
‹
8$Œ
(’
•
,–
8™—
™
Ï
8"4é
ð
½
8$Š
 Ž
8¶C,�
 ”
8 EL•
'ž
 
,¡
8™¢
£
¤
§
,¥
8»¦
à
8"4ª
8$±
µ
,¶
·
Ì
,¸
8™¹
&º
8³Z4¼
Ã
-Å
8Œ,Æ
$Ë
Í
8ñC4Ï
&Õ
8ù„×
ç
8³Z4é
8
ð
,ô
8ÿ
$õ
ù
,ú
û
ÿ
,ü
8™ý
$þ
€
8ñC4‚
ˆ
’
Ï"
8 
8¯(t£
±
¾
8ã,²
&·
¹
º
½
8¦»
(À
8ý4Ã
É
Ê
Ë
$Ì
8¶¬DÎ
Ö
Ø
Ë
8ý
8¶C,�
‡
‰
8åjtŠ
˜
,™
8¾	š
$�
8ñC4Ÿ
¥
8§
8³Z4ª
°
'±
8©\³
¾
Ä
8ã,¿
-Å
%Æ
,Ø
Ù
¥
8"4½
Ä
“
8¶C,Þ
 ã
8‚Etä
'ò
ô
,õ
8™ö
÷
ø
û
,ù
8»ú
-ü
%ý
¦
8Ò¸
º
½
»
¼
8"4Ú
8á
8»¤ä
ø
…
8ã,ù
&þ
€
�
„
8¦‚
(‡
Š
8$‹
�
Å"
$8¶
8¶C,º
À
Â
8åjtÃ
Ñ
,Ò
8¾	Ó
$Ö
8ñC4Ø
Þ
8à
8³Z4ã
é
'ê
8»¤ì
€ 
† 
8ã,� 
%‡ 
8Ó
û!
'þ!
8ùL€"
'‰"
‹"
Œ"
8åjt�"
›"
,œ"
8¾	�"
$ "
8ñC4¢"
¨"
$©"
«"
8$¬"
°"
±"
·"
8¶C,²"
8$Ú"
Þ"
,ß"
à"
‚#
,á"
8™â"
&ã"
8Íå"
'è"
8�,ê"
ð"
8³Z4ò"
ù"
-û"
8Œ,ü"
$�#
ƒ#
8ñC4…#
&‹#
8ù„�#
�#
8ÍŸ#
'¢#
8�,¤#
8
ª#
,®#
8ÿ
$¯#
³#
,´#
µ#
¹#
,¶#
8™·#
$¸#
º#
8ñC4¼#
Â#
Ä#
Ö$

8Ò#
8ÍÕ#
Ø#
ú#

Ù#
8$Ú#
$Þ#
8þà#
&á#
ã#
8ä#
8Íè#
'ë#
8œLí#
ö#
:8÷#
ù#
(ü#
8ý4ÿ#
…$
†$
‡$
$ˆ$
8ÍŠ$
'�$
8”,�$
”$
–$
Ì$
¨$
·$
,©$
ª$
µ$
8$«$
 ¯$
,°$
8Ï±±$
²$
³$
$´$
¶$
 ¸$
8Í¹$
¼$
¾$
8þ½$
8$³%
·%
,¸%
¹%
Ú%

,º%
8™»%
&¼%
8ÛL¾%
È%
8³Z4Ê%
Ñ%
-Ó%
8Œ,Ô%
$Ù%
Û%
8ñC4Ý%
&ã%
8ù„å%
õ%
8ÛL÷%
8
�&
,…&
8ÿ
$†&
Š&
,‹&
Œ&
�&
,�&
8™Ž&
$�&
‘&
8ñC4“&
™&
›&
�'
8©&
8Õ¬&
®&
Â&
¯&
8$°&
$´&
8î,¶&
&»&
½&
8$¾&
(Ä&
8õ$Ç&
Ì&
“'
ß&
î&
,à&
á&
ì&
8$â&
 æ&
,ç&
8Ï±è&
é&
ê&
$ë&
í&
 ï&
8Õð&
ò&
…'
ó&
ô&
„'
,õ&
ö&
‚'
8î,÷&
 ü&
,ý&
8Ï±þ&
ÿ&
€'
$�'
ƒ'
8$¨'
¬'
,'
®'
È'

,¯'
8™°'
&±'
8‘³'
¶'
8³Z4¸'
¿'
-Á'
8Œ,Â'
$Ç'
É'
8ñC4Ë'
&Ñ'
8ù„Ó'
ã'
8‘å'
8
è'
,ì'
8ÿ
$í'
ñ'
,ò'
ó'
÷'
,ô'
8™õ'
$ö'
ø'
8ñC4ú'
€(
‚(
ƒ(
8$Ž(
’(
,“(
”(
¶(

,•(
8™–(
&—(
8ÜT™(
¤(
8³Z4¦(
(
-¯(
8Œ,°(
$µ(
·(
8ñC4¹(
&¿(
8ù„Á(
Ñ(
8ÜTÓ(
8
Þ(
,â(
8ÿ
$ã(
ç(
,è(
é(
í(
,ê(
8™ë(
$ì(
î(
8ñC4ð(
ö(
ø(
¢*

8†)
8¤\‰)
”)
¨)
•)
8$–)
$š)
8î,œ)
&¡)
£)
8$¤)
(ª)
8Ó4)
³)
8³$´)
'¸)
8Ðº)
'½)
8ÕD¿)
Ç)
É)
˜*
Û)
ê)
,Ü)
Ý)
è)
8$Þ)
 â)
,ã)
8Ï±ä)
å)
æ)
$ç)
é)
 ë)
8¤\ì)
÷)
Š*
ø)
ù)
‰*
,ú)
û)
‡*
8î,ü)
 �*
,‚*
8Ï±ƒ*
„*
…*
$†*
ˆ*
8$*
±*
,²*
³*
Î*

,´*
8™µ*
&¶*
8Ô¸*
¼*
8³Z4¾*
Å*
-Ç*
8Œ,È*
$Í*
Ï*
8ñC4Ñ*
&×*
8ù„Ù*
é*
8Ôë*
8
ï*
,ó*
8ÿ
$ô*
ø*
,ù*
ú*
þ*
,û*
8™ü*
$ý*
ÿ*
8ñC4�+
‡+
Š+
œ,

8˜+
8Ð›+
ž+
²+
Ÿ+
8$ +
$¤+
8î,¦+
&«+
+
8$®+
(´+
8³$·+
'»+
8Ð½+
'À+
8ÕDÂ+
Ë+
’,
Ý+
ì+
,Þ+
ß+
ê+
8$à+
 ä+
,å+
8Ï±æ+
ç+
è+
$é+
ë+
 í+
8Ðî+
ñ+
„,
ò+
ó+
ƒ,
,ô+
õ+
�,
8î,ö+
 û+
,ü+
8Ï±ý+
þ+
ÿ+
$€,
‚,
8"4ý-
8$„.
ˆ.
,‰.
Š.
Ž.
,‹.
8™Œ.
$�.
�.
,‘.
’.
š.
,“.
8Øõ,”.
$™.
›.
8ñC4�.
£.
8Ü?t¥.
³.
,´.
8ÿ
$µ.
¹.
,º.
».
¿.
,¼.
8™½.
$¾.
À.
8ñC4Â.
È.
8
Ë.
Ï.
Ý.
,Ñ.
Ò.
Ù.
,Ó.
8Øõ,Ô.
$Ú.
Û.
8$,ç.
,ù.
ú.
�/
,û.
8™ü.
&ý.
8³Z4ÿ.
†/
-ˆ/
8Œ,‰/
$Ž/
�/
,ž/
Ÿ/
»/
	, /
8Øõ,¡/
&¦/
8Ü?t¨/
¶/
,·/
8™¸/
¹/
$º/
¼/
8ñC4Ê/
&Ð/
8ù„Ò/
$â/
ì/
Î9
8ú/
8ûÄý/
•0
8š–0
—0
˜0
½0

™0
8$š0
$ž0
8 0
&¡0
8$£0
8›4¨0
®0
·0
¯0
°0
¶0
±0
²0
µ0
8¦³0
(¹0
8š¼0
(¿0
8šÂ0
Ä0
±1
8ß\–1
	¡1
¢1
£1
+À1
Á1
È1
8þ4Â1
8Ö1
8Ã”Ù1
ë1
ñ1
ì1
8$í1
(ó1
8‰,ö1
ü1
Š4
8åjt¡3
'¯3
±3
,²3
8¾	³3
$¶3
8ñC4¸3
¾3
'¿3
8ÿC¼Á3
Ø3
ü3
Ù3
û3
,Ú3
Û3
ø3
8$Ü3
 à3
,á3
8»â3
 ã3
8Ã”ä3
ö3
÷3
$ù3
ú3
+™4
š4
¡4
8þ4›4
8¯4
8Ü¤²4
Æ4
Ü4
Ç4
8$È4
$Ì4
8·…Î4
&Ñ4
Ó4
8Ô4
Ø4
Û4
8¦Ù4
Þ4
Ä9
8ð4
8÷Î
<ô4
ü4
þ4
 5
,ÿ4
€5
�5
8$�5
 …5
,†5
8»‡5
 ˆ5
8Ã”‰5
›5
œ5
$ž5
Ÿ5
%¡5
8Æ6
8¶C,Ê6
Ð6
8åjtÒ6
'à6
â6
,ã6
8¾	ä6
$ç6
8ñC4é6
ï6
'ð6
8£Düò6&
˜7
¥7
8÷Î
<™7
$ 7
8·…¢7
%¦7
,¸7
¹7
µ9
8"4¾8
Å8
£9

8¶C,ß8
 ä8
8ÞDdå8
'ñ8
ó8
,ô8
8™õ8
$ö8
,ø8
8Øõ,ù8
þ8
ÿ8
Œ9
,€9
8»�9
$‚9
„9
8$…9
 ‰9
,Š9
8»‹9
%�9
¶9
+Ù9
Ú9
ñ9
8¢Û9
Þ9
ð9
8¶<ß9
ç9
7á<é9
8$û9
ÿ9
,€:
�:
–:
,‚:
8™ƒ:
&„:
8³Z4†:
�:
-�:
8Œ,�:
$•:
—:
8ñC4™:
&Ÿ:
8ù„¡:
±:
8á,³:
'¸:
8š4º:
'À:
8œ<Â:
8
Ê:
,Î:
8ÿ
$Ï:
Ó:
,Ô:
Õ:
Ù:
,Ö:
8™×:
$Ø:
Ú:
8ñC4Ü:
â:
ä:
‰<
8!$ò:
8OwnedÁ,÷:
ý:
8á,ÿ:
'„;
8¿,†;
'‹;
8ä�;
�;
8$‘;
•;
%–;
8¤;
8to_ownedÁD§;
¯;
µ;
°;
8$±;
(·;
8$º;
'¾;
8�µ
,À;
Æ;
ÿ;
8õ
¤Ø;
ì;
ñ;
8$í;
8$”<
˜<
:¨™<
$›<
,�<
ž<
¢<
,Ÿ<
8™ <
$¡<
£<
,¥<
¦<
®<
,§<
8Øõ,¨<
$<
¯<
8ñC4±<
·<
8îØD¹<
Â<
:¨Ã<
$Å<
,Ç<
8ÿ
$È<
Ì<
,Í<
Î<
Ò<
,Ï<
8™Ð<
$Ñ<
Ó<
8ñC4Õ<
Û<
8
Þ<
â<
î<
,ã<
ä<
ë<
,å<
8Øõ,æ<
$ì<
í<
8$,ø<
,’=
“=
¨=
,”=
8™•=
&–=
8³Z4˜=
Ÿ=
-¡=
8Œ,¢=
$§=
©=
,¿=
À=
Ú=
,Á=
8Øõ,Â=
&Ç=
8îØDÉ=
Ñ=
:¨Ò=
$Ô=
,Ö=
8™×=
Ø=
$Ù=
Û=
8ñC4ñ=
&÷=
8ù„ù=
Š>
Â?
8˜>
8‰L›>
¤>
Å>
8î,¥>
&ª>
¬>
:¨>
,°>
8ÿ
$±>
µ>
,¶>
·>
»>
,¸>
8™¹>
$º>
¼>
8ñC4¾>
Ä>
(Ç>
8$Ê>
Ï>
¸?
á>
ª?
,÷>
ø>
—?
,ù>
8Øõ,ú>
'ÿ>
8‰L�?
Š?
•?
8î,‹?
 �?
,‘?
8Ï±’?
“?
”?
$–?
˜?
+Í?
Î?
å?
8¢Ï?
Ò?
ä?
8¶<Ó?
Û?
7×<Ý?
8$ï?
ó?
,ô?
õ?
‹@
,ö?
8™÷?
&ø?
8×,ú?
'ÿ?
8	SerializeÁL�@
$Š@
Œ@
8ñC4Ž@
”@
8×,–@
'›@
8û¿
L�@
8
§@
,«@
8ÿ
$¬@
°@
,±@
²@
¶@
,³@
8™´@
$µ@
·@
8ñC4¹@
¿@
8$,É@
,Û@
Ü@
ñ@
,Ý@
8™Þ@
&ß@
8³Z4á@
è@
-ê@
8Œ,ë@
$ð@
ò@
,âA
ãA
…B
8
äA
çA
:¨èA
êA
ìA
:¨íA
,ðA
8™ñA
&òA
8îØDôA
üA
:¨ýA
$ÿA
,�B
8™‚B
ƒB
$„B
†B
8ñC4”B
&šB
8ù„œB
µB
ŽF
8ÃB
8	serializeÁLÆB
ÏB
8SÁÐB
ÑB
ÒB
çB
ÓB
8$ÔB
$ØB
8
serializerÁTÚB
&äB
8œÄ
æB
(éB
8ý4ìB
òB
8œÄ
óB
'ôB
8ÒöB
$øB
8œÄ
úB
'ûB
8”,ýB
‚C
8$,„C
8œÄ
ŠC
&‹C
8×,�C
'’C
8
SerializerÁT”C
ŸC
„F
8±C
8ÔÄ
T´C
 ¾C
8is_human_readableÁŒ¿C
ÐC
ÑC
ÓC
—E
8éC
8thisÁ$íC
òC
ôC
±D
,ŽD
�D
™D
8$�D
 ”D
,•D
8Ï±–D
—D
˜D
$šD
›D
%²D
ÈD
ÉD
ÒD
,ÊD
ËD
ÏD
ÌD
,ÍD
8™ÎD
$ÐD
ÑD
8ÔD
8×,×D
'ÜD
8û¿
LÞD
çD
'èD
8�Ä
LêD
óD
…E
ôD
8�Ç
$õD
$ùD
8ÔÄ
TûD
8$™E
žE
öE
8ÔÄ
T´E
 ¾E
8serialize_bytesÁ|¿E
ÎE
äE
8$ÏE
 ÓE
8¶C,ÔE
 ÙE
8ŠDÚE
âE
ãE
+™F
šF
ÉF
8¢›F
žF
ÈF
8àŸF
¢F
ÇF
8¶<£F
«F
7×<F
$´F
8¶<¶F
¾F
7á<ÀF
8$ÓF
×F
:'deÁØF
$ÛF
,ÝF
ÞF
óF
,ßF
8™àF
&áF
8³Z4ãF
êF
-ìF
8Œ,íF
$òF
ôF
8ñC4öF
üF
8×,þF
'ƒG
8DeserializeÁ\…G
�G
:òË
‘G
”G
8
–G
8á,šG
'ŸG
8¿,¡G
'¦G
8ä¨G
«G
,¬G
8ÿ
$G
±G
,²G
³G
·G
,´G
8™µG
$¶G
¸G
8ñC4ºG
ÀG
8$,ÏG
,¾H
¿H
ðH
8á,ÁH
'ÆH
8¿,ÈH
'ÍH
8äÏH
ÒH
,ÓH
8™ÔH
ÕH
&ÖH
8×,ØH
'ÝH
8ŠÍ
\ßH
êH
:òË
ëH
îH
$ïH
ñH
8ñC4ƒI
&‰I
8ù„‹I
œI
ÄO
8ªI
8deserializeÁ\I
¸I
8DesÁ¹I
¼I
½I
ÏI
8deserializerÁd¾I
&ÊI
8äÐ
ÌI
(ÑI
8ý4ÔI
ÚI
8$ÛI
$ßI
8äÐ
áI
'äI
8”,æI
ëI
8$,íI
8äÐ
óI
&öI
8×,øI
'ýI
8DeserializerÁdÿI
‹J
:òË
ŒJ
�J
‘J
ºO
8£J
8†Ñ
d¦J
 ²J
8ÍÆ
Œ³J
ÄJ
ÅJ
ÇJ
òL
8ÝJ
8�Ç
$áJ
æJ
èJ
éJ
…K
,ëJ
ìJ
‚K
	8á,íJ
'òJ
8¿,ôJ
'ùJ
8äûJ
þJ
,ÿJ
8™€K
�K
$ƒK
„K
8‡K
8×,ŠK
'�K
8ŠÍ
\‘K
œK
'�K
8ÇÐ
\ŸK
ªK
·K
8†Ñ
d«K
-¸K
%¹K
8ÏK
8this_refÁDÓK
ÜK
ÞK
›L
,øK
ùK
ƒL
úK

ûK
8�Ç
$üK
 €L
,�L
8»‚L
$„L
…L
%œL
8Ò²L
´L
àL
8,µL
'ºL
8÷=¼L
'¿L
8õ
¤ÁL
ÕL
ßL
ÖL
8ÄÕ
D×L
8$ôL
ùL
¬O
8£N
8deserializedÁd§N
´N
¶N
·N
,¸N
8ÿ
$¹N
½N
,¾N
¿N
ÃN
,ÀN
8™ÁN
$ÂN
ÄN
8ñC4ÆN
ÌN
'ÎN
8ÇÐ
\ÐN
ÛN
èN
8†Ñ
dÜN
-éN
%êN
8Ò€O
‚O
šO
8Î×
dƒO
 �O
8to_boxedÁD�O
˜O
™O
+ÏO
ÐO
çO
8¢ÑO
ÔO
æO
8¶<ÕO
ÝO
7×<ßO
8$ñO
õO
:¨öO
$øO
:òË
úO
&ýO
:¨ÿO
$�P
,ƒP
„P
™P
,…P
8™†P
&‡P
8³Z4‰P
�P
-’P
8Œ,“P
$˜P
šP
8ñC4œP
&¢P
8ù„¤P
´P
8×,¶P
'»P
8ŠÍ
\½P
ÈP
:òË
ÉP
ÌP
8
ÎP
ÒP
:¨ÓP
,ÖP
8ÿ
$×P
ÛP
,ÜP
ÝP
áP
,ÞP
8™ßP
$àP
âP
8ñC4äP
êP
ìP
®U
8úP
8ÇÐ
\ýP
ˆQ
8äÐ
‰Q
ŒQ
�Q
ŸQ
8†Ñ
dŽQ
&šQ
8äÐ
œQ
(¡Q
8ý4¤Q
ªQ
8$«Q
$¯Q
8äÐ
±Q
'´Q
8”,¶Q
»Q
8$,½Q
8äÐ
ÃQ
&ÆQ
8×,ÈQ
'ÍQ
8®Ò
dÏQ
ÛQ
:òË
ÜQ
ßQ
áQ
¤U
8óQ
8†Ñ
döQ
 ‚R
8ÍÆ
ŒƒR
”R
•R
—R
ÖS
8“R
°R
ÄS
8×,±R
'¶R
8deÁ¸R
'ºR
8”,¼R
'ÁR
8‰	4ÃR
ÉR
ÃS
8ï4ãR
	éR
êR
¬S
7&ÁëR
$îR
8µLðR
	ùR
úR
€S
,ûR
8ÿ
$üR
$�S
7' can only deserialize in zero-copy waysÁüƒS)
$S
8$ØS
ÝS
–U
8óS
8ã,÷S
ýS
ÿS
€T
�T
„T
8¦‚T
…T
'†T
8ÇÐ
\ˆT
“T
 T
8†Ñ
d”T
-¡T
%¢T
,¸T
8ÿ
$¹T
'½T
¿T
,ÀT
ÁT
ÅT
,ÂT
8™ÃT
$ÄT
ÆT
8ñC4ÈT
ÎT
'ÏT
8©\ÑT
ÜT
âT
8ã,ÝT
 ãT
8†
<äT
ëT
„U
8×,ìT
'ñT
8à
óT
'õT
8”,÷T
'üT
8‰	4þT
%µU
„èüËUR Types to help compose fixed-size [`ULE`] and variable-size [`VarULE`] primitives.Á¡Ëü¥]Z This module exports [`VarTuple`] and [`VarTupleULE`], which allow a single sized type andÁüƒ@= a single unsized type to be stored together as a [`VarULE`].ÁÄËtÈá ×Ë<Ûæ¡üã85 use zerovec::ule::vartuple::{VarTuple, VarTupleULE};ÁäœÇ—¹ËÌ½ struct Employee<'a> {Á„×
     id: u32,Á´è     name: &'a str,Á4ÿÄ§†Ë¬Š let employees = [Á”      Employee {Á´³         id: 12345,ÁìÊ         name: "Jane Doe",ÁTè     },Á”óØé
´†         id: 67890,Áì�         name: "John Doe",ÁT»µê
4ÆÕžÍËüÑ+( let employees_as_var_tuples = employeesÁ¤ý     .into_iter()ÁÜ’     .map(|x| VarTuple {ÁÄ®         sized: x.id,ÁìÇ         variable: x.name,ÁTåà’ìðò’ŽËü’:7 let employees_vzv: VarZeroVec<VarTupleULE<u32, str>> =ÁüÍ2/     employees_as_var_tuples.as_slice().into();Á€	Ëü„	'$ assert_eq!(employees_vzv.len(), 2);Á¬	Ëü°	MJ assert_eq!(employees_vzv.get(0).unwrap().sized.as_unsigned_int(), 12345);Áüþ	DA assert_eq!(&employees_vzv.get(0).unwrap().variable, "Jane Doe");ÁÃ
ËüÇ
MJ assert_eq!(employees_vzv.get(1).unwrap().sized.as_unsigned_int(), 67890);Áü•DA assert_eq!(&employees_vzv.get(1).unwrap().variable, "John Doe");Á<Úæ¡FŽ®é<ó˜•—transmute_copyÁtü¹•˜îØD›
•™îØ5•™ÀY,²É•›Ü?t¹•œµ¶¬DÉÊ•�³Z4ÓÓ•ž³Z¸•žÙâ>ÛÄ•Ÿâ>·•ŸØüç$äæ”‘Öüª5µ·¤¦Ž�}TVü¸dÓ!¡±¢¢¡©âæñÄ‡äÇÉæñ,ôæñ<üØè4ŒÖ�£¤ÔÖ£¤IKNPü£7t¦€€—ãºê ¼ 
£æñ¡Çã,µüò5¤ü��—ã�Ö� ˜ 
¤æñ¡Çã,‘ü–,™Ó!¦¦W§±¨¦§¨’õ
¢,©âìñ¥,”ˆ¨,«õ
,í,»õ
<õ,ìñèÈŒ…-¥ˆ4Ÿ-ÇŒ©¬¯²µ©¬npjloqü¶-IÄ¹-‚‚ÇŒò¡
÷¡
¥šª¢«ª«Õ-¥°¢
Ò-Á¢
Ôß-ƒ„™ ò¡
ƒ
„—ã¬ä-ƒ„ò¡
µú
› ÷¡
ø-
©æñìñèÈ÷¡
ò¡
$Ö-Ü-‰‹Ž�üê.%”í.……ÇŒ¥€/¥
¬æñìñèÈ$�/üì/.¤ï/†‡†ÇŒ‡—ã¥„0¥
æñìñèÈ$…0·…‹0üÊ4’¨¯Ó!°¦W±±²²°¯±ÈÕÓ4©â¡üÖ4ªâ¨�Ù4É›ü,œ5›ü<¤5Ó¨�4´5
¡ü¨¨�|Ì5¬�³
³Ï4~€z|vxüã52Læ5¨ï�¬�®®
³¨›ü¡ü¨�î,ð5t‚FG´ÚŒF¬ú]Gü™2£F£FtGtGºFºFüÕ!ÑFÑFèFèF”€¢Gä™‰�|€osbf¤¦ü¸[X Fixed-width, byte-aligned data that can be cast to and from a little-endian byte slice.Á”	Ëü˜	[X If you need to implement this trait, consider using [`#[make_ule]`](crate::make_ule) orÁüô	+(  [`#[derive(ULE)]`](macro@ULE) instead.Á 
Ëü¤
DA Types that are not fixed-width can implement [`VarULE`] instead.Áé
Ëüí
.+ "ULE" stands for "Unaligned little-endian"ÁœËd âêËü± Safety checklist for `ULE`:ÁÑËüÕFC 1. The type *must not* include any uninitialized or padding bytes.Áüœ[X 2. The type must have an alignment of 1 byte, or it is a ZST that is safe to construct.Áüø[X 3. The impl of [`ULE::validate_bytes()`] *must* return an error if the given byte sliceÁüÔ
63    would not represent a valid slice of this type.Áü‹[X 4. The impl of [`ULE::validate_bytes()`] *must* return an error if the given byte sliceÁüç_\    cannot be used in its entirety (if its length is not a multiple of `size_of::<Self>()`).ÁüÇa^ 5. All other methods *must* be left with their default impl, or else implemented according toÁü©*'    their respective safety guidelines.ÁüÔC@ 6. Acknowledge the following note about the equality invariant.Á˜Ëüœqn If the ULE type is a struct only containing other ULE types (or other types which satisfy invariants 1 and 2,ÁüŽkh like `[u8; N]`), invariants 1 and 2 can be achieved via `#[repr(C, packed)]` or `#[repr(transparent)]`.ÁúËÄþ # Equality invariantÁ—Ëü›_\ A non-safety invariant is that if `Self` implements `PartialEq`, the it *must* be logicallyÁüû>; equivalent to byte equality on [`Self::slice_as_bytes()`].ÁºËü¾_\ It may be necessary to introduce a "canonical form" of the ULE if logical equality does notÁüžZW equal byte equality. In such a case, [`Self::validate_bytes()`] should return an errorÁüù`] for any values that are not in canonical form. For example, the decimal strings "1.23e4" andÁüÚb_ "12.3e3" are logically equal, but not byte-for-byte equal, so we could define a canonical formÁü½41 where only a single digit is allowed before `.`.ÁòËüö]Z Failure to follow this invariant will cause surprising behavior in `PartialEq`, which mayÁüÔQN result in unpredictable operations on `ZeroVec`, `VarZeroVec`, and `ZeroMap`.Á-FÄÄ÷™ü¦³¸•,ËþÀ•$ÜÊ•<ãÄ÷™:¸•6¢”,Ê•*÷™R¸•N¢”DÊ•BÅÆÇÈÅÆÇÈÈÆÇÅü©8üò$! Validates a byte slice, `&[u8]`.Á›Ëü£]Z If `Self` is not well-defined for all possible bit values, the bytes should be validated.Áü…^[ If the bytes can be transmuted, *in their entirety*, to a valid slice of `Self`, then `Ok`Áüè<9 should be returned; otherwise, `Err` should be returned.Át¬ˆˆ—ãºêÄÂÄ
ÅÀ•ã,»ü¹!BüçTQ Parses a byte slice, `&[u8]`, and return it as `&[Self]` with the same lifetime.ÁÀËüÈ]Z If `Self` is not well-defined for all possible bit values, the bytes should be validated,ÁüªTQ and an error should be returned in the same cases as [`Self::validate_bytes()`].ÁƒËü‹NK The default implementation executes [`Self::validate_bytes()`] followed byÁüÞ)& [`Self::slice_from_bytes_unchecked`].ÁŒ Ëü” ZW Note: The following equality should hold: `bytes.len() % size_of::<Self>() == 0`. ThisÁüó A> means that the returned slice can span the entire byte slice.Á¤¼!‰‰—ãê³í³î³Òï³ìð³ñ³“ò³ìäs{©¶‘‰
À•À�ÄØ!Ä
ÆÀ•ã,Ñ!üÛ+=ü±#\Y Takes a byte slice, `&[u8]`, and return it as `&[Self]` with the same lifetime, assumingÁü’$^[ that this byte slice has previously been run through [`Self::parse_bytes_to_slice()`] withÁdõ$	 success.Á†%ËüŽ%TQ The default implementation performs a pointer cast to the same region of memory.Áç%Ëdï%âê€&Ëtˆ& ## CallersÁ›&Ëü£&^[ Callers of this method must take care to ensure that `bytes` was previously passed throughÁü†'MJ [`Self::validate_bytes()`] with success (and was not changed since then).ÁØ'Ëœà' ## ImplementorsÁø'Ëü€(_\ Implementations of this method may call unsafe functions to cast the pointer to the correctÁüä(1. type, assuming the "Callers" invariant above.Áš)Ëü¢)GD Keep in mind that `&[Self]` and `&[u8]` may have different lengths.Áî)Ë¬ö) Safety checklist:Á�*Ëü˜*UR 1. This method *must* return the same result as [`Self::parse_bytes_to_slice()`].Áüò*VS 2. This method *must* return a slice to the same region of memory as the argument.ÁÔå+ŠŠ—ãŠÂžÄ‡,Ä
ÇÀ•ã,€,üª1*ü‚.>; Given `&[Self]`, returns a `&[u8]` with the same lifetime.ÁÅ.ËüÍ.TìŸ¦/Ëd®/âê¿/ËüÇ/WT Implementations of this method should call potentially unsafe functions to cast theÁü£0  pointer to the correct type.ÁÈ0ËüÐ0G§¤t1‹‹Âž‹—ãÄÃ1Ä
ÈÀ•î,¼1¬�4üÛ2[X A trait for any type that has a 1:1 mapping with an unaligned little-endian (ULE) type.Á·3Ëü»3a^ If you need to implement this trait, consider using [`#[make_ule]`](crate::make_ule) instead.Á@FÉÉ÷™ü�4	¢”$®4É÷™"¢”÷™.¢”*ÊËÌÊËÌ©âÀ•Êt‚7Ä�®Œ7…®�®ÌËl‚7ü¹4)& The ULE type corresponding to `Self`.Áç4Ëüï4TQ Types having infallible conversions from all bit values (Plain Old Data) can useÁüÈ5SP `RawBytesULE` with the desired width; for example, `u32` uses `RawBytesULE<4>`.Á 6Ëü¨6UR Types that are not well-defined for all bit values should implement a custom ULE.Á‡7ÉÉü€9#ü–7(% Converts from `Self` to `Self::ULE`.ÁÃ7ËüË7SP This function may involve byte order swapping (native-endian to little-endian).Á£8Ëü«8PM For best performance, mark your implementation of this function `#[inline]`.Ádƒ9À•�®ÉÉ
ËÀ•$�9ü˜=0ü©9(% Converts from `Self::ULE` to `Self`.ÁÖ9ËüÞ9SP This function may involve byte order swapping (little-endian to native-endian).Á¶:Ëü¾:Pë±“;Ëd›;âê¬;Ëü´;\Y This function is infallible because bit validation should have occurred when `Self::ULE`Áü•<\Y was first constructed. An implementation may therefore involve an `unsafe{}` block, likeÁìö< `from_bytes_unchecked()`.Át›=�®À•ÉÉ
ÌÀ•çë	Lª=ìÍAüÌ=JG A type whose byte sequence equals the byte sequence of its ULE type onÁä—> little-endian platforms.Á´>Ëü¸>;8 This enables certain performance optimizations, such asÁüô>@= [`ZeroVec::try_from_slice`](crate::ZeroVec::try_from_slice).Áµ?ËÜ¹? # Implementation safetyÁÕ?ËüÙ?^[ This trait is safe to implement if the type's ULE (as defined by `impl `[`AsULE`]` for T`)Áü¸@]Z has an equal byte sequence as the type itself on little-endian platforms; i.e., one whereÁü–A63 `*const T` can be cast to a valid `*const T::ULE`.ÁSFÍÍ÷™üÍA ÉÀ•,åAÍ÷™)ƒ½÷™5ƒ½*¤úBüïALI A trait for a type where aligned slices can be cast to unaligned slices.Á¼BËüÀB96 Auto-implemented on all
�®ÎôDÎ
ÏÀ•î,íDüºE,»›EžE·E8ËlŸEE7littleÁD¯Eü™E ™ÑÑ½ð¿E½—,àE³ÑÒÏÒüûE=”þE��ƒÙø°ú°û°Ðü°ý°�þ°ìH�ËˆXêE>�ÀÉÐ˜FÐ
Ò³Ñî,‘FüÌd üÿJ^[ Variable-width, byte-aligned data that can be cast to and from a little-endian byte slice.ÁÞKËüâKa^ If you need to implement this trait, consider using [`#[make_varule]`](crate::make_varule) orÁüÄL1.  [`#[derive(VarULE)]`](macro@VarULE) instead.ÁöLËüúLfc This trait is mostly for unsized types like `str` and `[T]`. It can be implemented on sized types;ÁüáMgd however, it is much more preferable to use [`ULE`] for that purpose. The [`custom`] module containsÁüÉNQN additional documentation on how this type can be implemented on custom types.Á›OËüŸOa^ If deserialization with `VarZeroVec` is desired is recommended to implement `Deserialize` forÁü�PDA `Box<T>` (serde does not do this automatically for unsized `T`).ÁÆPËüÊPpm For convenience it is typically desired to implement [`EncodeAsVarULE`] and [`ZeroFrom`](zerofrom::ZeroFrom)Áü»QVS on some stack type to convert to and from the ULE type efficiently when necessary.Á’RËd–Râê£RËü§R" Safety checklist for `VarULE`:ÁÊRËüÎRFáƒü•S1. 2. The type must have an alignment of 1 byte.ÁüÇS^[ 3. The impl of [`VarULE::validate_bytes()`] *must* return an error if the given byte sliceÁü¦T6ø…üÝT^[ 4. The impl of [`VarULE::validate_bytes()`] *must* return an error if the given byte sliceÁü¼U&#    cannot be used in its entirety.ÁüãUZW 5. The impl of [`VarULE::from_bytes_unchecked()`] must produce a reference to the sameÁü¾VRO    underlying data assuming that the given bytes previously passed validation.Áü‘Wa^ 6. All other methods *must* be left with their default impl, or else implemented according toÁüóW*íˆüžXC@ 7. Acknowledge the following note about the equality invariant.ÁâXËüæXxu If the ULE type is a struct only containing other ULE/VarULE types (or other types which satisfy invariants 1 and 2,ÁüßYkñŠËZËÄÏZï‹èZËüìZ_›ŒüÌ[85 equivalent to byte equality on [`Self::as_bytes()`].Á…\Ëü‰\_Õ�üé\Z½ŽüÄ]` �ü¥^b‰�üˆ_4ô�½_ËüÁ_\Y There may also be cases where a `VarULE` has muiltiple canonical forms, such as a fasterÁüž``] version and a smaller version. The cleanest way to handle this case would be separate types.Áüÿ`\Y However, if this is not feasible, then the application should ensure that the data it isÁüÜa[X deserializing is in the expected form. For example, if the data is being loaded from anÁü¸b_\ external source, then requests could carry information about the expected form of the data.Á˜cËüœc]¼‘üúcQ¢’yFÓÓ÷™üÌdÊ•<ådÓ÷™"Ê•÷™.Ê•*ÔÕÖ×ÔÕÖ×Õ×ÖÔüªg9üód$”œeËü¤e]å”ü†f]Z If the bytes can be transmuted, *in their entirety*, to a valid `&Self`, then `Ok` shouldÁüèf=: be returned; otherwise, `Self::Error` should be returned.ÁtgŽŽ—ãºêÓÄgÓ
ÔÀ•¸ø4¼güøl7üégRO Parses a byte slice, `&[u8]`, and return it as `&Self` with the same lifetime.ÁÀhËüÈh]º˜üªiT ™ƒjËü‹jNˆšüÞj#  [`Self::from_bytes_unchecked`].Á†kËüŽkZW Note: The following equality should hold: `size_of_val(result) == size_of_val(bytes)`,Áüík[X where `result` is the successful return value of the method. This means that the returnÁüÍl&# value spans the entire byte slice.Á\ûl��—ãê³í³î³Òï³ìð³ñ³“ò³ìäs{©¶‘
‚Õâé÷‡êâê�ôE†âãæUF‹âã²VF•âãÜ?ŒFâãµŽG£F™âã¸ÆGºF�âãºûJÑF×âã¼ÞLèFöâã½â>-FÄâãÀY@FÉâãåYSFÍâãòYfFÎâã³ZyFÓâãâ>ÿF·âãØ³ZG¸âãÙcartable_ptrÁeÚâëeitherÁ5ð2âëYokeableÁEÍÀâëÚñ(âë
CloneableCartÁmîÔâëYokeÁ%ýŽâë¶¬2GÊâã´iFGÆ
âã´åj]Gà
âã¶ûktGô
âã¹ûktGõ
âã¹ên¢G©âã¾ên¢Gªâã¾Tÿü’(GJ58	„ûúýëî$‘üÀHüçXU This impl requires enabling the optional `yoke` Cargo feature of the `zerovec` crateÁ¨í™îíîñ½Ð§¤
<Ó‚¾,Ýî‘ïðñòóÂÃÄÅÆñðòóÌQS\�4”ììÄÙü¿*LÂ¨î‘¨î‘¨Âìì
ð¨ýÎ$Ðü‘	(|”	î‘ß÷ìì
ñ¨ýÎ$¤	üá	*$ë	ß÷î‘ìì
ò¨ýÎï$ð	ü†ll‰¨î‘ƒÏìðôôìó¨—ƒÏ<Ãõ™ ƒÏõß÷üÍ$õƒÏ¦ú› äÕ
ó¨ýÎƒÏ$¢þ¨rtÑüòUü™X¶ô¨÷™øø÷â¨‚§¤
<…Ï«4�Æ’ùúûüýÂÃÄÅÆüúûýþQS\Î4ÓööààáÔ*åì6
ä>(ùOè¨ýÎÏÊü�*L„¨Æ’¨Æ’¨Âöö
ú¨ýÎ$’üÓ(|ÖÆ’©ýöö
û¨ýÎ$æü£*$©ýÆ’öö
ü¨ýÎï$²üÈllË¨Æ’ƒÏöðþþöó¨Ù‹ú<…ÿ™ ƒÏÿ©ýü�$ÿƒÏíÿ› ä—
ý¨ýÎƒÏ$äþêoq“ü´LüÛX¶ô¨�	™‚	�	‚	â¨Ä§¤
<Ç�“ƒ	„	…	†	‡	ÂÃÄÅÆ‡	…	„	†	ÀIK\‡4Œ€	€	

—@¿#à›6¢¨ýÎüº*L½¨�“¨�“¨Â€	€	
„	¨ýÎ$ËüŒ(|��“æ‚€	€	
…	¨ýÎ$ŸüÜ*$ææ‚�“€	€	
†	¨ýÎï$ëü�ll„¨�“ƒÏ€	ðˆ	ˆ	€	ó¨’‹ú<¾‰	™ ƒÏ‰	æ‚üÈ$‰	ƒÏª…› äÐ
‡	¨ýÎƒÏ$�þ£oqÌ”ûNtÿNù„¤aŠ	Œ	Ã	»Ý%dÂ‘Š	Ž	¯	Ô*TÐàŠ	�	°	Ô*áŠ	�	°	æLÜÂŠ	�	²	žŽ<çªŠ	‘	³	îØDº
Š	’	îØ5Š	’	�ôE†Š	‹	æUF‹Š	‹	²VF•Š	‹	Ü?ŒFŠ	‹	µŽG£F™Š	‹	¸ÆGºF�Š	‹	ºûJÑF×Š	‹	¼ÞLèFöŠ	‹	½â>-FÄŠ	‹	ÀY@FÉŠ	‹	åYSFÍŠ	‹	òYfFÎŠ	‹	³ZyFÓŠ	‹	â>ÿF·Š	‹	Ø³ZG¸Š	‹	Ù¶¬2GÊŠ	‹	´iFGÆ
Š	‹	´åj]Gà
Š	‹	¶ûktGô
Š	‹	¹ûktGõ
Š	‹	¹ên¢G©Š	‹	¾ên¢GªŠ	‹	¾T„ì—Ôüº5ÀÃ°�„jm”°ZüÅ\½^”	8•™•	”	••	è„	ÏÕ<‘ù„	,›Ñ“–	
–	Ê+-ü¶0L¹–½^ªªŽ¨½®¿½¯°7½Ê˜!ÚÆdG
–ÕÑ““	×“	
–	½^8Õî,Ãü¦Z½^˜	™™	™	˜	ñ½°§¤
<ð‚¾,ú°”š	
š	«(*ü•.L˜�•°”—	—	
š	½^ýÎî,¢üƒ\½^œ	™�	œ	�	ñ½�§¤
<Ï‚¾,Ù�•ž	
ž	ˆ(*üô.L÷�•�•›	›	
ž	½^ýÎî,�ü¼…½^ 	™¡	ð¢	 	¡	¢	â¨Æó¨Éç®„Ì§¤
<§	Ï«4±	ª•£	
£	Á8:=?üÖ	4LÙ	½^˜Ôª•Ÿ	Ÿ	
£	½^ýÎƒÏî,ã	ü«
‡½^¥	8—™¦	ð§	¦	—§	¥	’Ìµ
£Ì¸
ØÌ„»
ÙŒ<˜´Ì4¢ø•¨	
¨	°
8:=?üÇ6LÊ˜½^ààáÔ*åì6
ä>(ùOè˜Õ³Õø•¤	ë¤	
¨	½^8Õ³Õî,Ôü©l½^ª	™«	ª	«	â¨³§¤
<ûÏ«4…
ÿ–¬	
¬	®(*üª
1L
ÿ–ÿ–©	©	
¬	½^ýÎî,·
´˜O‚üõP9œ‰Q“|žQ¥ü¸Q$ËËááüûQ#¡áQäQëQ8°4åQtßQÜƒRîØD·R
µ	îØ5µ	”R#dÐ\üã\B? This module contains additional utility types for working withÁüª][X [`ZeroVec`] and  [`VarZeroVec`]. See their docs for more details on the general purposeÁœŠ^ of these types.Á¢^Ëüª^VS [`ZeroSlice`] and [`VarZeroSlice`] provide slice-like versions of the vector typesÁü…_63 for use behind references and in custom ULE types.ÁÀ_ËüÈ_VS [`VarZeroVecOwned`] is a special owned/mutable version of [`VarZeroVec`], allowingÁü£`.+ direct manipulation of the backing buffer.Á$Ø\Ä	Ç	Ê	Ì	æL†aÂ¸	žŽ<‘aª¹	åhl¸a½
º	ŸÝ%dþa‘¼	³¯	Ô*TŒbà½	´°	Ô*á½	´°	�c<ˆcä	¿	·�cå	¿	·ˆd<‘cø	À	¸ˆdù	À	¸“b4šcÐ	Á	¹“bÑ	Á	¹‡f„¢c™
Â	ºù„´caÃ	»üõ`$?B/2ì¨a'üêa-üôbQÚÜ²´ŠŒbdPRäÌcdÕc¨Å	™Æ	Æ	Å	ñ½æc¼üâc
ä‹dd”d¨È	™É	È	É	ñ½¥dààáÔ*åì6
ä>(ùOè¨ýÎçË¡dGIÔÊdtÓd™Ë	Ë	½ðâd‘‘Ý%”‡
�•‰&�Ž6Òß�ñ’K³ÑÏÊDFÔ…etŽe™Í	Í	½ð�e‘‘Ý%”‡
�•‰&�Ž6Òß�ñ’K³ÑçËDFÄº|ûÜ„¤Œ™üÚ]Z This is a [`VarZeroVecFormat`] that stores u8s in the index array, and a u8 for a length.Á¸Ëü¼PM Will have a smaller data size, but it's *extremely* likely for larger arraysÁü�NK to be unrepresentable (and error on construction). Should probably be usedÁüÜIF for known-small arrays, where all but the last field are known-small.Á4¤·ÉaŠQ9æà�õÑ	Ÿ)Ð	Ð	·É ¯a·É(	µ¡
8°#b·É37b·ÉÕ	ßÕ	RT™™·É·ÉÔ		µÔ	
Õ	,µ(
¼c·É×	á`×	"$š›œš·É›Á`Á`œÃ`èÁ]Ä`áÁ]Ê\É:•œ˜ùÖ	
¼Ö	
×	,¼þË Ãd·ÉÙ	¼bÙ	"$�ž�·ÉžµØ	µÚ	Ú	ÃØ	©âªª–Ãbªª¤
Ù	ªª$Ã�º¼¾HÉe·Ée·ÉÝ	 Ý	68Ÿ Ÿ·É ·ÉÜ	ÉÜ	
Ý	LÉîš
Ôf·Éß	¤ß	"¡)+.08°:>@¡¡·ÉÞ	
ÔÞ	
ß	ÔPØg·Éá	Ëá	"$¢£¢·É£·Éþà	Øà	
á	TØîˆäh·Éã	Äã	"$¤¥¤·É¥·Éñþâ	äâ	
ã	äîˆ”àü_\ This is a [`VarZeroVecFormat`] that stores u16s in the index array, and a u16 for a length.Á�Ëü‘IF Will have a smaller data size, but it's more likely for larger arraysÁüÛ52 to be unrepresentable (and error on construction)Á‘Ëü•WT This is the default index size used by all [`VarZeroVec`](super::VarZeroVec) types.Á<ëÏÊÁÀ;A®Î)å	š)ä	ä	ÏÊ öiÏÊ(ü¡
8°#jÏÊ37jÏÊé	ßé	RT¦¦ÏÊÏÊè	üè	
é	,ü(ƒkÏÊë	á`ë	"$§¨©§ÏÊ¨Á`Á`œÃ`èÁ]Ä`áÁ]Ê\É:•©˜ùê	ƒê	
ë	,ƒþË ŠlÏÊí	¼bí	"$ª«ªÏÊ«ªªì	µî	î	Šì	Øª‹çª‘
í	ªª$Š�§©«H�mÏÊmÏÊñ	 ñ	68¬¬ÏÊÏÊð	�ð	
ñ	L�îš›nÏÊó	¤ó	"¡)+.08°:>@®®ÏÊò	›ò	
ó	›PŸoÏÊõ	Ëõ	"$¯°¯ÏÊ°ÏÊþô	Ÿô	
õ	TŸîˆ«pÏÊ÷	Ä÷	"$±²±ÏÊ²ÏÊñþö	«ö	
÷	«îˆ”žüõ_\ This is a [`VarZeroVecFormat`] that stores u32s in the index array, and a u32 for a length.ÁüÕGD Will have a larger data size, but will support large arrays withoutÁl�
 problems.Á<©çË–·>è{z.;ù	ù(ø	ø	çË ´qçË(º¡
8°#rçË37rçËý	ßý	RT³³çËçËü	ºü	
ý	,º(ÁsçËÿ	á`ÿ	"$´µ¶´çËµÁ`Á`œÃ`èÁ]Ä`áÁ]Ê\É:•¶˜ùþ	Áþ	
ÿ	,ÁþË ÈtçË�
¼b�
"$·¸·çË¸ªª€
µ‚
‚
È€
Øª‹çª‘
�
ªª$È�§©«HÎuçËuçË…
 …
68¹º¹çËºçË„
Î„

…
LÎîšÙvçË‡
¤‡
"¡)+.08°:>@»»çË†
Ù†

‡
ÙPÝwçË‰
Ë‰
"$¼½¼çË½çËþˆ
Ýˆ

‰
TÝîˆéxçË‹
Ä‹
"$¾¿¾çË¿çËñþŠ
éŠ

‹
éîˆü©11¤´1¨�
™Ž
ð�
�
Ž
�
â¨Í1ó¨Ø1€®ü–4ªÎ2fm?Ž~��
‘
’
“
É1:<?AD€2€2YŒ
Œ
Œ½3<½3YŒ
Œ
úé„€44€4YŒ
Œ
úé”4–4YŒ
Œ
‰‰ŠÁ¯Ñ{·Ë…YÚÁ·ƒÏ( ¡1y¨•
™–
ð—
•
–
—
â¨*ó¨)ì´Pà`ƒÏ^ªÎ˜
á`˜
#&]`dg“•ÀÁÂÀªÎÁÁ`Á`œÃ`èÁ]Ä`áÁ]Ê\É:•Â˜ù”
 ¡1”

˜
¨ýÎƒÏ,¡1þMü¦“7üó’! An iterator over VarZeroSliceÁ	„±“¨š
™›
ðœ
œ
š
›
â¨Æ“ó¨\Ñ“€®±Ï€�Š5½Uf�
ž
Ÿ
Â“9;=Ñ“ÏÊüä“*Tä“Y™
™
ªÎd””,””Y™
™
”½–\½–Y™
™
(&ž“|¨¡
™¢
ð£
¡
¢
£
â¨òó¨°ì´O«ÊU±Ï¤
á`¤
ãåàâ†ˆÃÄÅÃ±ÏÄÁ`Á`œÃ`èÁ]Ä`áÁ]Ê\É:•Å˜ù 
&ž“ 

¤
¨ýÎƒÏ,ž“þBôõ¬þžÐßzþáJÇ¦
§
¨
©
§
©
ª
À�žÐDä¥
¥
žÐ¥
¥
žÐúú¥
¥

©
úúÀ�žÐ¥
¥
±Ò¤©¥
¥
À�(4í�žÐ¬
á`¬
#%ÆÇÈÆžÐÇÁ`Á`œÃ`èÁ]Ä`áÁ]Ê\É:•È˜ù«
4í«

¬
,íþÌüÝ6
´ï
™®
ð¯
¯
®
¶Õ†
»ê‘
úÐ(£Tªt_°
±
'),.Üš
4š
î

�”¤
d¤
î

—ãH9Í
„™³
ð´
´
³
¶Õ¯»êúÐ»½ÀÂ\`„™¶
ð·
·
¶
¶Õ»êØð�ž¹Ñ¹Ñ¯úÐ¸
 ¸
9<@CÞàÉÊÉúÐÊúÐµ
9Í
µ

¸
³Ñ¹ÑLÍ
îL:Ø
…™º
ð»
»
º
¶Õþ»êýãòD£¹ÑRúÐ¼
¤¼
+.25�¡ˆŠ��8°™�ŸËËúÐ¹
:Ø
¹

¼
³Ñ¹ÑØ
jûüÞe-* An iterator over elements in a VarZeroVecÁl¨f¨¿
™À
À
¿
ñ½ºf‚¾,½fÀõ§^Æ×žóP¾7Šyô¾
Á
ÙiÙiã÷Üi÷®iÝiü÷®iÞi’ø®it¸%ýN(¨ÔÚÆ×jû¼¾çÛÆ×½
½

¾
¨ýÎ¶fÖØìÄf¾½
½
çÛ(@•fˆ¨Ã
™Ä
Ã
Ä
ñ½1ì´;‚¾6à`ÔÚPÆ×Å
á`Å
Ž�betvÌÍÎÌÆ×ÍÁ`Á`œÃ`èÁ]Ä`áÁ]Ê\É:•Î˜ùÂ
@•fÂ

Å
¨ýÎ,•fþ)NüüƒMJ A u8 array of little-endian data corresponding to a Unicode scalar value.ÁÑËüÕ^[ The bytes of a `CharULE` are guaranteed to represent a little-endian-encoded u32 that is aÁü´96 valid `char` and can be converted without validation.ÁîËtòá �Ëü…30 Convert a `char` to a `CharULE` and back again:Á¹Ë<½æ¡üÅ,) use zerovec::ule::{AsULE, CharULE, ULE};ÁòË¤ö let c1 = 'ð‘„ƒ';Áü‹  let ule = c1.to_unaligned();Áü¬EB assert_eq!(CharULE::slice_as_bytes(&[ule]), &[0x03, 0x11, 0x01]);Áüò'$ let c2 = char::from_unaligned(ule);Á¼š assert_eq!(c1, c2);Á<²æ¡ºËü¾2/ Attempt to parse invalid bytes to a `CharULE`:ÁñË<õæ¡üý%" use zerovec::ule::{CharULE, ULE};Á£Ëü§1. let bytes: &[u8] = &[0xFF, 0xFF, 0xFF, 0xFF];ÁüÙEB CharULE::parse_bytes_to_slice(bytes).expect_err("Invalid bytes");Á<Ÿ	æ¡<ú	üÞfð°m8â›ÆÇ
È
§øüÞNü6’§øüÞÆ
Æ

Ç
<‚
’Æ
Æ
§ø‡
(IÅ	�üÞË
á`Ë
#%ÏÐÑÏüÞÐÁ`Á`œÃ`èÁ]Ä`áÁ]Ê\É:•Ñ˜ùÊ
IÅ	Ê

Ë
,Å	þÌHJÌ	ŽüÞŽüÞÎ
 Î
8:ÒÓÒüÞÓüÞÍ
JÌ	Í

Î
LÌ	îœK×	�üÞÐ
¤Ð
#¡*,/18°;?AÔÔüÞÏ
K×	Ï

Ð
×		(LÛ	¡
8°#�üÞ48�üÞÔ
ßÔ
TVÕÕüÞüÞÓ
LÛ	Ó

Ô
,Û	» Mâ	‘üÞ Nè	’üÞØ
¼bØ
#%Ö×ÖüÞ×ªª×
µÙ
Ù
Nè	×
ØªŒçª’
Ø
ªª$è	�¨ª¬øPõH¡PûPÿ4Convert an array of `char` to an array of `CharULE`.ÁñîøS�jøPùsPP‚ÝÿÌÿ—ÍÛ
Û
—“ÐpP�
Ú
Í€€e¿P“…Ú
Ú
œüüÎKH This type is used by the custom derive to represent multiple [`VarULE`]ÁüšJG fields packed into a single end-of-struct field. It is not recommendedÁüåda to use this type directly, use [`Tuple2VarULE`](crate::ule::tuplevar::Tuple2VarULE) etc instead.ÁÊËüÎ-* Logically, consider it to be `(, , , ..)`Áüü<9 where `` etc are potentially different [`VarULE`] types.Á¹Ëü½LI Internally, it is represented by a VarZeroSlice without the length part.Á&tÃæCâ
ñCã
ã
â
öÍ
„Ò„Î
4ä•Î
„ìýá¹ƒ}@e`ýÄá
ä
ÜúýáœünçÜúýáà
à

á
æC´â�Ø�ƒüƒ$çà
à
ÜúHj“¢æCæ
ñCç
æ
ç
öÍ
€jÒ„Î
ç•Î
åýázùû]a¢æCê
ñCë
ë
ê
öÍ
Z„Î
>ž´â´â¨•Î
Oýáí
 í
‹ðorÕ×ØÙØýáÙýáé
j“é

í
æC´âL“îEkž£æCð
ñCñ
ð
ñ
öÍ
€kÒ„Î
/£´âM•Î
<ýáó
¤ó
0Ý]`{¡‚„‡‰8°“—™ÚÚýáï
kžï

ó
æC´âžýü§-B	? Optional type which uses [`NichedOptionULE<U,N>`] as ULE type.Áê-	Ëüî-G	D The implementors guarantee that `N == core::mem::size_of::<Self>()`Áü¶.N	K `#[repr(transparent)]` guarantees that the layout is same as [`Option<U>`]Á,dæ0	¨8ö
Í÷
÷
ö
àúó0	Ì”tö0	´ä&Ð†
¸‰ôPõ
ø
¿ü´äýf¿ü´äô
ô

õ
æãÍwy|ü0	l†1	ô
ô
¿ü(}Ž/	¬¨8ú
Íû
û
ú
àúÙÌ”p}ö0	·ü
D´äý
á`ý
ùû'‚hjÛÜÝÛ´äÜÁ`Á`œÃ`èÁ]Ä`áÁ]Ê\É:•Ý˜ùù
}Ž/	ù

ý
æãÍ,Ž/	þ ~•/	¨8ÿ
Í€ÿ
€àúùÌ”p~ö0	®¤E´äš(›/	®¨8ƒÍ„ƒ„àúZÌ”pö0	ÞæãM´ä†ß†ƒ†1tvÞÞ´ä´ä‚›/	‚
†æãÍ,›/	H€¢/	¯¨8‰ÍŠ‰Šàú+Ì”p€ö0	´ä<?Ç]a¯¨8�ÍŽŽ�àú„Ì”Yç…œ´ä� �¢¥-ÃÅßàß´äà´äŒ€¢/	Œ
�æãÍL¢/	î4�/	°¨8“Í”“”àúbÌ”p�ö0	ã‡G´ä–¤–„‡*n¡uwz|8°†ŠŒáá´ä’�/	’
–æãÍ/	 ‚±/	±¨8˜Í™™˜àúHÌ”p‚ö0	»bæãO´ä›¼b›ru2ývxâãâ´äãµ—µœœ‚±/	—©âÇ‰íÃbÇ‰û
›æãÍÇ‰$±/	�!Pƒ·/	²¨8žÍŸžŸàúuÌ”pƒö0	ŒÆG´ä¡Ë¡—š*"npäåä´äå´äþ�ƒ·/	�
¡æãÍT·/	îá„Ã/	³¨8¤Í¥¥¤àúXÌ”p„ö0	ÝÇG´ä§Ä§z}*npæçæ´äç´äñþ£„Ã/	£
§æãÍÃ/	îáRÿü®SP A u8 array of little-endian data with infallible conversions to and from &[u8].Á0\–Í««“Ðt¢ëéÖ±ËúÇÒOUª¬¡ëëéRÿN¡ëëé©©
ªÍj¨\²©©¡ë(” ½Í¯¯“Ðp”¢ëé±á`±\BDèéêèëééÁ`Á`œÃ`èÁ]Ä`áÁ]Ê\É:•ê˜ù®” ®
±Í, þóH•§¾Í³³“Ðp•¢ëé
F8<¾Í¶¶“Ð4ëé¸ ¸E�suëìëëéìëéµ•§µ
¸ÍL§îß–²¿Í»»“Ðp–¢ëé½¤½2C¡JLOQ8°[_aííëéº–²º
½Í²(—¶¡
8° $ÀÍÀÀ“Ðp—¢ëé
ùTXÀÍÃÃ“Ð4ëéÅßÅE4�‘îîëéëéÂ—¶Â
ÅÍ,¶ ˜½ÁÍÉÉ“Ðp˜¢ëé
ÄP™ÃÂÍÌÌ“Ðp™¢ëéÎËÎCEïðïëéðëéþË™ÃË
ÎÍTÃî±šÏÃÍÑÑ“Ðpš¢ëéÓÄÓºCEñòñëéòëéñþÐšÏÐ
ÓÍÏî± ›ÔÄÍÖÖ“Ðp›¢ëéØ¼bØmCEóôóëéôµÕµÙÙ›ÔÕ©â¢›¹Ãb¢›Ç
ØÍ¢›$Ô�ãåç¸œõ1¥ÍÜÝÞ—+øœè*¡œ�œ¡~Gets this `RawBytesULE` as a `u16`. This is equivalent to calling [`AsULE::from_unaligned()`] on the appropriately sized type.ÁÞ›øž£¡øœ›ªxœïõõ¥ÍÚœÿÚ
Ü œ€øœÅ3¡œûœÿ}Converts a `u16` to a `RawBytesULE`. This is equivalent to calling [`AsULE::to_unaligned()`] on the appropriately sized type.Áæ�ø � øœù©`œÒ¥ÍÚÚ¬‡˜QÁø¢õH¡¢û¢ÿ=Convert an array of `u16` to an array of `RawBytesULE < 2 >`.ÁÖŸø¥�jø¢ùsP¢‚÷ŠåŠÚÍßßÚ“Ðp¢�
ÞÍ€€Å¢“âÞÞ¸¦õ2çÍæçè¶+ø¦è*¡¦�¦¡~Gets this `RawBytesULE` as a `u32`. This is equivalent to calling [`AsULE::from_unaligned()`] on the appropriately sized type.Áñ¡ø¨£¡ø¦›ªx¦ïööçÍä¦ÿä
æ ¦€ø¦Å3¡¦û¦ÿ}Converts a `u32` to a `RawBytesULE`. This is equivalent to calling [`AsULE::to_unaligned()`] on the appropriately sized type.Áù£øª� ø¦ù©`¦ÒçÍääµ’˜çÆø¬õH¡¬û¬ÿ=Convert an array of `u32` to an array of `RawBytesULE < 4 >`.Áé¥ø¯�jø¬ùsP¬‚€–î•äÍééä“Ðp¬�
èÍ€€‰Ê¬“âèè¸°õ3õëðñòÕ+ø°è*¡°�°¡~Gets this `RawBytesULE` as a `u64`. This is equivalent to calling [`AsULE::from_unaligned()`] on the appropriately sized type.Á„¨ø²£¡ø°›ªx°ï÷÷õëî°ÿî
ð °€ø°Å3¡°û°ÿ}Converts a `u64` to a `RawBytesULE`. This is equivalent to calling [`AsULE::to_unaligned()`] on the appropriately sized type.ÁŒªø´� ø°ù©`°ÒõëîîÎ�˜sÌø¶õH¡¶û¶ÿ=Convert an array of `u64` to an array of `RawBytesULE < 8 >`.Áü«ø¹�jø¶ùsP¶‚™¡‡¡îÍóóî“Ðp¶�
òÍ€€"Ð¶“âòò¸ºõ4Ïìúûüõ+øºè*¡º�º¡Gets this `RawBytesULE` as a `u128`. This is equivalent to calling [`AsULE::from_unaligned()`] on the appropriately sized type.Á—®ø¼£¡øº›ªxºïøøÏìøºÿø
ú º€øºÅ3¡ºûºÿ~Converts a `u128` to a `RawBytesULE`. This is equivalent to calling [`AsULE::to_unaligned()`] on the appropriately sized type.Á °ø¾� øºù©`ºÒÏìøøè¨˜
ÒøÀõH¡ÀûÀÿ?Convert an array of `u128` to an array of `RawBytesULE < 16 >`.Á‘²øÃ�jøÀùsPÀ‚³¬¡¬øÍýýø“ÐpÀ�
üÍ€€¼ÕÀ“æüüøÅð!'é¥Í„ü„Ÿ,èÅ¼" Å¿"¥Í‚‚
„˜(ÅÄ" Å¦#é†ˆ‰ÊËÌˆ‰@ÅÉ#ÅÎ#……¥Í¤øÅŠ$"`Å�$Ê……
ˆ Åš$øÅ�%/pÅ’%Ü¶…
®ñ”
ß”
				¸àô (à÷ ‰‰®ñ®ñ‘
àý ‘

”
æñìñ àþ øàÅ!*CÓ!–
¦W—
—
–
’õ
Á	‘ø
À	µåàÐ!Çå
®ñß	â	æ	é	¡â†âŠ$ULE type for tuples with 3 elements.ÁÇöøãŒ8øâ„ADL†%Ó!š
¦W›
kœ
›
œ
š
’õ
˜%‘ø
�%©â§ó¢%ÞòEÕAŸH>ÕÕ™
�
ž
Ÿ
æñìñ§óÞò“æñìñ§óÞò˜
˜

™
æñìñ§ó�Ÿ¢¤ž 0â¼˜
˜
æñ˜
˜
ìñ02˜
˜
§óøâ¯0DÓ!¡
¦W¢
k£
£
¡
¢
’õ
K‘ø
JÒø@µåâÁÇå
Ä§óÞò¤
Å¤
‰Œ�“Ž‘øâî7pâñŠŠ—ãºê 
â‡ 

¤
æñìñ§óã(â€øâû(DÓ!¦
¦W§
k¨
§
¨
¦
’õ
d‘ø
cÒøY«õ
(â†±ç
É§ó³ó©
ª
«
ÊËÌª
«
´·»¾¹¼@â²â·¥
¥
˜
˜
™
·{�
ìž
íŸ
îEÕAŸH>ÕÕÐèÛè§óÊøâ÷"`âú³ó³óÊ¥
¥

ª
æñìñ§ó â‡øâ¦/pâ©¼ÿ³ó¥
¥

«
æñìñ§óçë	Hâ¸øâÙ=DÓ!
¦W®
k¯
¯

®
	’õ
E‘ø
DÒø:ÎêPâäµåâñêêÇåà`§ó(²û$Þò°
á`°
™œ £ž¡øâ¥Câ¨‹Œ�‹ÞòŒÁ`Á`œÃ`èÁ]Ä`áÁ]Ê\É:•�˜ù¬
â¬¬

°
æñìñ§ó âþâ³øâ„;DÓ!²
¦W³
k´
³
´
²
	’õ
Ñ‘ø
ÐÒøÆíHâ�µåâ›ÍíÇåž§ó§ó,²û(Þòµ
 µ
),03.1øâÎ"âÑŽ�ŽÞò�Þò±
âÔ±

µ
æñìñ§ó âÕî(âÛøâÈ-DÓ!·
¦W¸
k¹
·
¸
¹
	’õ
‘ø
ÒøÏïâÓµåâØëïÇå£§ó(²û$Þòehlojmøâ‚=DÓ!»
¦W¼
k½
»
¼
½
	’õ
Ó‘ø
ÒÒøÈÞðPâ�µåâšþðÇåÉ§ó§ó,²û(Þò¾
Ë¾
+.2503øâÎBXâÑ�‘�Þò‘Þòþº
âÝº

¾
æñìñ§ó âÞî(âäøâñ/DÓ!À
¦WÁ
kÂ
Â
À
Á
	’õ
 	‘ø
	Òø	‚óâüµåâ‚žóÇåÃ§ó(²û$ÞòÃ
ÄÃ
t	w	{	~	y	|	øâ¯2â²’“’Þò“Þòñþ¿
â¶¿

Ã
æñìñ§ó â·î(â½øâº +DÓ!Å
¦WÆ
kÇ
Æ
Å
Ç
’õ
i
‘ø
h
Òø^
µåâÅ Çå
²ûÞòÈ
ßÈ
Ÿ
¢
¦
©
¤
§
¸âô (â÷ ””ÞòÞòÄ
âý Ä

È
æñìñ§ó âþ øâÅ!*DÓ!Ê
¦WË
kÌ
Ë
Ì
Ê
’õ
w‘ø
vÒølµåâÐ!Çå
²ûÞò¢¥©¬§ª~¡ä†äŠ$ULE type for tuples with 4 elements.Á�øåŒ8øä„AELµ%Ó!Ï
¦WÐ
kÑ
í~Ò
Ï
Ñ
Ò
Ð
’õ
Ç%‘ø
Ì%ÒøÑ%©âñôÖ%›ô¾N@Rze¶Î
Ó
Ô
Õ
Ö
æñìñ§óñô›ô~°æñìñ§óñô›ôÍ
Í

Î
æñìñ§óñô²´·¹¼¾¸º0ä¼Í
Í
æñÍ
Í
ìñ02Í
Í
§óFHÍ
Í
ñôøä¯0EÓ!Ø
¦WÙ
kÚ
í~Û
Ø
Ú
Û
Ù
’õ
’‘ø
‘Òø�Ð‘†µåäÁÇå
²ûÄñô›ôÜ
ÅÜ
Ýàäçëîéìøäî7päñ••—ãºê×
ä‡×

Ü
æñìñ§óñôã(ä€øäû(EÓ!Þ
¦Wß
kà
í~á
Þ
á
ß
à
’õ
Û‘ø
ÚÒøÙÐ‘Ï«õ
(ä†±ç
ËýÉñôþôâ
ã
ä
ÊËÌã
ä
8;?BFIDG@ä²ä·Ý
Ý
Í
Í
Î
À~Ó
ìÔ
íÕ
îÖ
ï¾N@Rze¶ÐèÛèŠÿñôÊøä÷"`äúþôþôÊÝ
Ý

ã
æñìñ§óñô ä‡øä¦/pä©Ó™þôÝ
Ý

ä
æñìñ§óñôçë	Hä¸øäÙ=EÓ!æ
¦Wç
kè
í~é
é
ç
æ
è
’õ
þ‘ø
ýÒøüÐ‘òÎêPääµåäñêêÇå¼� ²ûà`ñô4ü”0›ôê
á`ê
ehlosvqtøä¥Cä¨–—˜–›ô—Á`Á`œÃ`èÁ]Ä`áÁ]Ê\É:•˜˜ùå
ä¬å

ê
æñìñ§óñô äþä³øä„;EÓ!ì
¦Wí
kî
í~ï
ì
î
ï
í
’õ
À‘ø
¿Òø¾Ð‘´íHä�µåä›ÍíÇåÈ„ ²ûžñôñô8ü”4›ôð
 ð
+.259<7:øäÎ"äÑ™š™›ôš›ôë
äÔë

ð
æñìñ§óñô äÕî(äÛøäÈ-EÓ!ò
¦Wó
kô
í~õ
ò
ô
õ
ó
’õ
A‘ø
@Òø?Ð‘5ÏïäÓµåäØëïÇå“‡ ²û£ñô4ü”0›ô� ¤§«®©¬øä‚=EÓ!÷
¦Wø
kù
í~ú
ú
ù
÷
ø
’õ
)	‘ø
(	Òø'	Ð‘	ÞðPä�µåäšþðÇåÊˆ ²ûÉñôñô8ü”4›ôû
Ëû
”	—	›	ž	¢	¥	 	£	øäÎBXäÑ›œ››ôœ›ôþö
äÝö

û
æñìñ§óñô äÞî(ääøäñ/EÓ!ý
¦Wþ
kÿ
í~€ÿ
ý
þ
€’õ
¬
‘ø
«
Òøª
Ð‘ 
‚óäüµåä‚žóÇå—‹ ²ûÃñô4ü”0›ô�Ä�!$"øä¯2ä²�ž�›ôž›ôñþü
ä¶ü

�æñìñ§óñô ä·î(ä½øäº +EÓ!ƒ¦W„k…í~†ƒ„†…’õ
+‘ø
*Òø)Ð‘µåäÅ Çå
²ûü”›ô‡ß‡nqux|z}¸äô (ä÷ ŸŸ›ô›ô‚äý ‚
‡æñìñ§óñô äþ øäÅ!*EÓ!‰¦WŠk‹í~ŒŒŠ‹‰’õ
i
‘ø
h
Òøg
Ð‘]
µåäÐ!Çå
²ûü”›ô¡
¤
¨
«
¯
²

°
¡æ†æŠ$ULE type for tuples with 5 elements.Á±¬øçŒ8øæ„AFLé%Ó!�¦W�k‘í~’—B““�‘’�’õ
û%‘ø
€&Òø…&Ð‘Š&©âÍö�&éõ	pŠÄ‘ƒŽ”•–—˜æñìñ§óñôÍöéõÍæñìñ§óñôÍöéõ��
Žæñìñ§óñôÍöÇÉÌÎÑÓÖØÒÔ0æ¼��æñ��ìñ02��§óFH��ñô\^��Íöøæ¯0FÓ!š¦W›kœí~�—Bž�žœš›
’õ
Ù‘ø
ØÒø×Ð‘Öì®ÌµåæÁÇå
²ûü”ÄÍö$éõŸÅŸ148;?BFIDGøæî7pæñ  —ãºê™æ‡™
Ÿæñìñ§óñôÍöã(æ€øæû(FÓ!¡¦W¢k£í~¤—B¥¤¢¥¡£
’õ
R‘ø
QÒøPÐ‘Oì®E«õ
(æ†±ç
ËýÅ—ÉÍö$Úö¦§¨ÊËÌ¨§¼¿ÃÆÊÍÑÔÏÒ@æ²æ·  ��Ž¢‚”ì•í–î—ï˜ð	pŠÄ‘ƒÐèÛèŠÿ ™ÍöÊøæ÷"`æúÚöÚöÊ  
§æñìñ§óñôÍö æ‡øæ¦/pæ©‰¸Úö  
¨æñìñ§óñôÍöçë	Hæ¸øæÙ=FÓ!ª¦W«k¬í~—B®«®ª¬’õ
¸‘ø
·Òø¶Ð‘µì®«ÎêPæäµåæñêêÇå¼� ²ûþ›,ü”(à`Íö@ä²<éõ¯á`¯259<@CGJEHøæ¥Cæ¨¡¢£¡éõ¢Á`Á`œÃ`èÁ]Ä`áÁ]Ê\É:•£˜ù©æ¬©
¯æñìñ§óñôÍö æþæ³øæ„;FÓ!±¦W²k³í~´—Bµ±µ´²³’õ
°‘ø
¯Òø®Ð‘ì®£íHæ�µåæ›ÍíÇåÈ„ ²ûÀŸ,ü”(žÍöÍöDä²@éõ¶ ¶.158<?CFADøæÎ"æÑ¤¥¤éõ¥éõ°æÔ°
¶æñìñ§óñôÍö æÕî(æÛøæÈ-FÓ!¸¦W¹kºí~»—B¼¼¸º»¹’õ
g	‘ø
f	Òøe	Ð‘d	ì®Z	ÏïæÓµåæØëïÇå“‡ ²ûÁ¢,ü”(£Íö@ä²<éõÖ	Ù	Ý	à	ä	ç	ë	î	é	ì	øæ‚=FÓ!¾¦W¿kÀí~Á—BÂÀÁ¿Â¾’õ
€
‘ø

Òø~
Ð‘}
ì®s
ÞðPæ�µåæšþðÇåÊˆ ²û©¤,ü”(ÉÍöÍöDä²@éõÃËÃþ
øæÎBXæÑ¦§¦éõ§éõþ½æÝ½
Ãæñìñ§óñôÍö æÞî(æäøæñ/FÓ!Å¦WÆkÇí~È—BÉÇÅÉÈÆ’õ
9‘ø
8Òø7Ð‘6ì®,‚óæüµåæ‚žóÇå—‹ ²û¬§,ü”(ÃÍö@ä²<éõÊÄÊ³¶º½ÁÄÈËÆÉøæ¯2æ²¨©¨éõ©éõñþÄæ¶Ä
Êæñìñ§óñôÍö æ·î(æ½øæº +FÓ!Ì¦WÍkÎí~Ï—BÐÐÎÌÍÏ
’õ
î
‘ø
í
Òøì
Ð‘ë
ì®á
µåæÅ Çå
²ûü”ä²éõÑßÑ>AEHLOSVQT¸æô (æ÷ ªªéõéõËæý Ë
Ñæñìñ§óñôÍö æþ øæÅ!*FÓ!Ó¦WÔkÕí~Ö—B×Ô×ÓÕÖ
’õ
\‘ø
[ÒøZÐ‘Yì®OµåæÐ!Çå
²ûü”ä²éõ¡¤¨«¯²¶¹´·‘¡è†èŠ$ULE type for tuples with 6 elements.ÁÔÍøéŒ8øè„AGL¢&Ó!Ú¦WÛkÜí~Ý—BÞðßßÝÛÜÚÞ’õ
´&‘ø
¹&Òø¾&Ð‘Ã&ì®È&©â¹øÍ&È÷©úþXZŒT?Ùàáâãäåæñìñ§óñôÍö¹øÈ÷‘êæñìñ§óñôÍö¹øÈ÷ØØ
Ùæñìñ§óñôÍö¹øÜÞáãæèëíðòìî0è¼ØØæñØØìñ02ØØ§óFHØØñô\^ØØÍörtØØ¹øøè¯0GÓ!ç¦Wèkéí~ê—Bëðìêèìëçé’õ
 ‘ø
ÒøÐ‘ì®§ÐµåèÁÇå
²ûü”ä²Ä¹ø*È÷íÅí…ˆŒ�“–š�¡¤Ÿ¢øèî7pèñ««—ãºêæè‡æ
íæñìñ§óñôÍö¹øã(è€øèû(GÓ!ï¦Wðkñí~ò—Bóðôóñïôðò’õ
É‘ø
ÈÒøÇÐ‘Æì®Å§Ð»«õ
(è†±ç
ËýÅ—ÝµÉ¹ø*Æøõö÷ÊËÌö÷@CGJNQUX\_Z]@è²è·îîØØÙÛ†àìáíâîãïäðåñ©úþXZŒTÐèÛèŠÿ ™Õ·¹øÊøè÷"`èúÆøÆøÊîî
öæñìñ§óñôÍö¹ø è‡øè¦/pè©ÝÚÆøîî
÷æñìñ§óñôÍö¹øçë	Hè¸øèÙ=GÓ!ù¦Wúkûí~ü—Býðþûüúþýù’õ
q‘ø
pÒøoÐ‘nì®m§ÐcÎêPèäµåèñêêÇå¼� ²ûþ›,ü”(ßº8ä²4à`¹øLëÔHÈ÷ÿá`ÿþøè¥Cè¨¬®¬È÷Á`Á`œÃ`èÁ]Ä`áÁ]Ê\É:•®˜ùøè¬ø
ÿæñìñ§óñôÍö¹ø èþè³øè„;GÓ!�¦W‚kƒí~„—B…ð†‚„…ƒ�†’õ
Ÿ‘ø
žÒø�Ð‘œì®›§Ð‘íHè�µåè›ÍíÇåÈ„ ²ûÀŸ,ü”(×¾8ä²4ž¹ø¹øPëÔLÈ÷‡ ‡0	3	7	:	>	A	E	H	L	O	J	M	øèÎ"èÑ¯°¯È÷°È÷€èÔ€
‡æñìñ§óñôÍö¹ø èÕî(èÛøèÈ-GÓ!‰¦WŠk‹í~Œ—B�ðŽ‹‰�ŽŒŠ’õ
Œ
‘ø
‹
ÒøŠ
Ð‘‰
ì®ˆ
§Ð~
ÏïèÓµåèØëïÇå“‡ ²ûÁ¢,ü”(ŽÂ8ä²4£¹øLëÔHÈ÷#&*-(+øè‚=GÓ!�¦W‘k’í~“—B”ð••”�’“‘’õ
Ö‘ø
ÕÒøÔÐ‘Óì®Ò§ÐÈÞðPè�µåèšþðÇåÊˆ ²û©¤,ü”(§Ä8ä²4É¹ø¹øPëÔLÈ÷–Ë–gjnqux|ƒ†�„øèÎBXèÑ±²±È÷²È÷þ�èÝ�
–æñìñ§óñôÍö¹ø èÞî(èäøèñ/GÓ!˜¦W™kší~›—Bœð�š˜�™›œ’õ
Å
‘ø
Ä
ÒøÃ
Ð‘Â
ì®Á
§Ð·
‚óèüµåè‚žóÇå—‹ ²û¬§,ü”(àÇ8ä²4Ã¹øLëÔHÈ÷žÄžRUY\`cgjnqloøè¯2è²³´³È÷´È÷ñþ—è¶—
žæñìñ§óñôÍö¹ø è·î(è½øèº +GÓ! ¦W¡k¢í~£—B¤ð¥¥£¡¢ ¤’õ
°‘ø
¯Òø®Ð‘ì®¬§Ð¢µåèÅ Çå
²ûü”ä²ëÔ"È÷¦ß¦
"%),'*¸èô (è÷ µµÈ÷È÷Ÿèý Ÿ
¦æñìñ§óñôÍö¹ø èþ øèÅ!*GÓ!¨¦W©kªí~«—B¬ð¬¨ª«©’õ
N‘ø
MÒøLÐ‘Kì®J§Ð@µåèÐ!Çå
²ûü”ä²ëÔ"È÷ £§ª®±µ¸¼¿º½øêëÙ
¡ê§

ê«

LVarULE type for tuples with 2 elements. See module docs for more informationÁ™óøë
`
øê¥
i
KdÈU
Ó!¯¦W°ñC±±¯°ªâæñÛU
ªâìñåU
©â‡úøêŒ"
a‡ú€ê”
·ù+MéãîD²³´WYSUO0êŒ
ÏÊ˜êÀ
ÝU
‹®®‰‰ŠÁ¯Ñ{·Ë…YÚæñDçU
‹®®‰‰ŠÁ¯Ñ{·Ë…YÚìñøê—#
(ê—
‹®®à
à
á
åjä
ìç¹ƒ}@e`ýÄ‡úÖU
øêÎM
KÓ!·¦W¸ñC¹¹·¸½õºÎõ°ßõ0êì
Óæñ0êÙ
Óìñóõ€êô
·ùº»XZ¸ê�
¡ê¿
êÃ
Get field 0of this tupleÁ‘ùøìÅ*
øê½3
í¶¶·ù¶æñ¶ê‹
¶
ºæñìñ‡ú êŒ
¶¡²´®Get field 1of this tupleÁ»úøíÅ*
ªR···ù·ìñ¶¥¶
»æñìñ‡ú¡øêª_
KÓ!½¦W¾ñC¿½¾¿½õÂÎõ¸ßõ0êÏ
˜ù0ê¼
ªù
óõ€ê×
·ùÀÂÔÖÂÀ

XZøê 7
pê£
¸¸—ãºê¼ê¹
¼
Àæñìñ‡úã(ê²
9øêÚ5
 êä
¹¹—ã¹·ù¼ê€
¼
Âæñìñ‡úã(êù
¾ÌøêÚ"i
KÓ!Æ¦WÇñCÈÈÆÇ½õ…Îõ{ßõ0ê…#
ÎêPêå"
˜ù0êò"
êêªùóõ€ê�#
·ùÉá`ÉÒÕÐÓ]_øêÒ#C
êÕ#
º»¼º·ù»Á`Á`œÃ`èÁ]Ä`áÁ]Ê\É:•¼˜ùÅêÙ#
Å
Éæñìñ‡ú êÚ#
þêà#
øê³%g
KÓ!Ë¦WÌñCÍÌÍË½õ	Îõÿßõ0êÝ%
íHê¾%
˜ù0êÊ%
Ííªùóõ€êå%
·ùÎ ÎVYTW]_øê©&"
ê¬&
½¾½·ù¾·ùÊê¯&
Ê
Îæñìñ‡ú ê°&
î(ê¶&
øê¨'Y
KÓ!Ð¦WÑñCÒÑÐÒ½õHÎõ>ßõ0êË'
Ïïê³'
˜ù0ê¸'
ëïªùóõ€êÓ'
·ùŠ�ˆ‹RTøêŽ(i
KÓ!Ô¦WÕñCÖÔÕÖ½õ÷Îõíßõ0ê¹(
ÞðPê™(
˜ù0ê¦(
þðªùóõ€êÁ(
·ù×Ë×D	G	B	E	]_øê†)B
Xê‰)
¿À¿·ùÀ·ùþÓê•)
Ó
×æñìñ‡ú ê–)
î(êœ)
øê*[
KÓ!Ù¦WÚñCÛÛÚÙ½õ8
Îõ.
ßõ0êÑ*
‚óê¸*
˜ù0ê¾*
žóªùóõ€êÙ*
·ùÜÄÜ…
ˆ
ƒ
†
]_øê˜+2
ê›+
ÁÂÁ·ùÂ·ùñþØêŸ+
Ø
Üæñìñ‡ú ê +
î(ê¦+
øêý-æ
KÓ!Þ¦WßèŽàòŽáñCâàÞâáß
½õšÎõ�©âÕúßU
©âÛúéU
©â²û0ê�.
˜ù0êÿ.
ªù
Õúæñ�ê¨/
Ûúìña²û€êÒ/
Óúãæè¯²µèæãGJEH´¶°²¬®øêú/I
Àêý/
ÃÃÓú¢šÝšä¢ååäê™0
Ý©â•�ê–0
©â��Ðê£0
ÄÅ™ ��Ä
Å—ã¨ê¨0
ÄÅ��‹�› •�ê¼0

ãæñìñÕúÛú²û•��� êš0
ê 0
¦¨ ¢øêÖ1%
�êÙ1
ÆÆÓúÝêì1
Ý
ææñìñÕúÛú²û êí1
Þøê¯4.
 ê²4
ÇÈÇÓúÈ—ãÝêÇ4
Ý
èæñìñÕúÛú²û êÈ4
·…êÎ4
}
øê”<õ
K¨ëÓ!ì¦WíèŽîòŽïñCðëíîìðï
ªâ›ümªâ¡ül©âÀûÜ©âÆûÛ©â§ü0ê±<
Ó›ü0ê˜=
Ó¡ü
Àû¨›ü€êÉ=

Æû¨¡üa§ü€êù=
¾ûñ
ñê™<
,/*-™œ—š»½øê˜>6
Hê›>
¨Óû¾ûêê
ñ¨›ü¡üÀûÆû§üî(ê¥>
øñëÙ
¡ñ§

ñ«

LVarULE type for tuples with 3 elements. See module docs for more informationÁÊ–øò
`
øñ¥
i
Ld€V
Ó!ó¦WôkõñCöôöõó½õ“V
Îõ�V
ªâ§ó§V
©â”ýøñŒ"
a”ý€ñ”
´üÑ&?)œ
ó÷øùúacfhbd^0ñŒ
ÏÊ˜ñÀ
•V
‹òòéöŸV
‹òò©÷8©V
‹òò‰‰ŠÁ¯Ñ{·Ë…YÚ§óøñ—#
(ñ—
‹òòà
à
á
åjä
ìç¹ƒ}@e`ýÄ”ýŽV
øñÎM
LÓ!ý¦WþkÿñC€ýÿ€þ½õÓÎõÒ�™Èž™0ñì
˜ù0ñÙ
ªù
Ó§ó²™€ñô
´ü�‚ƒ#&*-(+hj¸ñ�
¡ñ¿
ñÃ
‘ù‘ùøóÅ*
øñ½3
ïÉÉ´üÉæñüñ‹
ü
�æñìñ§ó”ý ñŒ
¤¡ ¢œ»ú»úøôÅ*
˜hÊÊ´üÊìñü“ü
‚æñìñ§ó”ý�/¡,/*Get field 2of this tupleÁŸŸøõÅ*
>õËË´üË§óü:ü
ƒæñìñ§ó”ý7øñª_
LÓ!…¦W†k‡ñCˆ…†ˆ‡½õ…Îõ„�™zž™0ñÏ
˜ù0ñ¼
ªù
ÿœ²™€ñ×
´ü‰‹ÔÖ‰‹ÚÝáäßâmoøñ 7
pñ£
ÌÌ—ãºê„ñ¹
„
‰æñìñ§ó”ýã(ñ²
øñÚ5
 ñä
ÍÍ—ãÍ´ü„ñ€
„
‹æñìñ§ó”ýã(ñù
œªøñÚ"i
LÓ!�¦W�k‘ñC’��‘’½õ|Îõ{�™qž™0ñ…#
ÎêPñå"
˜ù0ñò"
êêªù¼� ÿœ²™€ñ�#
´ü“á`“ÜßãæáäxzøñÒ#C
ñÕ#
ÎÏÐÎ´üÏÁ`Á`œÃ`èÁ]Ä`áÁ]Ê\É:•Ð˜ùŽñÙ#
Ž
“æñìñ§ó”ý ñÚ#
þñà#
øñ³%g
LÓ!•¦W–k—ñC˜—•˜–½õ5Îõ4�™*ž™0ñÝ%
íHñ¾%
˜ù0ñÊ%
ÍíªùÈ„ ÿœ²™€ñå%
´ü™ ™•˜œŸš�xzøñ©&"
ñ¬&
ÑÒÑ´üÒ´ü”ñ¯&
”
™æñìñ§ó”ý ñ°&
î(ñ¶&
øñ¨'Y
LÓ!›¦Wœk�ñCž›žœ�½õ©	Îõ¨	�™ž	ž™0ñË'
Ïïñ³'
˜ù0ñ¸'
ëïªù“‡ ÿœ²™€ñÓ'
´üþ	


moøñŽ(i
LÓ! ¦W¡k¢ñC£ ¢£¡½õˆ
Îõ‡
�™}
ž™0ñ¹(
ÞðPñ™(
˜ù0ñ¦(
þðªùÊˆ ÿœ²™€ñÁ(
´ü¤Ë¤è
ë
ï
ò
í
ð
xzøñ†)B
Xñ‰)
ÓÔÓ´üÔ´üþŸñ•)
Ÿ
¤æñìñ§ó”ý ñ–)
î(ñœ)
øñ*[
LÓ!¦¦W§k¨ñC©¦¨©§½õþÎõý�™óž™0ñÑ*
‚óñ¸*
˜ù0ñ¾*
žóªù—‹ ÿœ²™€ñÙ*
´üªÄª^aehcfxzøñ˜+2
ñ›+
ÕÖÕ´üÖ´üñþ¥ñŸ+
¥
ªæñìñ§ó”ý ñ +
î(ñ¦+
øñý-æ
LÓ!¬¦Wk®èŽ¯òŽ°Ò“±ñC²¯±²°¬®½õ¥
Îõ¤
�™š
Ê”—V
Ú”¡V
©âèý«V
©âÏþ0ñ�.
˜ù0ñÿ.
ªù
ÿœÀûæñ�ñ¨/
Æûìñèý§ó(aÏþ€ñÒ/
àý³¶¸¯²µ³¸¶pswzuxãåèêäæàâøñú/I
Àñý/
××àý¢š«š´¢µ´µñ™0
«©â“·ñ–0
©âŽ·Ðñ£0
ØÙ™ Ž·Ø
Ù—ã¨ñ¨0
ØÙŽ·‰¸› “·ñ¼0

³	æñìñ§óÀûÆûèýÏþ“·Ž· ñš0
ñ 0
®°¨ªøñÖ1%
�ñÙ1
ÚÚàý«ñì1
«
¶æñìñ§óÀûÆûèýÏþ ñí1
,øñ¯4.
 ñ²4
ÛÜÛàýÜ—ã«ñÇ4
«
¸æñìñ§óÀûÆûèýÏþ ñÈ4
·…ñÎ4
Õøñ”<õ
L¨»Ó!¼¦W½k¾èŽ¿òŽÀÒ“ÁñCÂ¼¿»Â¾Á½Àª”åº”äªâÒÿã©âÝþR©âãþZ©âéþY©â×ÿ0ñ±<
ý”0ñ˜=
�•
ÓÒÿ
Ýþ¨›ü€ñÉ=

ãþ¨¡ü
éþ¨Òÿ2a×ÿ€ñù=
ÛþÃ
Ãñ™<
ÐÓ×ÚÕØCFJMHKîðøñ˜>6
Hñ›>
¨öþÛþºº
Ã¨›ü¡üÒÿÝþãþéþ×ÿî(ñ¥>
øùëÙ
¡ù§

ù«

LVarULE type for tuples with 4 elements. See module docs for more informationÁÍ¿øú
`
øù¥
i
MdÂV
Ó!Å¦WÆkÇí~ÈñCÉÉÇÅÆÈ½õÕV
ÎõßV
�™éV
ªâñôóV
��øùŒ"
Û�€ù”
äÿtüþèe '·ÊËÌÍÎ[]`begacf0ùŒ
ÏÊ˜ùÀ
×V
‹ÄÄéöáV
‹ÄÄ©÷8ëV
‹ÄÄëšRõV
‹ÄÄ‰‰ŠÁ¯Ñ{·Ë…YÚñôøù—#
(ù—
‹ÄÄà
à
á
åjä
ìç¹ƒ}@e`ýÄ²ûÐV
øùÎM
MÓ!Ñ¦WÒkÓí~ÔñCÕÒÔÕÓÑ
½õÎõ�™¨Â÷��0ùì
˜ù0ùÙ
ªù
ÿœÓñôÛ�€ùô
äÿÖ×ØÙcfjmqtor€‚¸ù�
¡ù¿
ùÃ
‘ù‘ùøûÅ*
øù½3
7ÝÝäÿÝæñÐù‹
Ð
Öæñìñ§óñô²û ùŒ
©¡¥§¡»ú»úøüÅ*
�µÞÞäÿÞìñÐ˜Ð
×æñìñ§óñô²û”9¡694ŸŸŸŸøýÅ*
10ßßäÿß§óÐ-Ð
Øæñìñ§óñô²û*Ð¡ÍÐËGet field 3of this tupleÁ¢ÊøþÅ*
ßÄààäÿàñôÐÛÐ
Ùæñìñ§óñô²ûØøùª_
MÓ!Û¦WÜkÝí~ÞñCßßÛÝÞÜ
½õ‰Îõˆ�™‡¨Â}��0ùÏ
˜ù0ù¼
ªù
ÿœÏÆÛ�€ù×
äÿàâÔÖâàëîòõùü÷ú‚„øù 7
pù£
áá—ãºêÚù¹
Ú
àæñìñ§óñô²ûã(ù²
øùÚ5
 ùä
ââ—ãâäÿÚù€
Ú
âæñìñ§óñô²ûã(ùù
¥³øùÚ"i
MÓ!æ¦Wçkèí~éñCêêèæçé½õµÎõ´�™³¨Â©��0ù…#
ÎêPùå"
˜ù0ùò"
êêªù¼� ÿœþ›,ÏÆ(Û�€ù�#
äÿëá`ë(+/26947“•øùÒ#C
ùÕ#
ãäåãäÿäÁ`Á`œÃ`èÁ]Ä`áÁ]Ê\É:•å˜ùåùÙ#
å
ëæñìñ§óñô²û ùÚ#
þùà#
øù³%g
MÓ!í¦Wîkïí~ðñCñîïíñð½õ¤	Îõ£	�™¢	¨Â˜	��0ùÝ%
íHù¾%
˜ù0ùÊ%
ÍíªùÈ„ ÿœÀŸ,ÏÆ(Û�€ùå%
äÿò ò


!
%
(
#
&
“•øù©&"
ù¬&
æçæäÿçäÿìù¯&
ì
òæñìñ§óñô²û ù°&
î(ù¶&
øù¨'Y
MÓ!ô¦Wõköí~÷ñCøõ÷øöô½õNÎõM�™L¨ÂB��0ùË'
Ïïù³'
˜ù0ù¸'
ëïªù“‡ ÿœÁ¢,ÏÆ(Û�€ùÓ'
äÿ¶¹½ÀÄÇÂÅˆŠøùŽ(i
MÓ!ú¦Wûküí~ýñCþýþüúû½õ^Îõ]�™\¨ÂR��0ù¹(
ÞðPù™(
˜ù0ù¦(
þðªùÊˆ ÿœ©¤,ÏÆ(Û�€ùÁ(
äÿÿËÿÑÔØÛßâÝà“•øù†)B
Xù‰)
èéèäÿéäÿþùù•)
ù
ÿæñìñ§óñô²û ù–)
î(ùœ)
øù*[
MÓ!�¦W‚kƒí~„ñC…„‚…�ƒ½õ
Îõ	�™¨Âþ
��0ùÑ*
‚óù¸*
˜ù0ù¾*
žóªù—‹ ÿœ¬§,ÏÆ(Û�€ùÙ*
äÿ†Ä†}€„‡‹Ž‰Œ“•øù˜+2
ù›+
êëêäÿëäÿñþ€ùŸ+
€
†æñìñ§óñô²û ù +
î(ù¦+
øùý-æ
M	Ó!ˆ¦W‰kŠí~‹èŽŒòŽ�Ò“Ž£™�ñC�	�‰�Œˆ�‹ŽŠ½õ÷Îõö�™õ¨Âë€½ÙV
�½ãV
 ½íV
©â©�÷V
©â ‚0ù�.
˜ù0ùÿ.
ªù
ÿœÏÆÝþæñ�ù¨/
ãþìñéþ§ó(©�ñô:a ‚€ùÒ/
ž�‘”–¯²µ‘–”éìðó÷úõø #!øùú/I
Àùý/
ììž�
¢	š‡	š’	¢“
’	“
ù™0
‡©âÇåù–0
©âÂåÐù£0
íî™ Âåí
î—ã¨ù¨0
íîÂå½æ› Çåù¼0

‘æñìñ§óñôÝþãþéþ©� ‚ÇåÂå ùš0
ù 0
¶¸°²øùÖ1%
�ùÙ1
ïïž�‡	ùì1
‡
”	æñìñ§óñôÝþãþéþ©� ‚ ùí1
¾øù¯4.
 ù²4
ðñðž�ñ—ã‡	ùÇ4
‡
–	æñìñ§óñôÝþãþéþ©� ‚ ùÈ4
·…ùÎ4
qøù”<õ
M
¨™Ó!š¦W›kœí~�èŽžòŽŸÒ“ £™¡ñC¢	
œŸ›¢	žš¡�™ ª”Áº”Àð¼¿ªâ¹ƒ¾©â®‚Ü©â´‚ä©âº‚ì©âÀ‚ë©â¿ƒ0ù±<
ý”0ù˜=
�•
Ó½Ó¹ƒ
®‚¨›ü€ùÉ=

´‚¨¡ü
º‚¨Òÿ2
À‚¨¹ƒIa¿ƒ€ùù=
¬‚£
£ù™<
àãçêîñìï	),øù˜>6
Hù›>
¨Í‚¬‚˜
˜
£
¨›ü¡üÒÿ¹ƒ®‚´‚º‚À‚¿ƒî(ù¥>
ø‚ëÙ
¡‚§

‚«

LVarULE type for tuples with 5 elements. See module docs for more informationÁšïøƒ
`
ø‚¥
i
NdŽW
Ó!¥¦W¦k§í~¨—B©ñCª§¥©ª¨¦½õ¡W
Îõ«W
�™µW
¨Â¿W
ªâÍöÉW
ê”ø‚Œ"
Ï•€‚”
ÌƒŠÛƒÁäw«¬®¯°egjloqtvpru0‚Œ
ÏÊ˜‚À
£W
‹¤¤éöW
‹¤¤©÷8·W
‹¤¤ëšRÁW
‹¤¤ŸÄlËW
‹¤¤‰‰ŠÁ¯Ñ{·Ë…YÚÍöø‚—#
(‚—
‹¤¤à
à
á
åjä
ìç¹ƒ}@e`ýÄ§üœW
ø‚ÎM
NÓ!³¦W´kµí~¶—B·ñC¸´¸·³µ¶½õCÎõB�™A¨Â@�ò6ê”0‚ì
˜ù0‚Ù
ªù
ÿœÏÆÓÍö$Ï•€‚ô
Ìƒ¹º»¼½³¶º½ÁÄÈËÆÉ˜š¸‚�
¡‚¿
‚Ã
‘ù‘ùø„Å*
ø‚½3
òòÌƒòæñ²‚‹
²
¹æñìñ§óñôÍö§ü ‚Œ
®¡ª¬¦»ú»úø…Å*
¢óóÌƒóìñ²�²
ºæñìñ§óñôÍö§ü™C¡@C>ŸŸŸŸø†Å*
;‚ôôÌƒô§ó²7²
»æñìñ§óñôÍö§ü4ß¡ÜßÚ¢Ê¢Êø‡Å*
×õõÌƒõñô²Ó²
¼æñìñ§óñôÍö§üÐ{¡x{vGet field 4of this tupleÁ‰üøˆÅ*
Š�ööÌƒöÍö²†²
½æñìñ§óñôÍö§üƒø‚ª_