platform-admin/boc
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
9e4ebeea1aa4679ca00b951fdc58d376419ce821
boc/aamos-ledger-rust/target/debug/deps/libsharded_slab-4351dc85f44ef205.rmeta
T

976 lines
379 KiB
Plaintext
Raw Normal View History

ARCHITECTURE: NFC roadmap, edge AI, audit logging
2026-06-29 16:24:48 +00:00
rust
üê#rustc 1.96.0 (ac68faa20 2026-05-25)ÁÀ뉊]!ÜÛê(¹Þ—šên-5be7b69c3ff7b5b8ÁíàÄTËŸ ÜJîÄ)'ß\¥!-3d1337db07d0b3aeÁ¤²XctÔ'ÐÓ©z¨ɽÓ-a4945860e1c53b00Á¤°ð ¾ä-±($²ï=©Ã-7e98a21bfd32b0edÁ–�òÖÀH•‘PIÓHã#£-055f30b747f859b6Árustc_std_workspace_coreÁ­Cçß^ò½èÝ$­Çÿ+Cé-c4878ee60b2242c9ÁŸÃï+Ñ]ŠqB<ÏïW#-8dd1dd90e70d0b6aÁ miniz_oxideÁ€š»J(P>àö÷g\K-1eb618da2918ab7fÁadler2ÁÆ;+Þ®5¥ÌýÝ°¦ÛLˆ-f7919172d268e069Á hashbrownÁPäV9ÒÆèÜ�"ÊÖVŽ\-0fc2184a5da6723aÁrustc_std_workspace_allocÁs&ØòØy¯s•bæ!‰ýŠ-97e4bf30be240674Á
std_detectÁhŠBîÙºÌI®Ë�Å�š-9dbbf8346ba7ac8bÁrustc_demangleÁûë9´Ç×@Œ�’ùXFº-f33013f239bf9f14Ácfg_ifÁÜLh�ž§Œaã¯>­�-0a71c8f33a838301Á addr2lineÁ׎Þ!]8V$É@@T·-e618e6be60e87ba2ÁgimliÁ¸
°µ~Î1‹Ñt ðÁ€w-1f7768a68858f670ÁobjectÁ
áPÃ?­À¶¼QHJ¥�-914cd6a4dbe590d1ÁmemchrÁ›º«8Ór­2Ù $¨ûib‚-cf21ca6f2bb15dcdÁë
‹ás«LÖ€îâƒ×ɯŒ-ee6f3747e38367f0Á lazy_staticÁ)]šÆÛ!�y»á=½.°ù-2e560d709532b2e5Átest_dbgÁDÜ‚$ÁÔtestsÁ,ò+‚$ç+€innerÁ,SloomÁ$*™‚$ú$±Ð‚$á[‚$Ö[�withÁ$…$‚$ä# test_utilÁL¹�‚$Ž�•,Ö�‚$Ë�ÀmacrosÁ test_printlnÁ
panic_in_dropÁdebug_assert_eq_in_dropÁimplementationÁpoolÁ 
  
PoolÁ¥”shardsÁ_cfgÁRefÁ'aÁ¥”®shardÁkeyÁRefMutÁ$´ $¥$”$®$Ò $Þ OwnedRefÁ+¥+”+®+²
+Þ  OwnedRefMutÁ1¥1”1®1²
1Þ 7¥7æ 7new_with_configÁ:”<¥<”< USED_BITSÁ<createÁ@ < create_ownedÁB < create_withÁDimpl FnOnce(&mut T)Á<getÁF < get_ownedÁH <clearÁJ J M¥M”P¥P”S¥S>V¥V”V×Z´ Z¥Z”ZÞ Z»`´ `¥`”`å`´f´ f¥f”fã k´ k¥k”k×
p´ p¥p”p� u´ u¥u”uÞ u downgradeÁu» |´ |¥|”|å|´
‚´ ‚¥‚”‚‡´ ‡¥‡”‡ãŒ´ Œ¥Œ”Œ×‘´ ‘¥‘”‘�–¥–”–Þ –»›¥›”›å›´ ¥ ” ã¤¥¤”¤×¨¥¨”¨�¬¥¬”¯¥¯”²¥²”²Þ ²ý²Ò ²»¹¥¹”¹å¹´¾¥¾”¾Â¥Â”ÂãƥƔÆ×ʥʔÊ�ΥΔѥєâÔÔÔÔÔÔÔÔÔÔConfigÁÞ MAX_THREADSÁÞ MAX_PAGESÁÞINITIAL_PAGE_SIZEÁÞ
RESERVED_BITSÁÔ
CfgPrivate狂
ã
INITIAL_SZÁã
MAX_SHARDSÁãADDR_INDEX_SHIFTÁã page_sizeÁã™ãvalidateÁãunpackÁë’ã unpack_addrÁã
unpack_tidÁã
unpack_genÁÔð”Ô DebugConfigÁò”òŸ ÔWIDTHÁÔ next_pow2ÁÔ÷æ÷Â÷ÕÔû×Ôý”ý×瀀®‚‚‚‚‚‚‚‚hintÁŠ spin_loopÁ‚Œ¥Œæ Œñ�—�£Œwith_mutÁ’—’£‚¤•–¥–æ –get_refÁ–get_mutÁ–
into_innerÁÍœœœœœœClearÁ¢Íœ¤¥¤Íœ§¥§Íœª¥ªÍœ­œ­§­¤­Íœ²¥²¤²ÍœÍœ¸¥¸Íœ»¥»Íù¾¾¾¾¾¾¾¾Æ´ ƥƔƛÆó Ë ¾Í¥Í”pageÁÐÐÐÐÐÐÐslotÁ×××××××××× ×
× × ×
×××××SlotÁê¥ê”ê lifecycleÁêó ê÷êŸ ×
GenerationÁñ”ñ»ñŸ ×RefCountÁõ”õ»õŸ × LifecycleÁù”ùºùŸ × LifecycleGenÁý
ý”ýˆ×�”�LENÁ�PrevÁ�€�as_usizeÁׇ”‡æ ׊¥Š”Šó � Š»� Šset_nextÁ‘ Š«Š mark_releaseÁŠ release_withÁ•—•ž•£• ŠinitÁ×›¥›”›is_emptyÁž ›insertÁ›try_remove_valueÁ¡—› remove_valueÁ£—£ צ¥¦”¦æ ¦try_clear_storageÁª—¦
clear_storageÁ¬—¬ ® ×°¥°”°releaseÁ×´¥´”´×׸”¸××»”»advanceÁ× ¾”¾�×
Á”× Ã”Ãï
× Æ”Æ‹×
ɔɃ×Ì”×ΥΔΒ%ÎâÎ»Ó ×Õ”ÕMARKEDÁÕREMOVINGÁÕPRESENTÁ×Ú”Ú¾!ÚÉ!Ú€ÚÝ!×à”à�×ã”×å”å××è”è¾!èÉ!è€èÝ!×î”îMAXÁîincrÁîdecrÁ×ó”ó××ö”ö�×ù”×û”ûï
×þ”þ‹×�”�ƒ×„”׆”†¾!†É!†€†Ý!׌¥Œ”Œ
generationÁŒ»� Œ value_mutÁ’ Œ’%ŒýŒrelease2Á×exponential_backoffÁ— MAX_EXPONENTÁÐstackÁ™™™™™™™™
TransferStackÁ¡”¡headÁ¡Ÿ ™¥”¥æ ¥pop_allÁ¥pushÁ©impl Fn(usize)Á™«”«Ø,­¥­ ™°”°×ÐÐÐÐ ÐAddrÁ·”·addrÁ·Ÿ л”»NULLÁ»Ö»ž
ÐFreeListÁÀ”ÀØ,Â¥ÐĔľ!ÄÉ!ÄÝ!Ä€ÐIterÁÊ´ ʥʔÐLocalÁΠ,ÐSharedÁХДÐremoteÁЙÐprev_szÁÐslabÁÐSlotsÁ×¥×”ÐÚæ Ú ,Ü Úset_headÁÞ Ðà”àØ,â¥Ðä¥ä”äú-äæ äpopÁäis_unallocatedÁê ä with_slotÁì´ ì¦ì(impl FnOnce(&'a Slot<T, C>) -> Option<U>Áì ä free_listÁñÐó´ ó¥ó”ótakeÁ÷—÷ óremoveÁú—ú ü ómake_refÁóùÿ ÿ Ђ¥‚”‚ init_withÁ…¦…,impl FnOnce(usize, &Slot<T, C>) -> Option<U>Á… ‚allocateÁ‰ ‚
mark_clearÁ‹—‹ � ‚Í�—� ‘ Гה Ж”–¥–×Ð š”š×Ð
�”��Ð  ”Ð ¢”¢ï
Ð
¥”¥‹Ð¨”¨ƒÐ«”ÐindicesÁ­”Ò ¯¯¯¯¯¯¯¯¯¯ ¯
¯ ¯ ¯
¯¯¯¯¯¯¯ShardÁĥĔÄtidÁÄ®ÄsharedÁ¯Mʥʔʒ ÊmaxÁ¯Ï¥Ï”ϧ1Ò´ Ò¦Ò.impl FnOnce(&'a page::Slot<T, C>) -> Option<U>ÁÏæ Ö Ö ¯Ù¥Ù”Ù
take_localÁÙ take_remoteÁÙ remove_localÁÙ
remove_remoteÁÙù¯á¥á”á 3ä¦ä1impl FnMut(usize, &page::Slot<T, C>) -> Option<U>Áámark_clear_localÁámark_clear_remoteÁáclear_after_releaseÁá clear_localÁá clear_remoteÁᮯí¥í”íׯñ¥ñ”ñæ ñ«ñcurrentÁö ñú¯ù¥ù”ùã¯ý¥ý”ýׯ�¥�”�—
�¬�setÁ¯‡´ ‡¥‡”‡›‡ó –7���������� �
� � �
�������TidÁ¢”¢idÁ¢ _not_sendÁ¢Ÿ �RegistryÁ§ó §freeÁ�ª”ª¾!ªÉ!ªÝ!ª€�°”°Ü;² °
is_currentÁ´ °æ �·”·poisonedÁ· is_poisonedÁ�»”»×�¾”¾��Á”�ÔÃ�Æ”�Èæ ÈÜ;Ê”ÈregisterÁÌ”Ì Ì � ÐãÑ 
  
SlabÁâ¥â”⒠⟠EntryÁç´ ç¥ç”ç®ç»çÒ çÞ 
OwnedEntryÁï¥ï”ï®ï»ïç/ïÞ ö¥öæ ö˜
ù”û¥û”ûÇ
ûÉ#ÿ ÿ û vacant_entryÁ‚ ûÉ2„ „ û°2û«ˆ û¹Š ûcontainsÁû unique_iterÁŽ¥Ž>‘¥‘”‘ו¥•”˜¥˜”›´ ›¥›”›Þ ›»¡´ ¡¥¡”¡å¡´§´ §¥§”§ã ¬´ ¬¥¬”¬×
±´ ±¥±”±� ´ ¥”É#Þ  ¼¥¼”¼Þ ¼»
Á¥Á”ÁåÁ´Æ¥Æ”ÆãʥʔÊ×ΥΔÎ�Ò¥Ò”Õ¥Õ”PackÁؔؾ!ØÉ!ØBITSÁØSHIFTÁØMASKÁØÝ!Ø€ØpackÁØ from_packedÁã”ãðHã¾!ãüHã‰IãÉ!ãÝ!ã€ã¥Iã±IÔ
DefaultConfigÁî_pÁÔÔÔòƒ‚
UnsafeCellÁô
ô¥ôˆ‚ø¥øוTrackÁû¥û»•þ¥þו�¥�>¾
UniqueIterÁ„´ „¥„”„’ „pagesÁ„slotsÁ¾‹´ ‹¥‹”‹××GuardÁ�¥�”�â× ”¥”””×× InitGuardÁ˜¥˜”˜â˜curr_lifecycleÁ˜releasedÁ×!ž¥ž”ž××StateÁ¢PresentÁ£
£ ¢MarkedÁ¦
¦ ¢RemovingÁ©
© ×"¬××#®Ö×$×%±�×&×'×(µƒ¯PtrÁ·
·¥·”·ˆ¯ ¼¥¼”¼×¯IterMutÁÀ
À´ À¥À”Àˆ¯
Æ´ ƥƔÆ×� RegistrationÁË
ˈ�
Î×�REGISTRYÁÐ__private_fieldÁ�ÖP� ÓåÓ´Õ__static_ref_initializeÁÕ __stabilityÁ� Ø
initializeÁ×LAZYÁ� REGISTRATIONÁÛ__rust_std_internal_init_fnÁÛ Ý Þ__RUST_STD_INTERNAL_VALÁÝ à°R VacantEntryÁâ´ â¥â”â®âÞ â_ltÁé´ é¥é”é×@
D
D
F
J
Y
Y
Y
^
_
e
j
o
o
o
t
t
y
{
�
†
‹
�
�
�
•
•
™
š
Ÿ
£
§
§
§
«
«
µ
·
¸
½
Á
Å
É
É
É
Í
Í
ü
ü
ü
ÿ
ÿ
ÿ
�
’
™
š
£
¦
©
¬
±
µ
·
º
½
Ë
Í
†
�
�
‘
“
”
•
•
•
š
ž
 
 
¡
¡
£
£
ª
ª
¬
¬
³
·
·
·
º
º
º
À
À
Å
Å
È
È
Ë
Ñ
Ò
Ó
ß
â
â
ç
ç
ç
í
õ
õ
õ
ø
ø
ý
ý
€
€
ƒ
‹
�
�
’
”
•
–
—
¨
©
­
­
²
²
²
Â
Â
È
Ü
Þ
â
â
é
é
ê
ñ
÷
÷
ú
ú
ÿ
…
…
…
‰
‹
‹
�
�
”
”
”
™
™
™
œ
œ
œ
Ÿ
Ÿ
¤
¤
§
§
ª
Ü
Ý
Þ
ß
à
ä
ä
ç
è
é
ê
ë
ì
ð
ð
ð
õ
ö
ø
ü
€
€
€
…
†
Œ
®
º
½
½
½
À
À
Å
Ê
Ì
Ñ
ÿ
‚
„
‡
ˆ
Œ
�
”
”
”
Ÿ
 
¦
«
°
°
°
µ
µ
»
¿
À
Å
É
Í
Í
Í
Ñ
Ñ
ß
á
ê
ì
ó
ú
ú
ú
€
€
€
�
�
�
—
—
—
¡
¡
¡
­
­
­
¯
²
²

¿
¿
¿
Ê
Ê
Ê
Ï
Ï
Ï
Õ
Ù
í
í
í
Þã¢ÀØÌìù
’ Ÿ KŽ€NՀ”� Î_³ù
’ Ÿ KŽ€NՀ`îî˜Jï­JÔÜí%–YÜ¿cÎ_é!ª !®"Ò #Þ ò@÷¾À¹ü·´ ¥”Œ"•a¿c•aµß•aÙaé!$$è (®)Ò *Þ ðï=®~M3&´ Ùaßaö!ŽbŒ"Žb¿cŽbµßŽbÙaé!++Ÿ .®/²
0Þ XÒÐX7‚`ˆ`Œ"‹c¿c‹cµß‹c‚`� ‹cÌì‹cé!11Ñ 4®5²
6Þ ..Öã¦ð ‚`ˆ`ö!�dŒ"�d¿c�dµß�d‚`� �dÌì�d㔊 Ö`ÛÖ`ØÖ`ÞÖ`¿cÖ`¿còòíôŸ ÔìõéÑ3%~‘™e¿côôõÎJ÷ˆ‚ Ÿ´6@~’‚`¿cûûŠKý»•cÙcÎ4
!‚`³Ìf¢Û¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙ‚`¢��žBoxÁ¡ˆˆ¢‰ˆl }.xÏ‚`çEçEèEGlobalÁ ¿±‡§í#¢ªBªBö­BbufÁ÷<®B‘÷<9)
-ÜnL‚`¡h¢ðð�õbaseÁÜ¿¦p<JÔÏÏœ§¤¡h¢¡
¡
�¥
±hŒ
šI¼²'‡Õï‚`¤¡h¢úHúHßûHÁ‘4Ý­f‰úM÷¢µ>µ>¤·>®£>¸>poisonÁ£>¹>dataÁ£>Ë»™z™g—‚`¢°?°?Ò²?®�?³?�j�?´?“j�?R£W„ôÌ‚`¿c„„ÐKˆ’ ‰‚LŠ�LÒ Otõ¨ˆ´ ÙaßaùMŒlòP„„ÐKˆ’ ‰‚LŠ�LÒ Otõ¨ˆ8Ùaßa¿c��ÁL“â×—¹þWÄS®‚`ˆ`¿c˜˜ƒM›âל¬M×�ÂM×29¨°Ñë‚`ˆ`¿c¢£¤üM¥¦§•N¨©ª­N«hX¤Çt0¶™ÏnÐìÏnµßÏnÏnŠ ÏnÛÏnØÏnØññ� ó»×ôŸ ×_H5“h^o™e™e¿cêêÈíä×îó ×ï÷×ðŸ ×Áqq8<g‚`ˆ`¿cåoµßåoåo™åoíßåoåoºåoØåoŠ åoØùùß ûº×üŸ ×Nǃy"™e™eµßÙqÙq™Ùq¿cÙqØõõ· ÷»×øŸ ×$¶ùˆs6>Ιe™e¿cÂrµßÂrÂr™ÂríßÂrÂrºÂrØÂrŠ ÂrØýýþˆ!€ˆ× 2h m8õ»™e™eÀ¡¡ƒ,£ ,™¤Ÿ ™f
Ú5*¶\\™e™e¿c–tØ··Å-¹Ù-кŸ ЛÅ]ᱎ>Ç™e™eÀÎÎ�/Ï ,ÐÇî;�z©}™e¿c®u¿cÐФ/ÓÂ/ÐÔ™ÐÕØ/ÐÖç/ÐÚp.IDï_ï™eÙa¿cçtµßçtçt™çtíßçtçtºçtØçtŠ çt¿c··¸ŠO»ˆ¯ ³¢…`�SÇ{‚`ˆ`¿cÀÀÁÏOň¯ É6¼3쥚á´ Ùaßa¿cÄÄù6Ç–7È®¯É©7¯`D!β+6û‚`ˆ`Œ"ÊÊMÍ’ ¯ÎÖ7¯,+3m^;®‚`ˆ`¿cóxùMÜw¿cËĘ̈P͈� 5Ë>dð„Šé!ÐÐÖPÑæP�ÁÇDDÖuL—†zØ¢¢ú=¤�>�¥—>�¦Ÿ �9ɯñž¯‘C™e™e¿cÄzµßÄzÄz™ÄzØÄzŠ ÄzŒ"Íy¿cââÛRæ®çÞ è–S¯Ñ¤ð*ñ ‰´ Ùaßa³ââÏAå’ æŸ >[täƹc‚`Ö`¿cââÏAå’ æŸ >[täƹc‚`ˆ`Ììò|� ò|é!ççúAë®ì»íÒ îÞ Ö»¶
ž!ú8´ ÙaßaŒ"Ì}¿cÌ}µßÌ}Ùaé!ïï¾Bò®ó»ôç/õÞ Tò\hبúj‚`ˆ`Œ"Ï~¿cÏ~µßÏ~‚`� Ï~ÌìÏ~Ø™eM¯+Ñ1•âÕïP¬+Î1˜âÒïS�ûŽâVkŒ$¤+Æ1ûîýòøôþû‹„”�ž˜¬¢´ê¸ñåùóõ°¡“ΖК·¼·ÆÀíÄýÊÎË»¢éâ‘â¬çÊï`|$›+¹1ÓСçÁïf‡$ +Â1ùÊÐ˧çÆïp‘$¨+Ê1±¢¾ñàùöõ�·¾¢±çÎï‚$¾1ððî³¢Ìñ„õ«·Æ¢ñî´¢òîµ¢Éñ�õ¨·Ã¢÷î¤Û¼§�ªªB­ð²¡
úH¸µ>»°?Æ„‡ÀÍ„®¢Áñãùùõ ·Á¢°¢�ñÚùèõ†ýÄ·ª¢ã
Ãñûõ¢·Æñþõ¥·«¡àÎØÐÌìµ� ³¿cé!ÒŒ"+µß 3ö!Oã Š Û*ØÞ*¢ùM9òP™
äˆ`ü¾k*?,Ók$Däˆ` C::USED_BITSÁÔù
ßÖ`üÞ6ß,ñ%DßÖ`DefaultConfig::MAX_THREADSÁÄ‹
àÖ`üò2à,ƒ%DàÖ`DefaultConfig::MAX_PAGESÁüž  áÖ`üý
Bá,– %EáÖ` DefaultConfig::INITIAL_PAGE_SIZEÁ0Áü›3¼›Úññ� ó»×ôŸ ×_H5“h^oâ‹̵ݨ‹â‹w yÚ¨‹â‹<ݨ‹â‹²ü‚Mä,“ë/êÚ¨‹â‹¬Ý¨‹â‹Ú¨‹â‹Õݨ‹â‹_Áüî"

Lî
ö¼øáâ‹7üÔ=å,æ%Iáâ‹_Á¬ºŒºßâ‹ Î: 7ßâ‹5nü° 

L°ý�š% Ïü–;æ,¨ÕõŒÝ4×ßâ‹çßâ‹_Áüö*üö!
t‡
œÕ„öåâ‹„‡M Ÿüö. £% 'KKüÖOç,îêèõŒ–;×åâ‹_ÁäÕ!
ÔÕ!
À*üÕ!  ô!% 'KKüµ!Aõ,Í!µõŒ�4_Á$³"tº" º"
"T¼"
™Õ0d¼" Ç"œº" Ì",×" ß"Œß"
 lá"
›Õ2|á" ï"üû"(´ü"t„# ,„#

 
 ‘#
9 ,ü"õ U  !õ u S l•# $•#

 
 ¡#
Ä Õ  ì ¢# üö"-@#  ö"H#t ¤#¥#öüø!­ü¯"vüÓ"R,£" –"‘‘‘//ïîîîõŒ…„õŒ(&¹{pow2ÁzerosÁ¬Ðõ*õ 32Á4096ÁLš& ¢&3 ,š&õN õXü�&#ú,’&›+iõtõ_Á0b00Á0b01Á0b11Áüœ  T� õ„ª â™e4 0õ.â™eaüœ -\¾ Ýåo™e& (Ýåo™eM È ü‰ Aƒ,” ûõŒõŒœ=õâ™e!õâ™eÐÝåo™eâÝåo™e_Ál®©  ¢\Ë©  • ™eáü˜©E ù™e Ü© üƒ©[×Ùq$‘©Ïn–• • – PhantomDataÁFu\»ŸÆ¡µg_Á|�ª  ¢\¯ª  • Æ¡üú©G ù™e Àª üã©_ØÙq$ó©Ïn�¯¢}6_Átóª  ¢\‘«  • Æ¡üݪF ù™e ¢« üǪ]ÙÙq$ÖªÏn�¯¢}6_Á2ÁüÚ²,
œÛ²ÚÙq™e¤ñ²Úåo™eA <ÚÙq™e9Úåo™exüͲ9TͲõ! "õA …³üº²Mê,Ų õŒõŒ”@ÚÙq™eÚåo™e9ÚÙq™e6Úåo™eÞõéõ_ÁtÒµTÒµÜÂr™e ßµ9 ;ÜÂr™e8oü´µ-ð,ʵõŒ¨/§ÜÂr™e¹ÜÂr™e_Á¤Ö¿ Úåo™eüÿ(ˆ,ο'KÚåo™eGeneration<C>::LENÁ8ÁtœTœÜçt™e ©6 9Üçt™e7lüˆ#½,”õŒ£-£Üçt™eµÜçt™e_Áüƒ
"dƒ
à™eœ’
ç™e2 4à™e2ç™ecüð 6Æ,û õŒš-™à™e–ç™e·à™e´ç™e_Á|æ
½ˆ`üÒ$ç,Þ%E½ˆ`
Addr<C>::NULLÁùù
·™e
éù
·e
¾Íyùù
ÕúeÝÛ¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙ Û¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙÍy Íyƒ±³ãùø
�f�aÛ®®£°®¨it§ÅLS¶Íyáø
¢faZ݃±ƒ±_Áùù
ðe
éù
ðe
ÐÍy17ùù
¦®e
 Þˆ±›²á2ƒ± ù
¿eùù
íÔeùù
‚!­e
 à•´á%ƒ± ù
›!eR ù
À$eùù
Ûôe݃±!#Þ•´áóà•´á¨W_Áüð'ôð
tþª‘lðæ™e„þH –üð+ š% 'KKüÝ?¬,èåãõŒ–;Öæ™e_ÁdŽs
äˆ`üñr*þ,†s%Eäˆ` C::USED_BITSÁ,Ä‘|Ñ‘ LÒ‘Ú⋈` Þ‘@ <Ú⋈`9w¤Ì‘@#  Ì‘I$ ß‘,ê‘ \ò‘,ó‘  û‘@ (f ü‘œê‘
! ‚’ü¢‘bÜüÀ‘C ,®‘ëêõŒót ÿõŒshiftÁ3‚%Ú⋈`9Ú⋈`_Áüö“#Œö“Ý⋈`Ûˆ`|Š”Ú¹¾ˆ`G Hݹ¾ˆ`;Ú¹¾ˆ`€üá“9Ý,î“õŒ¹/·Ý¹¾ˆ`©Ú¹¾ˆ`Ýݹ¾ˆ`ÏÚ¹¾ˆ`_ÁÌÉ•\וÝ⋈`#@7 TÉ•Ü⋈`MÝ⋈`p7Ü⋈`�Ý⋈`üµ•.Þ,Á•É-ÈÝ⋈`¥Ü⋈`îÝ⋈`ËÜ⋈`Ý⋈`_Á0Á0Á0Á0Áü¿ ô‚`õ)�f4î0î0ÎJð0»Ì-·}—KEüC£‚`ip´¬ ý™eþ(×s3åo:Aì¤ ·‚`ˆ`¸+�w6¤]¤]V¦]Á‚]üß3ø¤”& ûûŠKý»•cÙcÎ4
!¡xš¡üû9 ÀÙaßa!Á.ÀÀÁÏOň¯ É6¼3쥚áÙaßapÜlÜlÏOßlµ ™làl
end_or_lenÁ™lál_markerÁ™lÚ½íDþïl%··¸ŠO»ˆ¯ ³¢…`�SÇ{Ùaßa
œ» ËÌ%Íy0á.á.aã.»Ì-IÜž�B2®Û¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙ©°Ô€œ¾Ð¯�âçïØâÀ´4ŒHÞÕ˜Jl”HîÖû,¯H¢×ÐKTÀH„Øù
$ìHÙú=‡I¢Ú”T–IãÛù6,­IÄÜ×¾I¤,Þ½¡\ËI• ß½¡– ßµ ØI“àKãI†JáüÜ�ü  A lock-free concurrent slab.Á!úü%KH Slabs provide pre-allocated storage for many instances of a single dataÁüqFC type. When a large number of values of a single type are required,Áü¸PM this can be more efficient than allocating each item individually. Since theÁü‰KH allocated items are the same size, memory fragmentation is reduced, andÁüÕ63 creating and removing new items can be very cheap.ÁŒúü�KH This crate implements a lock-free concurrent slab, indexed by `usize`s.ÁÜúdà ## UsageÁíúüñ)& First, add this to your `Cargo.toml`:Á›ú\Ÿ ```tomlÁÔ« sharded-slab = "0.1.1"Á<Æ ```ÁÎúüÒHE This crate provides two types, [`Slab`] and [`Pool`], which provideÁü›52 slightly different APIs for using a sharded slab.ÁÑúüÕNK [`Slab`] implements a slab for _storing_ small types, sharing them betweenÁü¤FC threads, and accessing them by index. New entries are allocated byÁüëFC [inserting] data, moving it in by value. Similarly, entries may beÁü²LI deallocated by [taking] from the slab, moving the value out. This API isÁüÿNK similar to a `Vec<Option<T>>`, but allowing lock-free concurrent insertionÁ„Î
and removal.ÁßúüãJG In contrast, the [`Pool`] type provides an [object pool] style API forÁü® OL _reusing storage_. Rather than constructing values and moving them into theÁüþ OL pool, as with [`Slab`], [allocating an entry][create] from the pool takes aÁüÎ
OL closure that's provided with a mutable reference to initialize the entry inÁüž KH place. When entries are deallocated, they are [cleared] in place. TypesÁüê JG which own a heap allocation can be cleared by dropping any _data_ theyÁüµ MJ store, but retaining any previously-allocated capacity. This means that aÁüƒ
NK [`Pool`] may be used to reuse a set of existing heap allocations, reducingÁœÒ
 allocator load.Áæ
úìê
 [inserting]: Slab::insertÁĈ [taking]: Slab::takeÁÔ¡ [create]: Pool::createÁ¤¼ [cleared]: ClearÁüÑDA [object pool]: https://en.wikipedia.org/wiki/Object_pool_patternÁ–útš # ExamplesÁ©úü­85 Inserting an item into the slab, returning an index:Á\æ ```rustÁìò # use sharded_slab::Slab;ÁÜ� let slab = Slab::new();Á¬úü°2/ let key = slab.insert("hello world").unwrap();Áüã63 assert_eq!(slab.get(key).unwrap(), "hello world");Á<š¦Ñ¢úü¦B? To share a slab across threads, it may be wrapped in an `Arc`:Á\éÏÞìõãÞ¼“ use std::sync::Arc;Áü«%" let slab = Arc::new(Slab::new());ÁÑúìÕ let slab2 = slab.clone();Áüó.+ let thread2 = std::thread::spawn(move || {Áü¢A> let key = slab2.insert("hello from thread two").unwrap();ÁüäEB assert_eq!(slab2.get(key).unwrap(), "hello from thread two");Á\ª keyÁ<¶ });Á¾úüÂ=: let key1 = slab.insert("hello from thread one").unwrap();Áü€A> assert_eq!(slab.get(key1).unwrap(), "hello from thread one");ÁÂúüÆ%" // Wait for thread 2 to complete.Áüì'$ let key2 = thread2.join().unwrap();Á”úü˜96 // The item inserted by thread 2 remains in the slab.ÁüÒA> assert_eq!(slab.get(key2).unwrap(), "hello from thread two");Á4”```Á›úüŸOL If items in the slab must be mutated, a `Mutex` or `RwLock` may be used forÁüïKH each item, providing granular locking of items rather than of the slab:Á»ú\¿ÏÞìËãÞüé  use std::sync::{Arc, Mutex};ÁüŠ%Õá°úü´LI let key = slab.insert(Mutex::new(String::from("hello world"))).unwrap();Á�úì…�âü£.¶âüÒ:7 let hello = slab2.get(key).expect("item missing");Áü�>; let mut hello = hello.lock().expect("mutex poisoned");ÁüÌ1. *hello = String::from("hello everyone!");Á<þ›ä†úäŠ thread2.join().unwrap();Á§úü«52 let hello = slab.get(key).expect("item missing");Áüá:7 let mut hello = hello.lock().expect("mutex poisoned");Áüœ2/ assert_eq!(hello.as_str(), "hello everyone!");Á<ϦÑ×úœÛ # ConfigurationÁïúüóNK For performance reasons, several values used by the slab are calculated asÁüÂPM constants. In order to allow users to tune the slab's parameters, we provideÁü“MJ a [`Config`] trait which defines these parameters as associated `consts`.Áüá<9 The `Slab` type is generic over a `C: Config` parameter.Áž úü¢ ! [`Config`]: trait.Config.htmlÁÄ úüÈ $! # Comparison with Similar CratesÁí úüñ PM - [`slab`]: Carl Lerche's `slab` crate provides a slab implementation with aÁüÂ!FC similar API, implemented by storing all data in a single vector.Á‰"úü�"JG Unlike `sharded_slab`, inserting and removing elements from the slabÁüØ"GD requires mutable access. This means that if the slab is accessedÁü #NK concurrently by multiple threads, it is necessary for it to be protectedÁüï#HE by a `Mutex` or `RwLock`. Items may not be inserted or removed (orÁü¸$FC accessed, if a `Mutex` is used) concurrently, even when they areÁüÿ$PM unrelated. In many cases, the lock can become a significant bottleneck. OnÁüÐ%JG the other hand, this crate al
*Ùú=*¢Ú”
*ãÛù6 *ÄÜ× *¤,Þ½¡
*• ß½¡*– ßµ 
*“àK *†Já+++TàF4äFÌd
  ´ ,, ! " *, #8argÁ$& '8¯(
+*. 1 ² 8;8â> A B G8‚$CI8âL O P [8
slab_printÁTQ ] ¬
8k8Àn'q8Š4s'y8ì
L{ „ … ‡ �8printlnÁ<§ ® ¯ ó
7[PANIC {:>17}:{:<3}] {}ÁÌ°$ É8Ì$Ë Ï Ð Ñ$ Ò8š$Ô Ø Ù Ú$ Û8ë\Ý è é ò, ê ë ð, ì8Ÿ í
ñ8$ƒ ˆ ¢8�¢<š ¡ ¢ ”7[{:?} {:>17}:{:<3}] {}ÁÄ£$ »8,½'Â8ú=Ä'Ç É8,Ê'Ï8˜JlÑ Þ'ß8Ü;<á è é$ ê8Ì$ì ð ñ ò$ ó8š$õ ù ú û$ ü8ë\þ ‰ Š “, ‹ Œ ‘, �8Ÿ Ž
’Ô”l¡ ¯ ö
 µ Á,  · ¿, ¸8Ÿ ¹& ¼8¯½
À*Ã Æ ô
 8Ð Ó8ÀÔ'×8Š4Ù'ß8ì
Lá ê ë í ”8Á
,û € � Š, ‚ ƒ ˆ, „8Ÿ …
‰8$– › î
8©8Š4­ ´8À'¹8Š4»'Á8Ü;<Ã Ê Ë% Ì8eprintlnÁDÚ â ã ã
$7�thread '{thread}' attempted to panic at '{msg}', {file}:{line}:{col}\n\
note: we were already unwinding due to a previous panic.Áüõ’$ ‡ 8Š4™   8Š4¢  ¨ 8Ð $©  ­ ®  ¯ 8¤L°  ¹ Å 7 <unnamed>Á\º $ Æ 8msgÁØ Ü 8ë\Þ  é  ê ó , ë  ì ñ , í 8Ÿ î 
ò $ ô 8Ì$†
‹
8Ì$�
 ‘
 ’
“
$ ”
8š$¦
«
8š$­
 ±
 ²
³
$ ´
8colÁÆ
Ê
8�4Ì
 Ò
 Ó
Ô
$ Õ
% ä
üù
$¼†  ž Ù  ¤ »  , ¥ 8thisÁ$¦ & ª 8›$« $ ¯ , ± 8thatÁ$² & 8›$· *½  À € 8ÿ ¼Ê  á  â ú   ã 8®,ä , ê 8ÿ®$ë $ ï , ñ 8®¯$ò $ ö 7úø % �  ‡ « 
, ˆ 8ÿ®$‰ & � 8›$Ž $ ’ , ” 8®¯$• & ™ 8›$š $ ž ,    ¡ © , ¢ 8Ÿ £ & ¦ 8¯§  ª *­  ° š
8ÿ ¼º  Ñ  Ò ”
  Ó 8®,Ô , Ú 8ÿ®$Û $ ß , á 8®¯$â $ æ 8ë\è  ó  ô “
7: {}Á4õ $ û 8ë\ý  ˆ
 ‰
’
, Š
 ‹
�
, Œ
8Ÿ �
 ‘
% ›
 ¡
Ê
 ¢
8®,£
, ©
8ÿ®$ª
& ®
8›$¯
$ ³
, µ
8®¯$¶
& º
8›$»
$ ¿
, Á
8»¬Â
& Å
8›$Æ
*Ì
 Ï
×8Ù
8âÜ
 ß
 à
ñ
8�„á
 ó
Ñ8�, „8ÿ®$…Š, �8®¯$Ž “ Ç8ë l¥ ² ³ ¹7>assertion failed ({} == {})\n left: `{:?}`,\n right: `{:?}`{}ÁüÉ@$ ‰8ÔLŸ ¨ © ¯, ª8ÿ®$«$ °8ÔLÆ Ï Ð Ö, Ñ8®¯$Ò$ ×, í8ÿ®$î$ ò, ˆ8®¯$‰$ �, £8»¬¤$ §´íFü`8
5 Notes on `sharded-slab`'s implementation and design.Á™
úd�
# DesignÁª
úü®L
I The sharded slab's design is strongly inspired by the ideas presented byÁüûB
? Leijen, Zorn, and de Moura in [Mimalloc: Free List Sharding inÁü¾O
L Action][mimalloc]. In this report, the authors present a novel design for aÁüŽ@
= memory allocator based on a concept of _free list sharding_.ÁÏ
úüÓN
K Memory allocators must keep track of what memory regions are not currently矢N
K allocated ("free") in order to provide them to future allocation requests.ÁüñN
K The term [_free list_][freelist] refers to a technique for performing thisÁüÀO
L bookkeeping, where each free block stores a pointer to the next free block,Áü�K
H forming a linked list. The memory allocator keeps a pointer to the most矆O
L recently freed block, the _head_ of the free list. To allocate more memory,Áü¬L
I the allocator pops from the free list by setting the head pointer to theÁüùO
L next free block of the current head block, and returning the previous head.矃N
K To deallocate a block, the block is pushed to the free list by setting itsÁü˜ P
M first word to the current head pointer, and the head pointer is set to pointÁüé O
L to the deallocated block. Most implementations of slab allocators backed byÁü¹
M
J arrays or vectors use a similar technique, where pointers are replaced byÁü‡ #
indices into the backing array.Á«
úü¯ M
J When allocations and deallocations can occur concurrently across threads,Áüý J
G they must synchronize accesses to the free list; either by putting theÁüÈ M
J entire allocator state inside of a lock, or by using atomic operations toÁü–
P
M treat the free list as a lock-free structure (such as a [Treiber stack]). InÁüç
N
K both cases, there is a significant performance cost — even when the freeÁü¶L
I list is lock-free, it is likely that a noticeable amount of time will beÁüƒM
J spent in compare-and-swap loops. Ideally, the global synchronzation point矄P
M created by the single global free list could be avoided as much as possible.Á¢
úü¦H
E The approach presented by Leijen, Zorn, and de Moura is to introduceÁüïP
M sharding and thus increase the granularity of synchronization significantly.ÁüÀF
C In mimalloc, the heap is _sharded_ so that each thread has its ownÁü‡N
K thread-local heap. Objects are always allocated from the local heap of theÁüÖL
I thread where the allocation is performed. Because allocations are always矣C
@ done from a thread's local heap, they need not be synchronized.Áç
úüëM
J However, since objects can move between threads before being deallocated,Áü¹J
G _deallocations_ may still occur concurrently. Therefore, Leijen et al.Áü„M
J introduce a concept of _local_ and _global_ free lists. When an object isÁüÒO
L deallocated on the same thread it was originally allocated on, it is placed矢N
K on the local free list; if it is deallocated on another thread, it goes onÁüñP
M the global free list for the heap of the thread from which it originated. ToÁüÂK
H allocate, the local free list is used first; if it is empty, the entireÁüŽM
J global free list is popped onto the local free list. Since the local free矆O
L list is only ever accessed by the thread it belongs to, it does not requireÁü¬K
H synchronization at all, and because the global free list is popped fromÁüøN
K infrequently, the cost of synchronization has a reduced impact. A majority矂D
A of allocations can occur without any synchronization at all; andÁüŒJ
G deallocations only require synchronization when an object has left itsÁü×/
, parent thread (a relatively uncommon case).Á‡
úü‹`
] [mimalloc]: https://www.microsoft.com/en-us/research/uploads/prod/2019/06/mimalloc-tr-v1.pdfÁüì7
4 [freelist]: https://en.wikipedia.org/wiki/Free_listÁü¤@
= [Treiber stack]: https://en.wikipedia.org/wiki/Treiber_stackÁå
ú¤é
 # ImplementationÁþ
úü‚J
G A slab is represented as an array of [`MAX_THREADS`] _shards_. A shardÁüÍI
F consists of a vector of one or more _pages_ plus associated metadata.Áü—O
L Finally, a page consists of an array of _slots_, head indices for the localÁÔç
 and remote free lists.Á‚
ú\†
 ```textÁü’ 1
. ┌─────────────â”�Á¼Ä
 │ shard 1 │ÁüÜ n
k │ │ ┌─────────────â”� ┌────────â”�ÁüË!Z
W │ pages───────┼───▶│ page 1 │ │ │Áü¦"Ž
‹ ├─────────────┤ ├─────────────┤ ┌────▶│ next──┼─â”�Áüµ#Z
W │ shard 2 │ │ page 2 │ │ ├────────┤ │Áü�$d
a ├─────────────┤ │ │ │ │XXXXXXXX│ │Áüõ$b
_ │ shard 3 │ │ local_head──┼──┘ ├────────┤ │ÁüØ%l
i └─────────────┘ │ remote_head─┼──â”� │ │◀┘ÁüÅ&f
c ... ├─────────────┤ │ │ next──┼─â”�Áü¬'t
q ┌─────────────â”� │ page 3 │ │ ├────────┤ │Áü¡(d
a │ shard n │ └─────────────┘ │ │XXXXXXXX│ │Áü†)p
m └─────────────┘ ... │ ├────────┤ │Áü÷)`
] ┌─────────────â”� │ │XXXXXXXX│ │ÁüØ*V
S │ page n │ │ ├────────┤ │Áü¯+b
_ └─────────────┘ │ │ │◀┘Áü’,]
Z └────▶│ next──┼───▶ ...Áüð,L
I ├────────┤Áü½-<
9 │XXXXXXXX│Áüú-L
I └────────┘Á<Ç.
¦ÑÏ.
úÓ.
úü×.M
J The size of the first page in a shard is always a power of two, and every矴/L
I subsequent page added after the first is twice as large as the page thatÁ„ò/
preceeds it.Áƒ0
ú\‡0
ÕÜ“0
ú<—0
 pg.ÁüŸ0%
" ┌───â”� ┌─┬─â”�ÁüÅ0!
 │ 0 │───▶ │ │Áüç01
. ├───┤ ├─┼─┼─┬─â”�Áü™1)
& │ 1 │───▶ │ │ │ │ÁüÃ1I
F ├───┤ ├─┼─┼─┼─┼─┬─┬─┬─â”�Áü�29
6 │ 2 │───▶ │ │ │ │ │ │ │ │ÁüÇ2y
v ├───┤ ├─┼─┼─┼─┼─┼─┼─┼─┼─┬─┬─┬─┬─┬─┬─┬─â”�ÁüÁ3Y
V │ 3 │───▶ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │Áü›4y
v └───┘ └─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┘Á<•5
¦Ñ�5
úü¡5O
L When searching for a free slot, the smallest page is searched first, and ifÁüñ5P
M it is full, the search proceeds to the next page until either a free slot isÁüÂ6P
M found or all available pages have been searched. If all available pages haveÁü“7M
J been searched and the maximum number of pages has not yet been reached, aÁüá7
 new page is then allocated.Á�8
úü…8O
L Since every page is twice as large as the previous page, and all page sizesÁüÕ8L
I are powers of two, we can determine the page index that contains a given矢9F
C address by shifting the address down by the smallest page size andÁüé9G
D looking at how many twos places necessary to represent that number,Áü±:D
A telling us what power of two page size it fits inside of. We canÁüö:I
F determine the number of twos places by counting the number of leadingÁüÀ;I
F zeros (unused twos places) in the number's binary representation, andÁüŠ<C
@ subtracting that count from the total number of bits in a word.ÁÎ<
úüÒ<P
M The formula for determining the page number that contains an offset is thus:Á£=
ú”§=
 ```rust,ignore矼=I
F WIDTH - ((offset + INITIAL_PAGE_SIZE) >> INDEX_SHIFT).leading_zeros()Á<„>
¦ÑŒ>
úü�>J
G where `WIDTH` is the number of bits in a `usize`, and `INDEX_SHIFT` isÁÛ>
ú”ß>
ïýüò>+
( INITIAL_PAGE_SIZE.trailing_zeros() + 1;Á<ž?
¦Ñ¦?
úüª?v
s [`MAX_THREADS`]: https://docs.rs/sharded-slab/latest/sharded_slab/trait.Config.html#associatedconstant.MAX_THREADSÁtõFd…Gü'$ A lock-free concurrent object pool.Á(úü,ZW See the [`Pool` type's documentation][pool] for details on the object pool API and howÁü‡%" it differs from the [`Slab`] API.Á­úü± [pool]: ../struct.Pool.htmlÁüÑ! [`Slab`]: ../struct.Slab.htmlÁ$�G$+1â$ŠÔ ”T�ã ˜Jlœî
û,·¢¸$ÂÐÒ ,ȯú=Ø¢ÌH$áØù6,çÄÜ×ü¤,½¡\‰• ½¡– Kœ†J,÷„÷„õ÷æèd°ÛÊÌ»½DÓ°Ÿ¡�’ö�ƒœ�uL–Uüô%ü£'¼�ËúüÏc` Slabs provide pre-allocated storage for many instances of a single type. But, when working withÁü³^[ heap allocated objects, the advantages of a slab are lost, as the memory allocated for theÁü’_\ object is freed when the object is removed from the slab. With a pool, we can instead reuseÁüò\Y this memory for objects being added to the pool in the future, therefore reducing memoryÁüÏ63 fragmentation and avoiding additional allocations.Á†úüŠc` This type implements a lock-free concurrent pool, indexed by `usize`s. The items stored in thisÁüî30 type need to implement [`Clear`] and `Default`.Á¢úü¦`] The `Pool` type shares similar semantics to [`Slab`] when it comes to sharing across threadsÁü‡ `] and storing mutable shared data. The biggest difference is there are no [`Slab::insert`] andÁüè b_ [`Slab::take`] analouges for the `Pool` type. Instead new items are added to the pool by usingÁüË
WT the [`Pool::create`] method, and marked for clearing by the [`Pool::clear`] method.Á£ út§ êÝ úüº 1. Add an entry to the pool, returning an index:Á<ì ¦Ñìô  # use sharded_slab::Pool;Áü’ )& let pool: Pool<String> = Pool::new();Á¼ úüÀ MJ let key = pool.create_with(|item| item.push_str("hello world")).unwrap();ÁüŽ
DA assert_eq!(pool.get(key).unwrap(), String::from("hello world"));Á<Ó
¦ÑÛ
úüß
KH Create a new pooled item, returning a guard that allows mutable access:Á<«¦Ñ쳋�üÑ)²�ûúüÿ+( let mut guard = pool.create().unwrap();ÁÔ« let key = guard.key();ÁüÆ" guard.push_str("hello world");ÁéúüíA> drop(guard); // release the guard, allowing immutable access.Áü¯DÈ‘<ô¦Ñüúü€SP Pool entries can be cleared by calling [`Pool::clear`]. This marks the entry toÁüÔ=: be cleared when the guards referencing to it are dropped.Á<’¦Ñìš‹�ü¸)²�âúüæMñ�´úü¸%" // Mark this entry to be cleared.Á¤Þ pool.clear(key);Áóúü÷;8 // The cleared entry is no longer available in the poolÁü³%" assert!(pool.get(key).is_none());Á<٦ќáèîõúüùpm Both `Pool` and [`Slab`] share the same configuration mechanism. See [crate level documentation][config-doc]Á¬ê for more details.Á€úü„%" [`Slab::take`]: crate::Slab::takeÁüª)& [`Slab::insert`]: crate::Slab::insertÁüÔ" [`Pool::create`]: Pool::createÁü÷  [`Pool::clear`]: Pool::clearÁü˜%" [config-doc]: crate#configurationÁܾ [`Clear`]: crate::ClearÁÌÚ [`Slab`]: crate::SlabÁ$ÿ¥”Íì‚` „Íìˆ`Œ‡¢‚`,§³‚`<¯Þˆ`\¿Î_KŽ€NÕ€î¸Z\W ‡Ö`ÔÒ4Òóx¤ò$ò• • – ½¡Fu\»Ÿˆ`ü»(ü‹63 A guard that allows access to an object in a pool.ÁÂúüÆZW While the guard exists, it indicates to the pool that the item the guard references isÁü¡^[ currently being accessed. If the item is removed from the pool while the guard exists, theÁü€:7 removal will be deferred until all guards are dropped.ÁÆ´ ¥”  ÍìÙa ÎÍìßaŒÑ¢Ùa,ñ³Ùa<ùÞßa\‰Ùa´ ´Àßa´ •aò@÷¾À¹ü·!"#jÊ}z ÑÖ`ôœ,œ��ÁL“â×—¹þWÄS®Ùaßa™,À ´ ÄÄù6Ç–7È®¯É©7¯`D!β+6ûÙaßaTÜÜüü+üëHE A guard that allows exclusive mutable access to an object in a pool.Á´úü¸LI While the guard exists, it indicates to the pool that the item the guardÁü…PM references is currently being accessed. If the item is removed from the poolÁüÖIF while a guard exists, the removal will be deferred until the guard isÁü NK dropped. The slot cannot be accessed by other threads while it is accessedÁdï mutably.Á4‡ ´ %¥&”'&'%ƒ£ ’ “£Œ• ££,µ ²£<½ Á£\Í У´ˆ!Þ£Žbðï=®~M3&()*‹Ž UWZ • Ö`üà ",à $$˜˜ƒM›âל¬M×�ÂM×29¨°ÑëÙaßa­,ˆ!$$†¥T¤!¤!$$üà6)ü³!NK An owned guard that allows shared immutable access to an object in a pool.Á‚"úü†"ZÆŸüá"^ª üÀ#:’¡û#úüÿ#JG Unlike [`Ref`], which borrows the pool, an `OwnedRef` clones the `Arc`ÁüÊ$NK around the pool. Therefore, it keeps the pool from being dropped until allÁü™%PM such guards have been dropped. This means that an `OwnedRef` may be held forÁÔê% an arbit
 `£cçg `àB¤GS
õÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
áŸÈŸÈ ÈErrorÁ O˜éBLV ÇæV
Y‚`ˆ`$Èæ± Îæü£èN´ [¥\”][\]ƒ£ ¬è“£ ¯è££,Íè²£<ÕèÁ£\åè•a^_¨è79;=Ôªéüøè-* Returns the key used to access this guardÁ±éö ö•aZ µéZ
^´ Ùaßa$¶é¬ñé,ôé÷ ÷•a ÷ÙaZ úéZ
_´ Ùaßa$ûéüÅíb´ a¥b”ccabƒ£ Îí“£ Ñí££,ƒî²£<‹îÁ£\›î•adeê!ë!eÊíBDFH\®î4³î``ÙaüÄî ,Çîø ø•a ø•aê!` Íî`
e´ Ùaßa$Îîü…ïW´ g¥h”ighiƒ£ Žï“£ ‘,¸ï²£<ÀïÁ£\Ðï•aj�"jŠï<>@B”ãï$æïù ù•aáf ëïf
j´ Ùaßa$ðïüðôj´ l¥m”nnmlƒ£ ùô“£ üô¿cÙaT©õ££,¶õ²£<¾õÁ£\Îõ•aoÀcoõôLNPRüáõ8äõúûü ú•a û c cˆ¢cµ
 `£cçg `àB¤GS
üóÀk èõk
o´ Ùaßa$éõ± ïõüÎön´ q¥r”ssqrƒ£ ×ö“£ ÚöµßÙaÙad‰÷££,˜÷²£< ÷Á£\°÷•at·ßtÓöQSUWüÃ÷Æ÷ýþ ý•a þÙap É÷p
t´ Ùaßa$Ê÷¹
,Ð÷ü¨ø^´ v¥w”xwxvƒ£ ±ø“£ ´øÁ£\·ø££,âø²£<êøÁ£\úøŽbyz{­øBDFHÔ¿ùü�ù-* Returns the key used to access the guard.ÁÆùÿ ÿŽbu Êùu
y´ Ùaßa$Ëùü†„+üøùJG Downgrades the mutable guard to an immutable guard, allowing access toÁüÇú(% the pooled value from other threads.Áôúú|üú ## ExamplesÁ�ûú<˜û¦Ñì¤û‹�üÆû# # use std::{sync::Arc, thread};Áüîû/, let pool = Arc::new(Pool::<String>::new());Á¢üúüªü=: let mut guard_mut = pool.clone().create_owned().unwrap();Áôìü let key = guard_mut.key();Áü�ý  guard_mut.push_str("Hello");Á´ýúü¼ýHE // The pooled string is currently borrowed mutably, so other threadsÁ̉þ // may not access it.Áì§þ let pool2 = pool.clone();ÁÜÉþ½üéþ)& assert!(pool2.get(key).is_none())Á¼—ÿ´¾³ÿúü»ÿ52 // Downgrade the guard to an immutable reference.Áüõÿ&# let guard = guard_mut.downgrade();Á €úü¨€;8 // Now, other threads may also access the pooled value.Áìè€ðÔÜŠ�½üª�" let guard = pool2.get(key)ÁüÑ�GD .expect("the item may now be referenced by other threads");Áü�‚1. assert_eq!(guard, String::from("Hello"));Á¼Ó‚´¾ï‚úü÷‚LI // We can still access the value immutably through the downgraded guard.Áüȃ-* assert_eq!(guard, String::from("Hello"));Á<úƒ¦ÑL�„Žb•auu
z´ Ùaßa$›„¬é…,ì…€  € Žb € Ùau ò…u
{´ Ùaßa$ó…üõ‡r´ }¥~”}~ƒ£ þ‡“£ �ˆÁ£\„ˆ££,Ȳ£<ˈÁ£\ÛˆŽb€�ê!ë!�ú‡NPRT\îˆ4óˆ||Ùaü„‰ ,‡‰�  � Žb � Žbê!| �‰|
�´ Ùaßa$Ž‰üʼnh´ ƒ¥„”……„ƒƒ£ Ή“£ щ££,‰Š²£<‘ŠÁ£\¡ŠŽb†÷!†ʉ>@BDü´Š,L·Š‚  ‚ Žb ‚ êÞ‚ ÁŠ‚
†´ Ùaßa$ÆŠüÌŒZ´ ˆ¥‰”ŠŠˆ‰ƒ£ ÕŒ“£ ØŒ££,‚�²£<Š�Á£\š�Žb‹�"‹ÑŒ>@BD”­�$°�ƒ  ƒ Žbᇠµ�‡
‹´ Ùaßa$º�üÔ�m´ �¥Ž”�Ž��ƒ£ Ý�“£ à�ŒÊT�‘££,�‘²£<¥‘Á£\µ‘Žb�Àc�Ù�GIKMüÈ‘8Ë‘„ … †  „ Žb …  c cˆ¢cµ
 `£cçg `àB¤GS
† óÀŒ Ï‘Œ
�´ Ùaßa$Б± Ö‘üµ’q´ ’¥“””“’”ƒ£ ¾’“£ Á’îÌdó’££,‚“²£<Š“Á£\š“Žb•·ß•º’HJLNü­“°“‡ ˆ  ‡ Žb ˆ Ùa‘ ³“‘
•´ Ùaßa$´“¹
,º“ü‘”K¥—”˜—˜�ž –” ž ™”°ž,¸”¿ž<À”Ξ\Д‹c™š2468Ô••üã”-»Âœ•‰  ‰ ‹c–  •–
™‚`ˆ`$¡•¬Ü•,ß•Š  Š ‹c Š ‚`– å•–
š‚`ˆ`$æ•ü°™_¥œ”�œ��ž µ™ ž ¸™°ž,뙿ž<ó™Ξ\ƒš‹cžŸê!ë!Ÿ>@BD\–š4›š››‚`ü¬š ,¯š‹  ‹ ‹c ‹ ‹cê!› µš›
Ÿ‚`ˆ`$¶šüíšT¥¡”¢¢¡�ž òš ž õš°ž,�›¿ž<¥›Ξ\µ›‹c£�"£79;=”È›$Ë›Œ  Œ ‹cá  Л 
£‚`ˆ`$Õ›üë£g¥¥”¦¦¥�ž 𣠞 󣙿T¡¤°ž,®¤¿ž<¶¤Ξ\Ƥ‹c§Àc§@BDFüÙ¤8ܤ� Ž �  � ‹c Ž  c cˆ¢cµ
 `£cçg `àB¤GS
� óÀ¤ त
§‚`ˆ`$ᤱ ç¤üÆ¥k¥©”ª©ª�ž Ë¥ ž Î¥µß‚`‚`dþ¥°ž,�¦¿ž<•¦Ξ\¥¦‹c«·ß«LNPRü¸¦»¦� ‘  � ‹c ‘ ‚`¨ ¾¦¨
«‚`ˆ`$¿¦¹
,Ŧüƒ§b¥­”®®­�ž �§ ž ’§‹½$º§°ž,Á§¿ž<ɧΞ\Ù§‹c579;üë§b¥°”±±°�ž ÷§ ž ú§‹½$¢¨°ž,©¨¿ž<±¨Ξ\Á¨‹c579;üð¨N¥³”´³´�ž õ¨ ž ø¨°ž,š©¿ž<¢©Ξ\²©�dµ·¸8:<>Ô÷©üÅ©-»Âþ©’  ’ �d² ‚ª²
µ‚`ˆ`$ƒªüÊ´,ü°ªLI Downgrades the owned mutable guard to an owned immutable guard, allowingÁü�«2/ access to the pooled value from other threads.Á¸«ú|À«›ÑÔ«ú<Ü«¦Ñìè«‹�üŠ¬#ÞÑü²¬/ŒÒæ¬úüî¬=ÓÒô°­šÓüÓ­ ÃÓø­úü€®HûÓÌÍ®ÍÔìë®ðÔÜ�¯½ü­¯)¦Õ¼Û¯´¾÷¯úüÿ¯5õÕü¹°&µÖä°úüì°;óÖ쬱ðÔÜα½üî±"Õ×ü•²G‚Øüá²1Ôؼ—³´¾³³úü»³L«ÙüŒ´-‚Ú<¾´¦ÑLÑ´�d‹c²²
‚`ˆ`$ß´ü«¶',®¶“  “ �dÛ¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙ “ ¡x² ´¶²
·‚`ˆ`$µ¶¬�¸,�¸”  ” �d ” ‚`² –¸²
¸‚`ˆ`$—¸üç»b¥º”»º»�ž ì» ž ï»°ž,¥¼¿ž<­¼Ξ\½¼�d¼½ê!ë!½>@BD\м4Õ¼¹¹‚`üæ¼ ,鼕  • �d • �dê!¹ ï¼¹
½‚`ˆ`$ð¼ü§½e¥¿”À¿À�ž ¬½ ž ¯½°ž,轿ž<ð½Ξ\€¾�dÁ÷!Á79;=ü“¾,L–¾–  – �d – ñ€¾  ¾¾
Á‚`ˆ`$¥¾ü�ÂW¥Ã”ÄÃÄ�ž ” ž —°ž,¿ž<ÊÂΞ\ÚÂ�dÅ�"Å79;=”íÂ$ð—  — �dá õÂÂ
Å‚`ˆ`$úÂüúÉj¥Ç”ÈÇÈ�ž ÿÉ ž ‚Ê™¿T³Ê°ž,ÀÊ¿ž<ÈÊΞ\ØÊ�dÉÀcÉ@BDFüëÊ8îʘ ™ š  ˜ �d ™  c cˆ¢cµ
 `£cçg `àB¤GS
š óÀÆ òÊÆ
É‚`ˆ`$óʱ ùÊüØËn¥Ë”ÌËÌ�ž ÝË ž àË�òd“Ì°ž,¢Ì¿ž<ªÌΞ\ºÌ�dÍ·ßÍACEGüÍÌÐÌ› œ  › �d œ ‚`Ê ÓÌÊ
Í‚`ˆ`$Ô̹
,ÚÌü˜Íe¥Ï”ÐÏÐ�ž ¤Í ž §Í‹½$ÒÍ°ž,ÙÍ¿ž<áÍΞ\ñÍ�d579;üƒÎe¥Ò”ÓÒÓ�ž �Πž ’΋½$½Î°ž,Äοž<ÌÎΞ\ÜÎ�d579;””G£GÞãòõöî� TñÔ×· D*õÔØÅ-$9·ÔÙÌH$MØÔÚ×]¤,Ôܽ¡\j• Ôݽ¡– ÔÝ\¼’”‚„rt\FeWVXœbH¼ÍüxTQ Configuration parameters which can be overridden to tune the behavior of a slab.Á4×ÞÞÍìâ‹,ßÞ�Ž�ŽßàáâßàáâÄÞüë<9 The maximum number of threads which can access the slab.Á¬úü´JG This value (rounded to a power of two) determines the number of shardsÁüƒPM in the slab. If a thread is created, accesses the slab, and then terminates,ÁüØGD its shard may be reused and thus does not count against the maximumÁü¤52 number of threads once the thread has terminated.Á\äÞÞ´òü™:7 The maximum number of pages in each shard in the slab.ÁØúüàLI This value, in combination with `INITIAL_PAGE_SIZE`, determines how manyÁü±<9 bits of each index are used to represent page addresses.ÁLøÞÞôý
ü©-* The size of the first page in each shard.ÁÛúüãB? When a page in a shard has been filled with values, a new pageÁüªLI will be allocated that is twice as large as the previous page. Thus, theÁüûIF second page will be twice this size, and the third will be four timesÁÌÉ  this size, and so on.Áç úüï LI Note that page sizes must be powers of two. If this value is not a powerÁüÀ
85 of two, it will be rounded to the next power of two.ÁŒƒ ÞÞÔµüÄ JG Sets a number of high-order bits in each index which are reserved fromÁt“  user code.Á¦ úü® KH Note that these bits are taken from the generation counter; if the pageÁüþ HE address and thread IDs are configured to use a large number of bits,ÁüË
HE reserving additional bits will decrease the period of the generationÁü˜KH counter. These should thus be used relatively sparingly, to ensure thatÁüèHE generation counters are able to effectively prevent the ABA problem.Ál»ÞÞüØ#TéããÎìâ‹ü؃Þâ‹4õãçœ*úœçœ6úœ*äåæçèéêëíîïäåæçèéêëíîïèêïëéíî´‚Lˆãã¼ÔTÚãã¼–TœããìÖ„Üããü«L®ãã
è⋹ ¸ü†,‰òòíôŸ ÔìõéÑ3%~‘â‹ãã
éâ‹lÝDàáãã
êâ‹ü¸,4»’ã’ììãÍ쀡 ÂØ€¡â‹TÅ
ëâ‹€¡¿
4Ñ-/ü§+\ª··Å-¹Ù-кŸ ЛÅ]ᱎ>Çâ‹ãã
íâ‹¿
4¶ü“0T–¢¢ú=¤�>�¥—>�¦Ÿ �9ɯñž¯‘Câ‹ãã
îâ‹¿
4¡ü„0T‡¨‹ãã
ïâ‹¿
4’üÜ ”ññÍì™e áÞ™e4ä™eüé (\û ”óó㤠‡!ó¤4Š!ØeìõéÑ3%~‘ô%'Ę!$˜!Ôòò¯¢ìµ!,Æ!üø!0LŒ"ý�¹ŠLìÆ#Ö`øùúáßàôê#Œð#÷÷ļ$û64ÁÜš$ü”$#\Â$÷÷´�&L‡&÷÷ü¨&!Ö`üÀcüüÐ&8Ó&� ž Ÿ  � Ö` ž  c cˆ¢cµ
 `£cçg `àB¤GS
Ÿ óÀû ×&û
ü$Ø&± Þ&ü±'-”þþ㤠¶'ó¤4¹'ØeÿÀcÿüå'8è'  ¡ ¢    Øe ¡  c cˆ¢cµ
 `£cçg `àB¤GS
¢ óÀý ì'ý
ÿ™e$í'± ó'œ¨G$·G‚¤$Š�¤,û•�Ä\°�ƒatomicÁ4æ‚]�†¤,îµ>�‡ yield_nowÁL† ¡�ˆ‹d™µ�‰ÎJTNô�\Lë
º$Å
»º„Ï
‚$á
ÄÎ
üÄ
#üÀ
(ü·
3,ï
€Š•ôõÄìƒûªá‚]†¤Ûµ>‡±«Í ¡ˆ‹Çµ‰Ä£JÐœÐ7:%(Œþùûœ³š‹ÌëLùá
‹¬ÿ¥���ž „�fŽ�’üŸ$¦‚`�fŒŒ
Ž‚`“j$ªü¬W$³£  £ �f—£Œ—�£‘‘� ¾ŒÍìÅ° ¸ÍìÊ° »–"Å° ‚`¬íÅ°°±˜"Ê° �
�‚`Å°Ê°$¿± Åbd^`ü×YDÞ¤  ¤ �fÅ°Ê°Œ—“£””“ 팃± ç”± ê–"Å° ‚`œœÅ°“³˜"Ê° ®
’‚`Å°Ê°$î± ôY[^`¤ì#û„›¥——�ž  Ìf˜™š›ü€ ‡‚`Ìf––
˜‚`»,‹Ü©<°¥  ¥ Ìf ¥ ‚`– ¸–
™‚`$¹üÑ#<ئ  ¦ Ìf ¦ ‚`– à–
š‚`$åä‚T‰Ìf‚`––
›‚`$”L¾G,ÂG¢ collectionsÁ\
Çœž§$ ‡œŸDerefMutÁD" ö!œ ç$, —3œ¡ XZHJl 3!#|Õ
ü4K H Trait implemented by types which can be cleared in place, retaining anyÁ¬€  allocated memory.Á– úüšG D This is essentially a generalization of methods on standard libraryÁüâI F collection types, including as [`Vec::clear`], [`String::clear`], andÁü¬M J [`HashMap::clear`]. These methods drop all data stored in the collection,ÁüúM J but retain the collection's heap allocation for future use. Types such asÁüÈC @ `BTreeMap`, whose `clear` methods drops allocations, should notÁÌŒ  implement this trait.Á¦ úüªJ G When implemented for types which do not own a heap allocation, `Clear`ÁüõN K should reset the type in place if possible. If the type has an empty stateÁüÄM J or stores `Option`s, those values should be reset to the empty state. ForÁü’P M "plain old data" types, which hold no pointers to other data and do not haveÁüãM J an empty or initial state, it's okay for a `Clear` implementation to be aÁü±N K no-op. In that case, it essentially serves as a marker indicating that theÁü€) & type may be reused to store new data.Áª úü®Y V [`Vec::clear`]: https://doc.rust-lang.org/stable/std/vec/struct.Vec.html#method.clearÁüˆ b _ [`String::clear`]: https://doc.rust-lang.org/stable/std/string/struct.String.html#method.clearÁüë i f [`HashMap::clear`]: https://doc.rust-lang.org/stable/std/collections/struct.HashMap.html#method.clearÁ,ß
¢¢çœüÕ
q ¢çœçœ£££¤° üë
@ = Clear all data in `self`, retaining the allocated capacithy.Á,³ §  § â‹á¢ ¹ ¢
£â‹$¾ ÜÈ ¥¥¥�ž Í Žg¦£¦œê ,í ¨  ¨ Žgᤠó ¤
¦‚`$ø ü¦ , ¥¨¨�ž « °ž,Ì Ýg©£©œç ,ê ©  © Ýg᧠ð §
©‚`$õ ħ
¥««�ž ¬
Ôh¬£¬œÔ
,×
ª  ª Ôh᪠Ý
ª
¬‚`$â
üŒm œ®§¯¤°¯®°ÍìÐi ‘ ÍìÖi ” ÍìÜi — šeÐiTÏ ™ÐiÜ ÅeÜiŒç ži±£±_a\^Y[œŽ ,‘ «  « žiá­ — ­
±ÐiÖiÜi$œ ü×g ¥³¤´´³�ž Ü Íì�j ß še‚`T” ™‚`¡ Åe�jŒ¬ ìiµ£µOQLNœÓ ,Ö ¬  ¬ ìiá² Ü ²
µ‚`�j$á ¬œ ­j·£·œÆ ,É ­  ­ ­já Ï 
·$Ô ü�' ¥¹¹�ž † °ž,‰ âjº£ºœ½ ,À ®  ® âjá¸ Æ ¸
º‚`$Ë ü…( ¥¼¼�ž Š °ž,� ¼k½£½œÂ ,Å ¯  ¯ ¼ká» Ë »
½‚`$Ð DÉG$ÍG„
FusedIteratorÁl òP¾Àž, ë1¾Áâ4 Ծø$9 оÄÒ ,? ¯¾Å œ
gUW,, HJ8:(*üÈ= ´ ǥȔÉÇÈɃ£ Ñ “£ Ô Á£\× ŒlÊËúMûMËÍ /146LŒ $‘ ÆÆ ´ Ùaü¤( $§ °  ° ŒlÛ¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙŒlúMÆ ¬ Æ
Ë´ Ùaßa$± <õ Ë°ùÌÈùÌåùÌÌËÌÙaßa ¬­¬­ FilterMapÁ¯­ùÍ:°­±Í:žYl¼[qR¨ÄlÄlë.Çlµ ™lÈlâÆ™lÉløÆ™lŒœjSžêêÈíä×îó ×ï÷×ðŸ ×Áqq8<gÛ¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙÙaßa ÐÖÛ¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙ Ùaö×áü­ > 8± ¥Î”Ïϱ ΃£ ² “£ µ Á£\¸ ìlDÓG$×G×™·ÀÊÎÐ×­â$ÔÐÒ”TãÐÓû,6¢ÐÔÎJ«ôÐÕ�ÌH$eØÐÖÈ$§ê³×·¤,е½¡\Ä• н¡– ÐT½ ®°œ(¡¼A=\^€œl${êñõùýþ—�˜¢–.D À×Ø AtomicUsizeÁ\5„Ä×Û®DB¼À×ܤ$QŠ×Ý�ÎJTWô×Þ�ârÔ×àû,~¢×áÌH$…Ø×âú=‹¢×ãÚ×›¤,×彡\¨• ×潡– ×æíµë×çµ º“×èŠ4¿¦×é|O\Ì9<*-  ,júüdwíÛÝÊÌ•¹»œ «‚„qs`bäÉ$Û¥ë”ìëì�ž à ž ã¬pÁqq8<gíîïð+-02´ìLì×êê¤]¤]V¦]Á‚]üß3ø¤”&¼¾$¾×êêôôõÎJ÷ˆ‚ Ÿ´6@~’œ€$€×êê�fÄ™$™×êê• • – ½¡Fu\»Ÿˆ`áüò4T„”òò㤴�åo_H5“h^oóô �Ö`d­,­×ññÄ¿$¿×ññ¯¢üñ2Dƒ”öö㤴ŒÂr$¶ùˆs6>Î÷ø ŒÖ`dª,ª×õõļ$¼×õõ¯¢ôÙLë”úú㤠õÙqNǃy"ûü!dþ,þ×ùùÏnÄ�$�×ùù¯¢Ñad³×”ÿÿ㤠À×s2h m8õ»þ€åo×sÑaO×åo×sýý
þ™efhlÃ×ýýåoüÜ .”‚‚㤠á ó¤\ä åoƒ„…†ÚÛà߆…35„‰ � ��LÐ $Õ ��Äzüÿ T‚ åo��
…™eÀ � Üÿ D‚
²  ² åo� ‹
�
†™e$Œ
ü¹
"”ˆˆã¤ ¾
ó¤\Á
åo‰äâ
å
×åo‡‡
‰™e»,é
ü�/¥‹”ŒŒ‹�ž ” ž —Ξ\²¬p��‘“”•š,.13üÛ"$éг  ³ ¬pŠ îŠ
�‚`ˆ`$ï4—�°ùŽÈùŽåùŽŽ�Ž‚`ˆ` áüÑ ,ß´  ´ ¬p ´ ‚`Š åŠ
�‚`ˆ`$æ4‹�°ù�Èù�åù����‚`ˆ`°± ‚`áüÆ*DÔе  µ ¬pአ݊
‘‚`ˆ`$Þó $䎑°ù’Èù’åù’’‘’‚`ˆ` á‚¡üàCî ¶ ¬pññ� ó»×ôŸ ×_H5“h^oˆ`· Š òŠ
“‚`ˆ`$ó5ùüó&:dö&×·  · ¬p�ðÛ¼ݼÞ¼©ß¼à¼Ûá¼
4È:È>$×:mutatorÁ<á:þ4ŠL•°ù™Èù™åù™™•™‚`ˆ`€ó†ó‹ó“³‹ó†óüúT4$ˆU»  » ¬pÛ¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙümŠ �UŠ
š‚`ˆ`$ŽUüÏ[7¥œ”��œ�ž Ô[ ž ×[Ξ\ú[êêÈíä×îó ×ï÷×ðŸ ×Áqq8<gŽgˆ`ž ¡£xz}Ô�\D�\×¼  ¼ íø› ™\›
ž‚`ˆ`$š\4Á\ž°ùŸÈùŸåùŸŸžŸ‚`ˆ` Žgáü‚^K4�^½ ¾  ½ íø ¾ ŽgÛ¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙ�ð› —^›
 ‚`ˆ`$˜^»,ž^üöf‘„„gп À  ¿ íø�ð À €ó›—¢¢ ®g›Óó •g†ô\˜g
¡‚`ˆ`€ó$¯g5½gž
4ÙgÈ>$ðg9;üào’dîoÐÁ   Á íø�ð  €óŽg›—¤¤ ”p›Óó ûo†ô\þo
£‚`ˆ`€ó$•p5£pž
4¿pÈ>$Öp9;4¢q£°ù¥Èù¥åù¥¥£¥‚`ˆ`€óÛ¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙ ŽgŽgáüõqG¥§”¨¨§�ž úq ž ýq¿ž<˜r°ž,¢rΞ\°r¬p©ª¬0257üÃr/ÚrЬp¦¦
©‚`ˆ`ó $Þrü¥v’Œ³vÐà Ä  à ¬p�ð Ä €ó¦—«« Þv¦Óó Åv†ô\Èv
ª‚`ˆ`€ó$ßv5ívž
4‰wÈ>$ w9;üŠ€Žl˜€ÐÅ Æ  Å ¬p�ð Æ €ó¦—­­ ¿€¦Óó ¦€†ô\©€
¬‚`ˆ`€ó$À€5΀ž
4ê€È>$��?A4Ò‚¬°ù®Èù®åù®®¬®‚`ˆ`€óÛ¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙ ‚`á<þ‚¬°ù¯Èù¯åù¯¯¬¯‚`ˆ`€ó ‚`ááü„„"¥±”²±²�ž ‰„ ž Œ„Ξ\�„¬p³!#Ì­„<°„×Ç  Ç ¬p° ¸„°
³‚`ˆ`$¹„üÚ‘1¥µ”µ�ž ß‘ ž â‘Ξ\呬p·Àc·%')+ü’’8•’È É Ê  È ¬p É  c cˆ¢cµ
 `£cçg `àB¤GS
Ê óÀ´ ™’´
·‚`ˆ`$š’±  ’ü©–$”¹¹ã¤ ®–åoºÀcºüÔ–8×–Ë Ì Í  Ë åo Ì  c cˆ¢cµ
 `£cçg `àB¤GS
Í óÀ¸ Û–¸
º™e$Ü–± â–üØ—"”¼¼ã¤ Ý—ó¤\à—åo½Ä�˜<„˜×åoåo»»
½™e$Œ˜üݘ0”¿¿ã¤ â˜ó¤\å˜åoÀ·ßÀü”™"—™Î Ï  Î åo Ï åo¾ š™¾
À™e$›™¹
,¡™üä™)”ÂÂ㤠é™ó¤\ì™åoü’š1”ÄÄ㤠—šó¤\ššåoÅïßÅüÊšA\ÍšÐ Ñ  Ð åo Ñ åoÛ¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙ¿ßÀßÁßLessÁÂßÃßÄß~ÅßÆßÇßGreaterÁÈßåºÝÈnûê7à ٚÃ
Å™e$Úš¹
,àšüÄ›*”ÇÇ㤠ɛó¤\Ì›åoÈ»Èüõ›1ø›Ò Ó  Ò åo Ó åoø’Æ ü›Æ
È™e$ý›¹
,ƒœüל,”ÊÊ㤠ܜó¤\ßœåoËÙ˼Š�,��Ô  Ô åoåoÉ “�É
Ë™e$”�ü»�+”ÍÍ㤠À�ó¤\Ã�åoü‚ž#¥Ï”ÐÐÏ�ž ‡ž ž ŠžΞ\�žÁmÑÒÓ#%')ü�¡+<¤¡Õ  Õ ÁmÎ ¬¡Î
Ñ‚`ˆ`$­¡ü¯¤/$ĤÖ  Ö Ám Ö ¬pÎ ɤÎ
Ò‚`ˆ`$ʤüà§',õ§×  × Ám × ‚`Î û§Î
Ó‚`ˆ`$ü§4¨¨Ó°ùÔÈùÔåùÔÔÓÔ‚`ˆ`„îáüÛ¨!”ÖÖ㤠à¨ó¤\ã¨Ùq×ØÙ”ƒ©4‰©×ÕÕÙq¤ã©Dé©×ÕÕÙqœÇª<ͪ×ÕÕÙqü¨«-”ÛÛ㤠­«ó¤\°«ÙqÜÝÞßÚÛàßßÞ57„Ü«â«ÚÚLö«$û«ÚÚáü‹¬TŽ¬ÙqÚÚ
Þ™eÀ ™¬Üä®Dç®Ø  Ø ÙqÚ ð®Ú
ß™e$ñ®ü§¯"”áá㤠¬¯Ùqâ·ßâüЯ"Ó¯Ù Ú  Ù Ùq Ú Ùqà Ö¯à
â™e$ׯ¹
,ݯÜ °”ää㤠¥°Ùq
üÀ°#”ææ㤠ŰÙqçÀcçüê°8í°Û Ü Ý  Û Ùq Ü  c cˆ¢cµ
 `£cçg `àB¤GS
Ý óÀå ñ°å
ç™e$ò°± ø°ü‡²,”éé㤠Œ²ó¤\�²ÂrêëìíÚÛàßìí57„º²À²èèLŒ³$‘³èèÙqü«³#T®³Ârèè
ì™e»,¹³ÜÓ´DÖ´Þ  Þ Ârè ß´è
í™e$à´ü�µ ”ïï㤠’µó¤\•µÂrðñòÜ´µŵîîìõµ$øµ×ÂrÛ¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙÂrîî
ñ™e$ýµ¬÷·$ú·×ÂrÂrîî
ò™e$ÿ·üÁ¸"”ôô㤠ƸÂrõÀcõüê¸8í¸ß à á  ß Âr à  c cˆ¢cµ
 `£cçg `àB¤GS
á óÀó ñ¸ó
õ™e$ò¸± ø¸üì¹.”÷÷㤠ñ¹ó¤\ô¹Ârø·ßøü¡º"¤ºâ ã  â Âr ã Ârö §ºö
ø™e$¨º¹
,®ºüñº'”úú㤠öºó¤\ùºÂrü�»/”üü㤠¢»ó¤\¥»ÂrýïßýüÓ»A\Ö»ä å  ä Âr å Âr³’û â»û
ý™e$㻹
,é»üͼ(”ÿÿ㤠Ҽó¤\Õ¼Âr€»€üü¼1ÿ¼æ ç  æ Âr ç Ârø’þ ƒ½þ
€™e$„½¹
,Š½üÞ½*”‚‚㤠ã½ó¤\æ½ÂrƒÙƒ¼�¾,’¾è  è ÂrÂr� ˜¾�
ƒ™e$™¾üÀ¾)”……㤠žó¤\ȾÂrüŒ¿0”‡‡ã¤ ‘¿ó¤\”¿×sˆ‰Š‹ÚÛàß‹Š57„ÿÉ¿††Lð¿$õ¿††ÂrüŽÀ#T‘À×s††
Š™e»,œÀÜëÀDîÀé  é ×s† ÷À†
‹™e$øÀü¬Á'¥�”ŽŽ��ž ±Á ž ´ÁΞ\·Áüm��’”•–,.02üÚÁ0TèÁê  ê üm�ðŒ óÁŒ
�‚`ˆ`$ôÁü¥Å',ºÅë  ë üm ë ‚`Œ ÀÅŒ
�‚`ˆ`$ÁÅ,ôÅ�°ù‘Èù‘åù‘‘�‘‚`ˆ`„îáüƒÊ3L˜Êì  ì üm ì ‚`Œ ¢ÊŒ
’‚`ˆ`$§Ê,âÊ’°ù“Èù“åù““’“‚`ˆ`“³‘ˆáüßÍ/<ôÍí  í ümŒ üÍŒ
”‚`ˆ`$�ÎüýÐ8L’Ñî  î ümÁmŒ œÑŒ
•‚`ˆ`$¡ÑüªÒ6D´Ò×ï  ï ümŒ ½ÒŒ
–‚`ˆ`$ÂÒnew_refsÁDÈÒü³è'œ¶è×ð  ð á Ïè
—expÁÊèÌŽéd”é×L�,…Сâ Ô™šåÚ\*„Ä™œ®D7¼À™�×L¤,™Ÿ½¡\Y• ™ ½¡– ™ T~œnp]_FOQœQAüh7lzД¢¢ã¤´ˆ–tf
Ú5*¶\\£¤ ˆÖ`Œ¦$¦™¡¡‡àĽ$½™¡¡¯¢üÚ%”¦¦ã¤ ßó¤\â–t§¨©܆”Жt¥¥
§™eü£-<±Ðñ  ñ –tÌÉ¥ ¹¥
¨™e$ºüÄ7$Ç™ò  ò –tä,á¥ä,ªª Ì¥Íì—Àtì�"—ÀLñ—ÀßÀ˜"á
©™e—À$Ínew_headÁDÓbeforeÁ4ä^`ü­ <”¬¬ã¤ ² ó¤\µ –t­Â­üð <$ó ó ô  ó –t ô êêÈíä×îó ×ï÷×ðŸ ×Áqq8<gÙa™eá«¥®® û «ƒ£ ø 
­™eÙa$ü ‘ÀD‚
â$“
')4Ë
­°ù¯Èù¯åù¯¯­¯™eÙaßÀá  ÆÂüð
'”±±ã¤ õ
–t²Àc²üž8¡õ ö ÷  õ –t ö  c cˆ¢cµ
 `£cçg `àB¤GS
÷ óÀ° ¥°
²™e$¦± ¬„›&6±66œ¼
6üõ;$‡”¸¸ã¤üŒ#ó¤\�çt›Å]ᱎ>ǹº( ŒÖ`\·$·Ð··ÄÈ$Èз·¯¢ä唼¼ã¤ êó¤\íçt½¾¿Œˆ$ŽÐ»»ü±",¿çt»»
¾™e$Åü‚ #4� çt»»
¿™e$— äà DÔ À”ÁÁÀçœüà | ž Ý Àçœ!çœ'ÂÂÂ*,üæ W$é ø ù  ø â‹ ù êêÈíä×îó ×ï÷×ðŸ ×Áqq8<g¥ˆ`áÀ¥Ãà ñ ÀÍìŽÌ î Ξ\± 
Â⋈`ŽÌ$ò ‘ÀDø â$‰ 46üÁ (”ÅÅã¤ Æ ó¤\É çtÆÇÈÉÚÛßàÈÉ35„ð ö ÄÄL¬
$±
ÄÄáÜÁ
DÄ
ú  ú çtÄ Í
Ä
È™e$Î
üü
"Tÿ
çtÄÄ
É™eÙ-$ŠôŸ$¯´ ˥̔ÍÌÍ˃£ ¸“£ »¬­¬­ËÔ¯­ùÍ:°­±Í:žYl¼[qR¨ÄlÄlë.Çlµ ™lÈlâÆ™lÉløÆ™lŒœjSž´ ÐÖ ´ ÐÖÛ¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙ£Ó´ûý¼¹,Ë®uÇî;�z©}ϼŽ$ŽÐÎÎÏàôª4¼¥Ñ”ÒÑÒ�ž àž ÆÐФ/ÓÂ/ÐÔ™ÐÕØ/ÐÖç/ÐÚp.IDï_ï‚`ˆ`Úp.IDï_ïÓÔÕÖ€‚…‡ü¸4¸ÐÐС¡ƒ,£ ,™¤Ÿ ™f
Ú5*¶\\ˆ`\ð$ðÐÐÐt�<�ÐÐÐü•%$•ÐÐÐôôõÎJ÷ˆ‚ Ÿ´6@~’Û¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙ��žëf¡ˆˆ¢‰ˆl }.xÏ
¬p¡h„¿,ÄХؔÙÙØ�ž Ê ž ÍÍÖTæ®uÛÜÞÜ÷…®uÚÚ
Û¼õ$øÐû  û ®uÚ ýÚ
Ü$þ4¦Ü°ùÝÈùÝåùÝÝÜݱìáüà#DãÐü  ü ®uáÚ ìÚ
Þ$í‘ÀDó4¡Þ°ùßÈùßåùßßÞßØï‚¡üã*”áá㤠èó¤\ë®uâÂâü”5$—ý þ  ý ®u þ ÆÂáà¥ãã Ÿàƒ£ œ
â™eÙa$ ‘ÀD¦â$·')üš1¥å”ææå�ž Ÿ ž ¢Ξ\¿¢Óçèéêìñ*,/1ŒÒ$ØÐääüü6Š¢Óää
è‚`ˆ`™$ŽØ/<›üã-æÐÿ €
 ÿ ¢Ó €
®uÌÉä êä
é‚`ˆ`$ë®,ñü�' t“'Ð�
 �
¢Óä ¢'ä
ê‚`ˆ`$£'Ê'ê°ùëÈùëåùëëêë‚`ˆ` ˆÖáü‚(�L�( ´ ¢Ó··Å-¹Ù-кŸ ЛÅ]ᱎ>Lj`È1Û¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙ¦ä´ í¦îÈ1ïíïîäÍìøâ ž(Íì®âüÖ((–"®â ´ ¬püÛ(#®âèã˜"³âLõ(
ì‚`ˆ`´ øâ®â$®(Ù-$¼(± Ó(š(€‚|~4Ž*ì°ùðÈùðåùððìð‚`ˆ`øâ®â´á³â„¡®âü–+3L¤+‚
 ‚
¢Ó ‚
‚`ˆ`òä ®+ä
ñ‚`ˆ`$¯+€Ì¹+ññÊÔÍì˜æ&À˜æˆ`\¾+ææ?õæñüê+B´ ô¥õ”öôõöƒ£ ó+“£ ö+Á£\›,Þ£©,ÐФ/ÓÂ/ÐÔ™ÐÕØ/ÐÖç/ÐÚp.IDï_ï¢×ßa÷úþÿï+‡‰ŒŽôü³,ª$Á,ƒ
„
 ƒ
òç··Å-¹Ù-кŸ ЛÅ]ᱎ>Çßaññ� ó»×ôŸ ×_H5“h^oßa „
—¢×ó—øø Ò,óÍì·ê Æ,À·êßa\Ñ-
÷´ Ùaßa·ê$Ó,Ù-$á,5ø,ý1Lš-JL4ç.÷°ùùÈùùåùùù÷ùÙaßa·ê Û¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙ��žëf¡ˆˆ¢‰ˆl }.xÏ
ÐÖ¡h¢×„¡ òé  ·êüš0’4¨0…
†
 …
òç¶éòé †
·êó—ûû È0óåê ¯0öê\²0
ú´ Ùaßa·ê$É0Ù-$×05î0ý1L�1?A4¬2ú°ùüÈùüåùüüúüÙaßa·ê­ìÂí4–3ú°ùýÈùýåùýýúýÙaßa·ê õìÛ¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙðׂ¡üó5:Dö5ПѩÑóó
þ´ Ùaßaâ$ÿ5üÙ63$ç6‡
 ‡
òçÛ¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙ‹Ðó ì6ó
ÿ´ Ùaßa$í64±7ÿ°ù€Èù€åù€€ÿ€Ùaßa­ìÛ¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙñðá4ç7ÿ°ù�Èù�åù��ÿ�Ùaßaïð¿Õáüù8I¥ƒ”„ƒ„�ž þ8 ž �9°ž,ž9¿ž<¦9Ξ\¶9¢Ó…‰‹�469;üÉ9�L×9ˆ
‰
 ˆ
¢Ó ‰
®u¹3Û¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙ¦‚¦†¹3‡‡† í9‚Íìô÷ á9Íìª÷ü™:,Š
–"ª÷ Š
¬püž:'Š
ª÷àø˜"¯÷L¼:
…‚`ˆ`ô÷ª÷$î9®,ü9“#$“:ƒ…�4Ô<…°ùˆÈùˆåùˆˆ…ˆ‚`ˆ`ô÷ª÷´á¯÷„¡ª÷„¡  ®u”¨@D«@Ћ
 ‹
¢Óá‚ ´@‚
‰‚`ˆ`$µ@×B‰°ùŠÈùŠåùŠŠ‰Š‚`ˆ` ˆÖáªBªBö­Bçg÷<®B‘÷<9)
-ÜnL¬p¡hüÃE–TÑEŒ
�
 Œ
¢Óòá�ð �
€ó‚—ŒŒ õE‚Óó ÜE†ô\ßE
‹‚`ˆ`€ó$öEÙ-$„F5›Fý1L½F9;4ÙG‹°ù�Èù�åù��‹�‚`ˆ`€ó±á„¡ �ð  €ó4ÃH‹°ùŽÈùŽåùŽŽ‹Ž‚`ˆ`€ó ÍÖÛ¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙ² ‚¡üìI‘,úIŽ
�
 Ž
¢Óòá�ð �
€ó‚—�� ™J‚Óó €J†ô\ƒJ
�‚`ˆ`€ó$šJÙ-$¨J5¿Jý1LáJ9;4ýK�°ù‘Èù‘åù‘‘�‘‚`ˆ`€ó±á…ÿ4çL�°ù’Èù’åù’’�’‚`ˆ`€óùÿ‚¡ÌŠN®u”Àc”üªN8­N�
‘
’
 �
®u ‘
 c cˆ¢cµ
 `£cçg `àB¤GS
’
óÀ“ ±N“
”$²N± ¸N4üN”°ù•Èù•åù••”•´ìóÀ   c cˆ¢cµ
 `£cçg `àB¤GS
ü¾P&”—¥˜—˜ã¤ ÃPƒ£ ÆPðu™Àc™!üëP8îP“
”
•
 “
ðu ”
 c cˆ¢cµ
 `£cçg `àB¤GS
•
óÀ– òP–
™™eÙa$óP± ùPü�S+”››ã¤ ”Só¤\—SçtœÀcœüÁS8ÄS–
—
˜
 –
çt —
 c cˆ¢cµ
 `£cçg `àB¤GS
˜
óÀš ÈSš
œ™e$ÉS± ÏSüÒU*”žžã¤ ×Uó¤\ÚUçtŸ·ßŸüƒV"†V™
š
 ™
çt š
çt� ‰V�
Ÿ™e$ŠV¹
,�VüÑV#”¡¡ã¤ ÖVó¤\ÙVçtüùV+”££ã¤ þVó¤\�Wçt¤ïߤü«WA\®W›
œ
 ›
çt œ
çt³’¢ ºW¢
¤™e$»W¹
,ÁWü£X$”¦¦ã¤ ¨Xó¤\«Xçt§»§üÎX1ÑX�
ž
 �
çt ž
çtø’¥ ÕX¥
§™e$ÖX¹
,ÜXü®Y&”©©ã¤ ³Yó¤\¶YçtªÙª¼ÛY,ÞYŸ
 Ÿ
çtçt¨ äY¨
ª™e$åYüŒZ%”¬¬ã¤ ‘Zó¤\”ZçtüÈZE<ÖZçt”®®ã¤ ÞZó¤\áZ
­™eidxÁîZ!LÝG,áGÄÊ·¸ÀÁâ$ Ô¯²”T 㯳û,5 ¢¯´¸$@ Яµ¤,Z •¯·� AtomicPtrÁL ¯]¯¹åÚ\Š „įº®$® ¼À¯¼ú=Ó ¢¯¾ÌH$Ü Ø¯¿×ð ¤,¯Áµ õ “¯Âž,ú ë1¯ÃË=Û ½À¯½Ë¾À¯½Ì=榿À¯½ÌÀÀ¯½G=í¬ÁÀ¯½GÂÀ¯½F5ç²ÃÀ¯½FÄÀ¯½×5Õ¶ÅÀ¯½×ÆÀ¯½, „  òõd. çÖÙüJ ÌÏük µ¸¦©ü§ ›D£ ´ DÎ ”‚…ê wzhkY\ü¦ * ,¸ ¥Å”ÆÆÅ�ž ¾  ž Á Ξ\Ä ¡x`D!β+6ûÇÈÉ1368¬ý ˆ ÄÄÌ™ ,™ ¯ÄÄ��žëf¡ˆˆ¢‰ˆl }.xÏ
Reference in New Issue Copy Permalink