Files
boc/aamos-ledger-rust/target/debug/deps/libfutures_intrusive-1e1207472ffe0441.rmeta
T

2097 lines
604 KiB
Plaintext
Raw Normal View History

rust
p #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$É@@-e618e6be60e87ba2ÁgimliÁ¸
°µ~Î1‹Ñt ðÁ€w-1f7768a68858f670ÁobjectÁ
áPÃ?­À¶¼QHJ¥-914cd6a4dbe590d1ÁmemchrÁ›º«8Ór­2Ù $¨ûib-cf21ca6f2bb15dcdÁë
‹ás«LÖ€îâƒ×ɯŒ-ee6f3747e38367f0Álock_apiÁEcÓŽ/ÅS}sw‡A$P-0e8055cd433fa267Á
scopeguardÁ’‰‘p ÒÞa¢ßöéqÓB-29f0bdb2ea82739eÁ futures_coreÁÆöc$޳–º¾v¸dK-ac1e9cdb826f83c0Á parking_lotÁâ°r4¨6ª(ü²Hd©n¼-21962aa896c8619bÁparking_lot_coreÁ’Ý%Ž=Eq^U4FOV)àŸ-e1ee0517e8b9a4bfÁsmallvecÁ[“S‰«2ûÓàÁ3™ËºS-fa382cf08413422fÁserdeÁFVæ¸Û•IÄÀzÍ-9c8ce3cf08540cc3Á serde_deriveÁ,w|êñ]ù¿¥­C£ð-975c43f96d83014eÁ
serde_coreÁ²€Ãb˜cÐòžÇÇ
-7a42419d8e43b208Á®f©¾/ô)c§{õa“â‘-a3906971a93fd1b8Áæ\‹±ÔcdùÀTƒ-f86f80b348d33b13ÁtestsÁ,ÕD$°Doä ,¶\$ð[ä ,îN$ÑNÀ¤ noop_lockÁ INITÁ  GuardMarkerÁ lockÁ try_lockÁ unlockÁbufferÁ
real_arrayÁ RealArrayÁ¥LENÁ³
 ring_bufferÁRingBufÁæ 
with_capacityÁcapacityÁis_emptyÁcan_pushÁpushÁpopÁArrayBufÁ%¥%%¦
%%recv_idxÁ%send_idxÁ%_phantomÁ-¥--×1¥11next_idxÁ5¥555æ 5ª5¾55ã5ò5ý@¥@@ãif_allocÁDDD FixedHeapBufÁG¥G¦
GcapÁDK¥K×DN¥NNæ NªN¾NNãNòNýDGrowingHeapBufÁX¥X¦
XlimitÁD\¥\×D_¥__æ _ª_¾__ã_ò_ýintrusive_double_linked_listÁooooooov¥væ oy¥yåy´o}¥}o¥æ  add_frontÁ
peek_firstÁ peek_first_mutÁ  peek_lastÁˆ 
peek_last_mutÁŠ  remove_firstÁ remove_lastÁÔremoveÁdrainÁ
reverse_drainÁintrusive_pairing_heapÁ safe_lesserÁ¥DropBombÁŸ
¡ã£¥£æ £is_rootÁ§¥§å§´«¥« add_childÁ®¥meldÁ°¥
maybe_meldÁ²¥
last_childÁ´¥ unlink_prevÁ¥merge_childrenÁ¸¥º¥ºæ ºinsertÁºpeek_minÁºÞchannelÁÀerrorÁÁÂÔ is_closedÁÁÅ¥Å
into_innerÁÅis_fullÁÅóÀÀÀÀÀchannel_futureÁÎÎÎÎÎÎÎÎÎÎ Î
ÎÚis_newly_closedÁÚis_already_closedÁÎÝæ ÎSendWaitQueueEntryÁߥßtaskÁߺ߻Îä¥ä×Îç¥çæ ÎChannelSendAccessÁê¥êsend_or_registerÁêremove_send_waiterÁÎChannelReceiveAccessÁî¥îreceive_or_registerÁîremove_receive_waiterÁÎChannelReceiveFutureÁò'aÁò MutexTypeÁò¥òÊò wait_nodeÁòÐÎùùšù¥Îýýšý¥ý×Κ¥°Š Έˆšˆ¥ˆ
is_terminatedÁΚ¥ãÎChannelSendFutureÁš¥Ê»ÐÎ š¥Î
š¥×Î ¢¢š¢¥¢cancelÁÎ §§š§¥§°§Š Î
­­š­¥­àβ²š²¥²ãÎü··sharedÁ¹¹ô»š»¥»Ê»»»Ð¹ÁšÁ¥¹ÄšÄ¥Ä׹ȚȥȰȊ ¹ÍšÍ¥Íà¹ÑšÑ¥Ñ㹚 ÕšÕ¥ÕÊÕ»ÕйۚۥÛÂ!¹ßšß¥¹âšâ¥â×¹æšæ¥æ°æŠ ¹ ëšë¥ëà¹
ïšï¥ïãÎ ÀÀÀÀÀÀ À
À À À
ÀÀoneshotÁÿÿÿÿÿÿÿÿÿÿ ÿ
ÿ ÿ ÿ
ÿÿÿÿÿÿÿ wake_waitersÁ ÿ ChannelStateÁ¥ is_fulfilledÁ»waitersÁÿ¥æ sendÁcloseÁ try_receiveÁ
remove_waiterÁÿGenericOneshotChannelÁ¢š¢¥¢innerÁÿ¦š¦¥ÿ©š©¥ÿ¬š¬¥¬×ÿ°š°¥°æ °ª(°¶(°receiveÁÿ·š·¥·¼·×ÿLocalOneshotChannelÁ¼¥ÿif_stdÁ¾¾OneshotChannelÁÀ¥ÿÿüÃÃÔ"ÅÅÅ GenericOneshotChannelSharedStateÁȚȥÈÊḀ̼̊̚Ì×ÅGenericOneshotSenderÁњѥј)ÅGenericOneshotReceiverÁÕšÕ¥Õ˜)ÅÙšÙ¥Ù×ÅݚݥÝ×Åášá¥áãÅåšå¥åãÅgeneric_oneshot_channelÁéšé¥Åìšì¥ìª(Åðšð¥ð™*Åð*ôô
OneshotSenderÁö¥ôOneshotReceiverÁø¥ôoneshot_channelÁú¥ÅÿÀÀÀÀÀoneshot_broadcastÁ 
  
µ' Î'¥ê'»†(ž¥žæ žª(ž¶(žÃ(žÖ(GenericOneshotBroadcastChannelÁ¥š¥¥¥˜)©š©¥¬š¬¥¯š¯¥¯×³š³¥³æ ³ª(³¶(³™*ºšº¥º¼º×LocalOneshotBroadcastChannelÁ¿¥ð*ÁÁOneshotBroadcastChannelÁÃ¥üÆÆÔ"ÈÈÈÅ+˚˥ËÊÈϚϥϼÏ×ÈGenericOneshotBroadcastSenderÁÔšÔ¥Ô˜)ÈGenericOneshotBroadcastReceiverÁؚإؘ)Èܚܥ܃Èàšà¥à×Èäšä¥ä×Èèšè¥èãÈìšì¥ìãÈ!generic_oneshot_broadcast_channelÁðšð¥Èóšó¥óª(È÷š÷¥÷™*Èð*ûûOneshotBroadcastSenderÁý¥ûOneshotBroadcastReceiverÁÿ¥ûoneshot_broadcast_channelÁ¥ÈÀÀÀÀÀstate_broadcastÁ 
  
 æ ¢æ ˜¤¥¤¼¤×StateReceiveFutureÁ¨¨š¨¥¨Ê¨»¨Ð¯¯š¯¥³³š³¥³×¸¸š¸¥¸°¸Š ¾¾š¾¥¾àÃÚåÃãµ'È Î'Ê¥ÊóÊstate_idÁʻʆ(Ð¥Ðæ Ъ(ж(ÐÃ(мÐÖ(GenericStateBroadcastChannelÁؚإؘ)ܚܥ ߚߥ
âšâ¥â× æšæ¥ææ æª(æ¶(æ™*æÃ( îšî¥î¼î×LocalStateBroadcastChannelÁó¥ð*õõStateBroadcastChannelÁ÷¥üúúÔ"üüüüü'GenericStateBroadcastChannelSharedStateÁš¥sendersÁ receiversÁÊüš¥¼×üç:ŒšŒ¥ŒÊŒ»ŒÐüš¥üš¥×üš¥°Š üžšž¥žàü¢š¢¥¢ãüGenericStateSenderÁ¦š¦¥¦˜)üGenericStateReceiverÁªšª¥ª˜)ü®š®¥®×ü²š²¥²×üš¥ƒü ºšº¥ºãü
¾š¾¥¾ƒü š¥Âãügeneric_state_broadcast_channelÁƚƥü ɚɥɪ(ü
͚͙ͥ*ÍÃ(üð*ÒÒ StateSenderÁÔ¥Ò
StateReceiverÁÖ¥Òstate_broadcast_channelÁØ¥üÀÀÀÀÀÀÀmpmcÁââââââââââ â
â â â
âââââââââââââââââââ â!â"â#âwake_recv_waitersÁ âwake_send_waitersÁ¥ âreturn_oldest_receive_waiterÁâÎ'¥ó¦
receive_waitersÁ send_waitersÁâ¥æ clearÁ¶(try_sendÁæ!try_copy_value_from_oldest_waiterÁtry_take_value_from_senderÁÃ(¼þ×âGenericChannelÁ¢š¢¥¢¢˜)â§š§¥§â«š«¥«â¯š¯¥¯¯×â´š´¥´´æ ´ª´ª(´öJ´™*´Ã(´streamÁ´¶(âÀšÀ¥ÀÀæÀþâÆšÆ¥ÆÆ¼Æ×âÌ̥̚ÌÌÌ poll_nextÁâÓÓšÓ¥ÓÓàâ LocalChannelÁÙ¥ÙâLocalUnbufferedChannelÁÜ¥Ü âð*ßßChannelÁá¥áßUnbufferedChannelÁä¥ä â$âüèèÔ"êêêêêêêêGenericChannelSharedStateÁòšò¥òòšAò©AòÊêùšù¥ùù¼ù×êÿšÿ¥ÿÿæÿþê
GenericSenderÁš¥˜)êGenericReceiverÁŠšŠ¥ŠŠ˜)ꚥ×ꚥ×ꚥƒêžšž¥žžã꣚£¥££ƒê¨š¨¥¨¨ãêgeneric_channelÁ­š­¥­ê±š±¥±±ª(±öJ±¶(ê ¸š¸¥¸¸™*¸Ã(¸¶(¸ into_streamÁê
ÀšÀ¥ÀÀ¶(ê ŚťÅÅÅøNÊ ê ̥̚ÌÌàêð*ÑÑÑSenderÁÔ¥ÑReceiverÁÖ¥ÑÊØ¥ÑUnbufferedSenderÁÚ¥ÑUnbufferedReceiverÁÜ¥Ñunbuffered_channelÁÞ¥êâ%ÀÀÀÀ À!À"À#À$ÀüêÔ"ëëëëëÀ%çòmanual_reset_eventÁóóóóóóóóóó ó
ó ó ó
óóóóóWaitQueueEntryÁÿºóæ ó
EventStateÁ is_setÁ †(óŽ æ Ž resetÁŽ setÁ Ž …[Ž try_waitÁŽ Ö(óGenericManualResetEventÁ š ˜)óšóšó š ×ó  š  æ   µ[  ¨[  …[  waitÁ  Í[  Ö(óGenericWaitForEventFutureÁ© © š© eventÁ© »ó® ® šó± ± š± ×óµ µ šµ °µ Š ó º º šº àó
¾ ¾ š¾ ãóLocalManualResetEventÁóLocalWaitForEventFutureÁÃ óð*Å Å ManualResetEventÁÅ WaitForEventFutureÁÈ óòòòòòòòòòmutexÁÓ Ó Ó Ó Ó Ó Ó Ó Ó Ó  Ó 
Ó  Ó  Ó 
Ó Ó Ó Ó Ó Ó Ó Ó Ó Ó ÀZë ÿë ºÓ î æ Ó 
MutexStateÁð is_fairÁð  is_lockedÁð †(Ó ô æ ô return_last_waiterÁô áaô 
ô 
try_lock_syncÁô 
ô force_remove_waiterÁô Ö(Ó GenericMutexGuardÁý ý šý ¥ý ›`Ó 
š
¥
×Ó 
š
¥
ãÓ Š
šŠ
¥Š
åŠ
´Ó 
š
¥
Ó 
š
¥Ó GenericMutexLockFutureÁ

š
¥
`
»Ó œ
œ
šœ
¥Ó  
 
š 
¥ 
×Ó  ¥
¥
š¥
¥¥
°¥
Š Ó 
«
«
š«
¥«
àÓ  °
°
š°
¥°
ãÓ  GenericMutexÁµ
šµ
¥µ
»µ
ºÓ  º
¥º
šÓ 
½
¥½
šÓ À
šÀ
¥À
×Ó Ä
šÄ
¥Ä
æ Ä
û Ä

Ä
áaÓ 
LocalMutexÁË
¥Ó LocalMutexGuardÁÍ
Í
¥Ó LocalMutexLockFutureÁÐ
Ð
¥Ó ð*Ó
Ó
¤Õ
¥Ó
¥×
×
¥Ó
MutexLockFutureÁÚ
Ú
¥Ó òò ò
ò ò ò
òòòòòò semaphoreÁé
é
é
é
é
é
é
é
é
é
 é

é
 é
 é

é
é
é
é
é
ÀZü
ÿü
ºü
required_permitsÁé
 æ é
SemaphoreStateÁ Òa permitsÁ †(é
 æ  wakeup_waitersÁ µk releaseÁ try_acquire_syncÁ  try_acquireÁ Îb Ö(é
GenericSemaphoreReleaserÁ  š ïi µké
 š ×é
 š disarmÁé
š šš ãé
GenericSemaphoreAcquireFutureÁ  š ïi »  auto_releaseÁé
£ £ šé
¦ ¦ š¦ ×é
ª ª šª °ª Š é
¯ ¯ š¯ àé
 ³ ³ š³ ãé
GenericSemaphoreÁ· š· ºé

º šé
 ¼ šé
 ¾ š¾ ×é

Á šÁ æ Á acquireÁÁ žlÁ ÷kÁ µké
LocalSemaphoreÁé
LocalSemaphoreReleaserÁÉ é
LocalSemaphoreAcquireFutureÁË é
ð*Í Í  SemaphoreÁÍ SemaphoreReleaserÁÐ Í SemaphoreAcquireFutureÁÒ é
é
üÕ Õ Õ GenericSharedSemaphoreReleaserÁØ šØ ïiØ µkÕ Ü šÜ ×Õ ß šß £mÕ â šâ ãÕ #GenericSharedSemaphoreAcquireFutureÁå šå ïiå »å ‹nÕ ê šÕ ì šì ×Õ ï šï °ï Š Õ ó šó àÕ ö šö ãÕ GenericSharedSemaphoreÁù šù ºÕ ü šü ƒÕ  ÿ šÕ 
 šÕ  ƒ šƒ ×Õ   š æ  œp žl ÷k µkÕ ð*  SharedSemaphoreÁ SharedSemaphoreReleaserÁ SharedSemaphoreAcquireFutureÁÕ é
òòòòòòòòòòòòòò ò!ò"ò#ò$timerÁ¦ clockÁ§ § § § ClockÁ« nowÁ§  MockClockÁ­ þw§ ¯ ×§ ± æ ± set_timeÁ§ ´ þw§ ð*   StdClockÁ¹ ¹ » × ½ æ  ¿ þw§ ¦ ¦ ¦ ¦ ¦ ÈwÆ Æ Æ Æ Æ Æ Æ Æ Æ Æ  Æ 
Æ  Æ  Æ 
Æ Æ Æ Æ Æ Æ Æ Æ TimerQueueEntryÁÜ expiryÁÜ ÿÜ ºÆ à æ Æ â Æ Æ å ï
Æ ç Æ 
TimerStateÁé Õwé †(Æ ì æ ì Í[ì Ö(ì next_expirationÁð ì check_expirationsÁÆ  TimerAccessÁó Í[ó Ö(Æ 
LocalTimerÁö delayÁö deadlineÁÆ TimerÁù Ë|ù Ø|Æ GenericTimerServiceÁü šü ˜)Æ ÿ šÆ 
šÆ ƒ
šƒ
ׯ  
š
æ 
á{
ý{
deadline_from_nowÁÆ 
Œ
šŒ
Ë|Œ
Ø|Æ  
š
Ë|
Ø|Æ  
š
Í[
Ö(Æ LocalTimerFutureÁ˜
˜
Èw˜
Ȯ 
œ
œ
ׯ Ÿ
Ÿ
°Ÿ
Š Æ £
£
àÆ ¦
¦
ãÆ  TimerFutureÁ©
©
 timer_futureÁÆ ¬
Æ ®
®
ׯ ±
±
°±
Š ´
Æ 

àÆ LocalTimerServiceÁÆ ð*º
º
 TimerServiceÁÆ ¦ ¦ ¦ ¦ ¦ ¦  ¦ 
¦  utilsÁÆ
Æ
Æ
Æ
update_waker_refÁÊ
NoopLockÁÌ
ÐÎ
×Ð
¥Ð
Ð
Û
Ô
¥Ô
Ô
Û
Ø
¥Ø
Ø
Û
Ü
¥Ü
Ü
Û
à
¥à
à
Û
ä
¥ä
ä
Û
è
¥è
è
Û
ì
¥ì
ì
Û
ð
¥ð
ð
Û
 ô
¥ô
ô
Û

ø
¥ø
ø
Û
 ü
¥ü
ü
Û
 ¥ Û

¥ Û
ˆ¥ˆ ˆÛ
Œ¥Œ ŒÛ
¥ Û
¥ Û
˜¥˜ ˜Û
œ¥œ œÛ
 ¥   Û
¤¥¤ ¤Û
¨¥¨ ¨Û
¬¥¬ ¬Û
°¥° °Û
´¥´ ´Û
¸¥¸ ¸Û
¼¥¼ ¼Û
À¥À ÀÛ
Ä¥Ä ÄÛ
È¥È ÈÛ
Ì¥Ì ÌÛ
 ХРÐÛ
!Ô¥Ô ÔÛ
"Ø¥Ø ØÛ
#Ü¥Ü ÜÛ
$à¥à àÛ
%ä¥ä äÛ
&è¥è èÛ
'ì¥ì ìÛ
(ð¥ð ðÛ
)ô¥ô ôÛ
*ø¥ø øÛ
+ü¥ü üÛ
,¥ Û
-¥ Û
.ˆ¥ˆ ˆÛ
/Œ¥Œ ŒÛ
0¥ Û
1¥ Û
2˜¥˜ ˜Û
3œ¥œ œÛ
4 ¥   Û
5¤¥¤ ¤Û
6¨¥¨ ¨Û
7¬¥¬ ¬Û
8°¥° °Û
9´¥´ ´Û
:¸¥¸ ¸Û
;¼¥¼ ¼Û
<À¥À ÀÛ
=Ä¥Ä ÄÛ
>È¥È ÈÛ
?Ì¥Ì ÌÛ
@ХРÐÛ
AÔ¥Ô ÔÛ
BØ¥Ø ØÛ
CÜ¥Ü ÜÛ
Dà¥à àÛ
Eä¥ä äÛ
Fè¥è èÛ
Gì¥ì ìÛ
Hð¥ð ðÛ
Iô¥ô ôÛ
Jø¥ø øÛ
oListNodeÁü¥üprevÁüó üdataÁü_pinÁo¥×o
LinkedListÁ¥headÁtailÁo¥×HeapNodeÁŒ¥ŒparentÁŒ´‘Œó Œ first_childÁŒÈ‘ŒÔ‘¥× PairingHeapÁ¥rootÁš¥š×ÁChannelSendErrorÁ
¥ˆÁ¡¥Á£¥£Á¦¥¦×ÁTryReceiveErrorÁ©EmptyÁª
©ClosedÁ¬
ÁÁ¯Á±×ÁÁ Á
µƒÁ TrySendErrorÁ·¥·FullÁ¹
¹ˆ·ó”¼
¼ˆÁ ¿¥Á Á¥ÁÁ
Ä¥Ä×Î CloseStatusÁÇ NewlyClosedÁÈ
Ç
AlreadyClosedÁÊ
ÎÌ×ÎÎσÎÎÒÖÎÎÕÎ×§ØùÎ
RecvPollStateÁÚ UnregisteredÁÛ
Ú
RegisteredÁÝ
ÚNotifiedÁß
ÎÎâÎä×ÎRecvWaitQueueEntryÁæÿæºÎé×Î
SendPollStateÁëð—ì
뉘î
ë SendCompleteÁð
ÎÎóÎõ×StateIdÁ÷
÷ˆ
üƒþ×>ƒÖï
Û—ð—Œ
‰˜Ž
×Ô˜ÿº=×â
ChannelStreamÁš¥ÊfutureÁâ ¢¢š¢¥¢¢×ê SharedStreamÁ¨š¨¥¨¨ç ¨¨œ¨àê
¯š¯¥¯¯×ó PollStateÁ´NewÁµ
´WaitingÁ·
´DoneÁ¹
ó ó ¼Ó ;޿
¾îÁ
¾ ˜Ã
¾‚žÅ
Ó Ó Èé
ÍÊÞË
ÊîÍ
Ê ˜Ï
Ê‚žÑ
é
é
ÔÆ ÍÖð—×
Ö‰˜Ù
ÖExpiredÁÛ
Æ Æ Þ




!
"
#
$
0
0
0
4
;
<
=
>
?
C
M
M
M
S
T
U
V
W
^
^
^
d
e
f
g
h
|

ƒ
ƒ


ˆ
Š
Œ

Ž








¢
¦
ª
­
½
½
¾
¿
¿
È
É
æ
æ
æ
ì
ì
ì
ì
í
í
ð
ð
ð
ð
ñ
ñ






Œ

¡
¡
¡
¦
¬
¬
¬
±

Ç
Ç
Ç
Ì
Ì
Ì
Ð
Ô
Þ
å
å
å
ê
ê
ê
î
ò

ž
Ÿ
 
 
 
 
¡
¡
¯
¯
¯
´
µ

º
º
º
º
»
»
Ï
Ï
Ï
Ï
Ð
Ð
Ü
Ü
Ü
à
à
à
ä
è
ï
ó

¡
¢
£
£
£
£
¤
¤
²
²
²
·
¸
¹
½
½
½
½
¾
¾
Ò
Ò
Ò
Ò
Ó
Ó
ß
ã
ã
ã
ç
ç
ç
ë
ï
ö
ú
¦
¦
¦
¦
§
§
·
·
·
½
½
½
Â
Ç
È
Ó
Ô
Õ
Ö
Ö
Ö
Ö
×
×
å
å
å
ê
ë
ì
í
ñ
ñ
ñ
ñ
ò
ò
Š
Š
Š
Š


˜
˜
˜



¡
¥
±
±
±
µ
µ
µ
¹
½
Á
Å
Ì
Ð
Ñ


Œ
˜

š




œ

ž
Ÿ
Ÿ
Ÿ
Ÿ
 
 
¡
¡
³
³
³
º
»
¼
½
¾
¿
Ä
Ä
Ä
Ä
Å
Å
Ê
Ê
Ê
Ê
Ë
Ë
Ò
Ò
Ò
Ø
ý
ý
ý
ý
þ
þ
ƒ
ƒ
ƒ
ƒ





˜
˜
˜

¢
§
¬
µ

·
¼
½
¾
Ä
Ê
Ê
Ê
Ð









Ÿ
Ÿ
Ÿ
£
¤
¥
¦
§
§
§
§
¨
¨
´
´
´
¹
¹
¹
½
Á
ö
÷
ø
ù
ú
ú
ú
ú
û
û
ü
ü






Š
Ž



¤
¤
¤
ª
ª
ª
¯
´
Ã
Ã
Ã
È
É
Ê
ˆ

Š

Œ
Œ
Œ
Œ


Ž
Ž






š
œ
©
©
©
®
®
®
²

À
À
À
Ä
Å
Æ
Ç
Þ
Þ
Þ
á
ä
î
î
î
ò
ò
ò
õ
ø
þ




Š

Œ
¬
°
°
°
³
µ
¼
¼
¼
À
ã
ã
æ
æ
è
è
î
î
î
î
ï
ï
ð
ò
ô
ô
ô
ô
õ
õ
÷
ø
ú
û




Š

Ž









ž
ž
ž
¢
¢
¢
¥
¨
°
°
°
´
´
´
¸
Ê
Ê
Ê
Ï
Ï
Ï









œ
œ
œ
¥
¥
¨
¨
¨
°
°
²
²
²

Ã
Ã
Æ
Æ
Æ
Í
Í
Í
Ð
Ó
Ö
Ö
Ø
Ø
ã
ã
å
å
å
ê
ê
ê
ô
ô
ö
ö
ö
ý
ÿ
ÿ
ÿ



ˆ
ˆ
Š
Š





š
š
š
§
§
§
³
³
³
½
½
É
É
Õ
Õ
ß
ß
ê ó ö ù ¿cÌ
Ì
¦‚Í
Р Gäk¸í渥¥¹¥¹¥¹¥¹¥¹¥¹¥¹¥¹¥¹¥¹¥¹¥¹¥¹¥¹¥¹¥¹¥¹¥¹ ¥¹¥¹
¥¹¥¹ ¥¹¥¹ ¥¹¥¹
¥¹¥¹¥¹¥¹¥¹¥¹¥¹¥¹¥¹¥¹¥¹¥¹¥¹¥¹¥¹¥¹¥¹¥¹¥¹¥¹¥¹¥¹¥¹¥¹¥¹¥¹¥¹¥¹¥¹¥¹¥¹¥¹¥¹¥¹¥¹¥¹¥¹¥¹ ¥¹¥¹!¥¹¥¹"¥¹¥¹#¥¹¥¹$¥¹¥¹%¥¹¥¹&¥¹¥¹'¥¹¥¹(¥¹¥¹)¥¹¥¹*¥¹¥¹+¥¹¥¹,¥¹¥¹-¥¹¥¹.¥¹¥¹/¥¹¥¹0¥¹¥¹1¥¹¥¹2¥¹¥¹3¥¹¥¹4¥¹¥¹5¥¹¥¹6¥¹¥¹7¥¹¥¹8¥¹¥¹9¥¹¥¹:¥¹¥¹;¥¹¥¹<¥¹¥¹=¥¹¥¹>¥¹¥¹?¥¹¥¹@¥¹¥¹¥¹¥¹¥¹¥¹¥¹¥¹¥¹¥¹¥¹¥¹¥¹¥¹ ¥¹¥¹@¥¹¥¹¥¹¥¹¥¹¿c%%(¦
)*²+Á,ÐØÕÆ‚¢æ¥¹ÛÉŒ"ÛÉ¿cGGI¦
DJ´Dt™-Ëáqx¥¹ÓÊ¿cXXZ¦
D[Dt7éF믿¥¹œË¿cüüœ‘þ´‘oÿó oÈ‘oÔ‘o4‹LÌgsÉ¥¹é!åËö!åË¿có‘oˆ™’o5Cñ­<ûÒƒ¥¹Œ"ŸŸ þ Ì©ñyhíg¯¿cŒŒ¹’ŽÑ’´‘ó ð’ȑԑJ£Œ"¥¹é!ËÍö!ËÍ¿cª“Å“—^ë—0>¥¹Ðìžæ“ ˆ D÷êB¥¹µß˜Ï˜Ï¿c˜ÏÐ쩪«á”¬­ó”%¦e8µßïÏïÏ¿cïÏŠ ïÏÛïÏØïÏÐì·¹ºØ•»ˆ¼½ó”¾ˆ¼t6|Ìä ¥¹µßëÐëпcëпcÇÈÉÑ–ÊËé–7ç"éobzÛÛÑØÛÑŠ ÛÑÛÑÐìÛѵßÛÑÛÑšeÛÑÐìÚÛÜð—ÝÞ‰˜ßà ˜ìÁŠJðHµßîÒîÒ¿cîÒ¿cææÔ˜çÿèºçè¿Ëç!Ðìëìíð—îðñ¼™ª[ôÿ˜Ï
µß–Ô–Ô¿c–Ô¿cßßÝáÿâºã»ñåÊø[|¥¹ÌìòòôöÊ÷»øÐ[—&Úkî·š¥¿cÊÕ‚ØÊÕÊÕŒ"ÊÕÌìš Ê»˜ÐþO²Ç°“Ö™Ö¿cÓÖ‚ØÓÖÓÖŒ"ÓÖÌì»»ô¾Ê¿»ÀÐyOˆl†/š¥¿cØ×‚ØØ×Ø×Œ"Ø×ÌìÕÕš ØÊÙ»Úб”_ý} ë›Ø¡Ø¿cÛØ‚ØÛØÛØŒ"ÛØÌ좢ë(¥˜)ÿÒ¯#S5O$ë›Ø¡Ø ÚÙ¿cÚÙîÚÙ¡ØîÈÈÅ+ËÊÅ[.ðã4M©W›Ø¡Ø¡Ø¿cÑѪ,Ô˜)ÅÝ»o' êü֛ءؿcÕÕÞ,ؘ)Å(…›Ø¡ØŒ"ýÚŒ"ºÛÌ쥥Þ1¨˜)Ò#’|ÞpŸ›Ø¡Ø ŽÜ¿cŽÜîŽÜ¡ØîËËÅ+ÎÊÈÔ
ÕpT\à9›Ø¡Ø¡ØØØØÃ5Û˜)Èž0oi®‡¾å›Ø¡Ø¿cÔÔ†5ט)ÈÏwoÒuùÆ‚›Ø¡Ø¿c±ÝŒ"îÝŒ"±ÝŠ ÷÷øô™ùˆ 5Þ=BÆxßÕÛÌÞØÌÞ¿cÌÞ³ÌÞÐìÌÞµßÌÞÌÞÌÞºÌÞíßÌÞÌÞÐìŒð—މ˜¥åÍpEZ^µßõßõß¿cõß¿cÔ˜ÿº˜=°Ÿ;Hì¸BgÌ쨨ç:¬Ê­»®Ðªü—6â!“Ö™Ö¿cžá‚ØžážáŒ"žáÌìØØì=Û˜)-Hæã›Ø¡Ø ¦â¿c¦â¤¦â¡Ø¤Û@šAü©AüÊü¯uxÀž›Ø¡Ø¡ØÌ쌌ç:Êü»üÐüŠ= éHÔ{›Ø¡Ø¿câã‚ØâãâãŒ"âã¿c¦¦¨C©˜)üRݬâç ›Ø¡Ø¿cªªÚC­˜)üÅ£${y¤`›Ø¡ØØãäŒ"ã䨠åŒ" åÌ좢ùK¦˜)ânzH‰+µ`›Ø¡Ø Šæ¿cŠæêŠæ¡ØîŠæ¡Ø¿cë› Ê⡨œâ…ªˆÊW“Ö™ÖEçSçîòò”QöšAê÷©AêøÊê(×uJ󾼛ءØÀæ¡Øêìç¡Ø¿c¿R˜)êƒH&ÔءØÀæ¿cŠŠôRŽ˜)ê%tÜ›ÏÕxg›Ø¡ØÀæØØèŒ"ØèØ™éŒ"™é¿c¨¨ãœ¬ç ê­¨œê®àê5 ŽVoa&›Ø¡ØÀæE†êS†êÐì´µÞ·¸î¹º‚žWø9„ÕµßöêöêÌìå[˜ ˜)󋆿cZü0›Ø ×ë¿c×ëÌì© © Œ]¬ ½]ó­ »óßÉRfû'Í£“Ö¿c§ì‚اì§ìŒ"§ìÐ쾿ÀÞÁÂîÃÄ ˜ÅÆ‚žQEƒàvð•ûµßŸíŸí¿cý ý ñb
›`Ó ¦*>öê©8“Ö™ÖŒ"îé!îö!î îÌì

»dš
`Ó 
»Ó ƒÞ/"¢T“Ö™Ö¿cÿî‚ØÿîÿîŒ"ÿîÌìµ
µ
ºf¸
»Ó ¹
ºÓ ÉCi˜~¥–›“Ö¥¹ ûï¿cµ
µ
ºf¸
»Ó ¹
ºÓ ÉCi˜~¥–››Ø¡ØÐìÊËÌÞÍÎîÏР˜ÑÒ‚žD0‰É2±þ.µß™ñ™ñ¿c  Ál ïié
 µké
]D],ª[8“ÖŒ"ŠòÌì  Æm  ïié
¡ »é
¢ né
aÜi¾—k“Ö¿càò‚ØàòàòŒ"àòÌì· · °o¹ ºé

r”¤eüÁ›Ø äó¿cäó¿cØ Ø ¦rÚ ïiÕ Û µkÕ ÆhwÐÌå)t›ØŒ"³ôÌìå å £sç ïiÕ è »Õ é ‹nÕ $çà«§ûhŠ›Ø¿c„õ‚Ø„õ„õŒ"„õØù ù ×tû ºÕ ±{ñ®³P›ØÌìö ö¿cö¿c­ ­ ‰x® þw§ ä­Y½åƒô"« Üö¿c¹ ¹ ëxº ¹ ©¾lòÔ{« œ÷ÐìÖרð—ÙÚ‰˜ÛÜðŸK (>MmuµßÝ÷Ý÷µßÜ Ü ´zÝ ËzÆ Þ ÿÆ ß ºÆ < fr¼õ¾ø¾øíß¾ø¾øº¾øÌìü ü …}þ ˜)Æ Ž"_m›Ø ¶ù¿c¶ùö ¶ùù ¶ùó ¶ù¿c˜
˜
ô~š
ÈwÆ 
»Æ ‰ë R»í¶‚ئú¦úŒ"¦úÌì©
©
€€«
›€Æ ßæ—7~>pÞ¿cû‚ØûûÎ
Ì
-%KG\X‚üŒš¦±©Ä·ÌÇäÚéæõëäßýòÄ»âÕ¬¢ÙÑÝÕ¯¥àÔäØþ÷³¨âØŒ®¦²ª¯¢¢Š¯¨ – ± © ‚
ý  

À
µ
 ¦  ¾ · Ü Ø ì å ƒ ù ¯ ­ » ¹ ƒ
ü œ
˜
®
©
Ì
Ð
Ô
Ø
Ü
à
ä
è
ì
ð
ô
ø
ü
ˆŒ˜œ ¤¨¬°´¸¼ÀÄÈÌÐÔØÜàäèìðôøüˆŒ˜œ ¤¨¬°´¸¼ÀÄÈÌÐÔØÜàäèìðôø5%NG_X@Ÿò²Ñ»ïÕáÑåÕèÔìØÃ¨¢Œº¦Âªž¨Š¾ © †
ý °

š  ³  â Ø ö å ¦
˜
yü§ŒŠ
ý }ü«Œ
ý ¡®©¿·ÔÇáÚòë÷»´Ç¾ÓÊÝÖ£¯©Á·ÕÇâÚóëƒ÷¼´È¾ÔÊÞÖâ Ü ³©ÑÇú÷´©ÎÇû÷µ©ÏÇÜØü÷¦¾ª£Šü ù ÒÇ÷ä Ü ×ÇùòÁ»ßÕ¦¢©¥¯¨ÜØŒ§¢– ® © œ

º
µ
£  º · ê å ÿ ù ÿ ü ¬
©
ò§È»æÕ¸¨Œµ © ¥

ª  ï å Ÿ
˜
±
©
ˆò­Í»ëÕ¾¨žŒº © «

¯  ó å £
˜
©
©¢¬¥ßØ«¢– “
ý ½
µ
¼ · ù
ü ·¢ÌȺ¥ÏËÆ¢ùò÷÷ç Ü ÷å Ü îØÀ¢ÿòÌŨǪ́´ ­ ¿ ¹ Œ
ü
ü
ü ¿c7à
ûK¬Œ"é!¦ö!Ðì µß
TŠ [ÛØ ?šeÌì‚Ø Œ T
TîF³*ºíߤêES« ö ù ó   ü‚/ Ì
 °üëG
æ¸ PhantomDataÁFu\»ŸúŠ^  
10Á
10Á 11Á 11Á 12Á 12Á
13Á
13Á14Á14Á15Á15Á16Á16Á17Á17Á18Á18Á19Á19Á20Á20Á21Á21Á22Á22Á23Á23Á24Á24Á25Á25Á26Á26Á27Á27Á28Á28Á29Á29Á30Á30Á31Á31Á 32Á 32Á!33Á!33Á"34Á"34Á#35Á#35Á$36Á$36Á%37Á%37Á&38Á&38Á'39Á'39Á(40Á(40Á)41Á)41Á*42Á*42Á+43Á+43Á,44Á,44Á-45Á-45Á.46Á.46Á/47Á/47Á048Á048Á149Á149Á250Á250Á351Á351Á452Á452Á553Á553Á654Á654Á755Á755Á856Á856Á957Á957Á:58Á:58Á;59Á;59Á<60Á<60Á=61Á=61Á>62Á>62Á?63Á?63Á@64Á@64Á128Á128Á256Á256Á512Á512Á1024Á1024Á2048Á2048Á4096Á4096Á 8192Á 8192Á@16384Á@16384Á32768Á32768Á65536Á65536Áœ 
 
ŒÄ ¡ >üó
; ­  ­ ´ ² üÉ
kÜö
¤]¤]V¦]Á‚]üß3ø¤”&¸Lô° ¥¹ž)˜Ï5¥¹=D ·¥¹º)ëÐ5¥¹=D
 ·¥¹½)ëÐ5¥¹=D”‹ ÷ø%ÌÞ18?o”Àò¦ Æ
À¤,áI¦‚D‡JÌ
ü¯KüLI Synchronization primitives and utilities based on intrusive collections.ÁMúüQQN This crate provides a variety of `Futures`-based and `async/await` compatibleÁü£>; types that are based on the idea of intrusive collections:Áüâ'$ - Channels in a variety of flavors:Á - OneshotÁüš,) - Multi-Producer Multi-Consumer (MPMC)Á¼Ç - State BroadcastÁüß! - Synchronization Primitives:ÁÔ - Manual Reset EventÁ
- MutexÁŒª - SemaphoreÁ
- A timerÁÊúìÎ ## Intrusive collections?ÁìúüðOL In an intrusive collection, the elements that want to get stored inside theÁüÀKH collection provide the means to store themselves inside the collection.ÁüŒNK E.g. in an intrusive linked list, each element that gets stored inside theÁüÛLI list contains a pointer field that points to the next list element. E.g.Á¨ú ```Áü´OL // The element which is intended to be stored inside an intrusive containerÁÄ„ struct ListElement {ÁŒ data: u32,Áô¯ next: *mut ListElement,ÁÔúôØ // The intrusive containerÁŒ÷ struct List {Áü‰ head: *mut ListElement,Á¤²Ù°·úü»QN The advantage here is that the intrusive collection (here: the list) requiresÁü NK only a fixed amount of memory. In this case it only needs a pointer to theÁ”Ü  first element.Áï úüó NK The list container itself has a fixed size of a single pointer independentÁüÂ
%" of the number of stored elements.Áè
úüì
MJ Intrusive lists are often used in low-level code like in operating systemÁüº OL kernels. E.g. they can be used for storing elements that represent threadsÁüŠ PM that are blocked and waiting on queue. In that case the stored elements canÁüÛ HE be on the call stack of the caller of each blocked thread, since theÁü¤
=: call stack won't change as long as the thread is blocked.Áâ
úôæ
 ### Application in FuturesÁúü‰OL This library brings this idea into the world of Rusts `Future`s. Due to theÁüÙNK addition of `Pin`ning, the address of a certain `Future` is not allowed toÁü¨OL change between the first call to `poll()` and when the `Future` is dropped.ÁüøJG This means the data inside the `Future` itself can be inserted into anÁüÃNK intrusive container. If the the call to `Future::poll()` is not immedatelyÁü’MJ ready, some parts of the `Future` itself are registered in the type whichÁüàNK yielded the `Future`. Each `Future` can store a `Waker`. When the originalÁü¯PM type becomes ready, it can iterate through the list of registered `Future`s,Áü€HE wakeup associated tasks, and potentially remove them from its queue.ÁÉúüÍJG The result is that the future-yielding type is not required to copy anÁü˜QN arbitrary number of `Waker` objects into itself, and thereby does not requireÁüê! dynamic memory for this task.ÁŒúüOL When a `Future` gets destructed/dropped, it must make sure to remove itselfÁüàKH from any collections that refer to it to avoid invalid memory accesses.Á¬úü°NK This library implements common synchronization primitives for the usage inÁüÿ+( asychronous code based on this concept.Á«úü¯EB The implementation requires the usage of a fair chunk of `unsafe`ÁüõRO annotations. However the provided user-level API is intended to be fully safe.ÁÈúüÌ ## Features of this libraryÁìúüð2/ The following types are currently implemented:Áü£:7 - Channels (oneshot and multi-producer-multi-consumer)ÁüÞ;8 - Synchronization primitives (async mutexes and events)Á - TimersÁ§úü«# ## Design goals for the libraryÁÏúüÓPM - Provide implementations of common synchronization primitives in a platformÁÔ¤ independent fashion.Áü¿PM - Support `no-std` environments. As many types as possible are also providedÁüLI for `no-std` environments. The library should boost the ability to useÁüÝ+( async Rust code in environments like:Áü‰.+ - Microcontrollers (RTOS and bare-metal)Á|¸ - KernelsÁ - DriversÁüØKH - Avoid dynamic memory allocations at runtime. After objects from thisÁü¤JG library have been created, they should not require allocation of anyÁüïNK further memory at runtime. E.g. they should not need to allocate memoryÁü¾PM for each call to an asynchronous function or each time a new task accessesÁü " the same object in parallel.ÁÔ²  - Offer familiar APIs.ÁüÍ MJ The library tries to mimic the APIs of existing Rust libraries like theÁü›!?< standard library and `futures-rs` as closely as possible.ÁÛ!ú„ß!
## Non goalsÁð!úüô!QN - Provide IO primitives (like sockets), or platform specific implementations.ÁüÆ"PM - Reach the highest possible performance in terms of throughput and latency.Áü—#JG While code in this library is optimized for performance, portabilityÁüâ#>; and deterministic memory usage are more important goals.Áü¡$96 - Provide future wrappers for platform-specific APIs.ÁÛ$úüß$*' ## Local, Non-local and shared flavorsÁŠ%úüŽ%74 The library provides types in a variety of flavors:ÁÆ%úüÊ%52 - A local flavor (e.g. [`channel::LocalChannel`])Áü€&41 - A no

 ¤ë  渄¸  Àˆ ‰e:3óÖ­0à àæ¸  ã
Ôòá áæ¸  þ
$ÿ¼§â âæ¸  ¸
œüI¨-t’J
Buffer typesÁ4šJÄ
L6Di%kŽ<sld­GmiXnitTì‹
üM J A marker trait which may only be implemented for native array types, likeÁüNP M `[T; 2]`. The library incorporates several components that are parameterizedÁüŸL I by array types, but currently Rust provides no safe mechanism to expressÁ  that.Áö úüúM J In order to work around the limitations, these methods only accept arraysÁüÈP M which implement the `RealArray` type. The library provides an implementationÁü™M J of `RealArray` for arrays up to length 64, as well as for all powers of 2Á up to 64k.Áö úüúN K In order to let the library accept arrays of bigger sizes, `RealArray` canÁüÉL I be implemented by users via newtypes. A type as defined in the followingÁü–) & example can be passed to the library:ÁÀ ú Ù°üÌ- * use futures_intrusive::buffer::RealArray;Áüú1 . use futures_intrusive::channel::LocalChannel;Á¬ úü°$ ! struct I32x384Array([i32; 384]);ÁüÕ1 . unsafe impl RealArray<i32> for I32x384Array {Áü‡  const LEN: usize = 384;Á ¤²­ úü±( % impl AsMut<[i32]> for I32x384Array {ÁüÚ, ) fn as_mut(&mut self) -> &mut [i32] {Á¼‡  &mut self.0Á  ¤²¯ úü³( % impl AsRef<[i32]> for I32x384Array {ÁüÜ$ ! fn as_ref(&self) -> &[i32] {Áœ  &self.0ÁL• ¤²¥ ú fn main() {Áü¹ ? < let channel = LocalChannel::<i32, I32x384Array>::new();Á¤²ÿ ú
Ù°
¥Îìü‹
W Íì¡Ø ¦
‡“)‡“/#%„Ï
ܯ
 The length of the arrayÁÕ
¼ä
 ü
 , ƒ  Œ , 8Ÿ & 8$ˆ $  Ž *  , ž  Ÿ  8"4­ 8$´  ¸ 8¥ ¹  º 8Ä
 Å 8¥ Æ  Ç 8
É  Í Ó 8¥ Î % Ï , Ñ 8Ÿ Ò  Õ Š 8 8Û
í & ð 8¬ ø , ú 8Ÿ û % ü ¬*Ø|B\F%DÄ
L ÓŠ\(ÓŠ  MaybeUninitÁ\DÑÛdá(Git˜8Xi„i´9=ŒmÔR A Ring Buffer of itemsÁ<w‡“üm°‡“‡“ !"#$ !"#$Íì™™!$ #"ü…30 The type of stored items inside the Ring BufferÁ$ÂŒÿüÍ-* Creates a new instance of the Ring BufferÁ
üØ%ü•FC Creates a new instance of the Ring Buffer with the given capacity.ÁüàKH `RingBuf` implementations are allowed to ignore the `capacity` hint andÁü°# utilize their default capacity.ÁlÛ
´éä¦ôƒ The capacity of the bufferÁD©ã ã ²
¼øüÇ,) The amount of stored items in the bufferÁûä ä ÿ
$€ÔÑü”85 Returns true if no item is stored inside the buffer.ÁDÔå å Ý
!Üìü‘:7 Returns true if there is enough space in the buffer toÁ¼Ð store another item.ÁDïæ æ ø
"üð%üŒ-* Stores the item at the end of the buffer.Áü¾-* Panics if there is not enough free space.Á$óç ç¡™ ø
#÷üû üš.+ Returns the oldest item inside the buffer.ÁüÍ)& Panics if there is no available item.Áþè è¡™ 
$$‡ Ìó üŸ  An array-backed Ring BufferÁ¿ úüà JG `A` is the type of the backing array. The backing array must be a realÁüŽ
PM array. In order to verify this it must satisfy the [`RealArray`] constraint.Áüß
NK In order to create a Ring Buffer backed by an array of 5 integer elements,Áü® '$ the following code can be utilized:ÁÖ ú Ù°üâ 74 use futures_intrusive::buffer::{ArrayBuf, RingBuf};Áš úüž +( type Buffer5 = ArrayBuf<i32, [i32; 5]>;ÁüÊ  let buffer = Buffer5::new();Á Ù° ¥&''&Í쥹
Íì±Ê Š
ã±Ê
¥¹Ìš
à±Ê¯ª̶
±Ê¥¹
ÛÉØÕÆ‚¢æ()*+,Cprln´æ
%%ÑÛÑÛÖ–ÓÛuninitÁÝÔÛ»ÝÍõƒ«%9±Ê\‚$‚%%|“D“%%%%Ľ%%ÓŠFu\»Ÿ¥¹üÚ¥././‚ª ß“ª ⤪̖¹ª̲ͪÛÉ0Àc01368üâbåéêë éÛÉ ê c cˆ¢cµ
 `£cbufÁ `àB¤GS
ëÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
ŸÈŸÈ ÈErrorÁ O˜éBL- ò-
0¥¹±Ê± üÜl¥2323‚ª ᓪ 䤪̃¹ªÌŸͪÛÉ4*,/1üÏ0ì ìÛÉ1 Û1
4¥¹±Êlast_idxÁDæüíx¥6767‚ª ò“ª õ¤ªÌ ¹ª̼ͪÛÉ89:;<=>? "#$9=><:?;egjl55¥¹„€ƒÛÉ55
9¥¹±ÊüÐ%ÛÉ55
:¥¹±Ê_capÁ$áܼD¿í íÛÉ5 È5
;¥¹±Ê´‚î îÛÉ5 5
<¥¹±ÊÔÆï ïÛÉ5 Ò5
=¥¹±Êü¢%ð ðÛÉÛÉ5 ª5
>¥¹±Ê»üÝàñ ñÛÉ·5 ä5
?¥¹±Êü‡!u¥ABAB‚ª Œ!“ª !¤ªÌ·!¹ªÌÓ!ͪdï!ÛÉC"C1368”ƒ"$†"ò òÛÉ@ "@
C¥¹±Ê$"d±&»¤Œ&Ì—&Dµ&GXVecDequeÁDî&Ÿ(DFÄ
¦DEÓŠ©DEÓŠ¿DEÖ–¦ÑÛDEŽVDEØ%DEü¤DDE,È&äÚ&¦ÔÖ(üý&52 A Ring Buffer which stores all items on the heap.Á·'úü¿'MJ The `FixedHeapBuf` will allocate its capacity ahead of time. This is goodÁü‘(@= fit when you have a constant latency between two components.ÁÔ¥HH‚ª î(ÓÊt™-ËáqxIJ œû(4û(DGGŸ(Ÿ(¦¹¢(‚$£(‚$¤(Ü­‚$C¯\j Õ­ç¥¹çEçEèEGlobalÁ ¿±‡§í#T’*’*DGGü©*,¥LL‚ª ®*ÓÊMÀcMüà*nã*óôõ óÓÊ ô c cˆ¢cµ
 `£cÜ­ `àB¤GS
õƒ¯K ô*K
M¥¹$õ*± ‡+ü‡-#¥OO‚ª Œ-ÓÊPQRSTUVW "#$QUVTRWSEGLµ-$º-NN¥¹„Í-Ð-ÓÊNN
Q¥¹üÝ.$là.ÓÊNN
R¥¹´î.Ü0D 0ö öÓÊN ©0N
S¥¹$ª0´õ0ø0÷ ÷ÓÊN ü0N
T¥¹$ý0ÔÑ1DÔ1ø øÓÊN Ý1N
U¥¹$Þ1ü½2%$À2ù ùÓÊÓÊN Å2N
V¥¹$Ê2»,Ð2üÚ3Ý3ú úÓÊäÅN á3N
W¥¹$æ3ä8üê4KH A Ring Buffer which stores all items on the heap but grows dynamically.Áº5úüÂ5GD A `GrowingHeapBuf` does not allocate the capacity ahead of time, asÁüŽ6IF opposed to the `FixedHeapBuf`. This makes it a good fit when you haveÁüÜ6B? unpredictable latency between two components, when you want toÁü£7DA amortize your allocation costs or when you are using an externalÁäì7 back-pressure mechanism.Á4¥YY‚ª §8œËt7éF믿Z[ œ´84´8DXX©¾d9,9DXXü¤9.¥]]‚ª ©9œË^Àc^üÝ9nà9ûüý ûœË ü c cˆ¢cµ
 `£cÜ­ `àB¤GS
ýƒ¯\ ñ9\
^¥¹$ò9± „:üŠ<%¥``‚ª <œËabcdefgh "#$gechdbfEGLº<$¿<__¥¹„Ò<Õ<œË__
b¥¹üæ=&lé=œË__
c¥¹,÷=ÜŸ?D¢?þ þœË_ «?_
d¥¹$¬?´ù?ü?ÿ ÿœË_ €@_
e¥¹$@ÔÕ@DØ@ œË_ á@_
f¥¹$â@üÃA%$ÆA œËœË_ ËA_
g¥¹$ÐA»,ÖAüæBéB œËßÑ_ íB_
h¥¹$òBDœD\[±&´&¨&«&Ì £&ÜÝ—&ü·J ä»Jü
PhantomPinnedÁlE”íoqžÒ•íoqr,^é!osDerefMutÁDeö!ot§<you$1¬=hü1*GI13dt&œÌ¥ww‚ª ÑåËx
 üš"¡¥¹åËvv
x¥¹È‘ìÍ¥zz‚ª ÒåË{|ê!ë!|yy¥¹¬‡ƒ ƒåË ƒ¥¹y y
|¥¹$‘ü» ¥~~‚ª ÀåË÷!üâ! åË ¥¹} ï}
¥¹¬… ¥‚ª Š ØÌƒˆŠŒŽ,.¤Æ Í ØÌ
¥¹üÿ:L ØÌ åË 
ƒ¥¹nodeÁ$¢üŽ0T• ØÌÛ¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙ åË  
¥¹<closure_kind>Á<closure_signature>Á<upvars>Á¥¹§ ïíe¼îËè¿*åË åËü—<ˆ ˆØÌÛ¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙ ˆåË ­
¥¹ÒÚëÚ‰Û¥¹·Ü åËü© / ØÌÛ¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙ åË º 
ˆ¥¹4Õ#ˆÒÚëÚ‰Ûˆ¥¹´Üü°&;l·&Š ŠØÌÛ¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙ ŠåË Å&
Š¥¹$Ê&Tè)ŠÒÚëÚ‰ÛŠ¥¹ùÞüç*:dî* ØÌÛ¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙ åË û*
Œ¥¹$€+üó19\ú1Œ ŒØÌÛ¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙ ŒåË †2
¥¹$‹2ôù8D€9 ØÌ ‰9
Ž¥¹$Š9üÉ<?4×<Ž ŽØÌ åË Þ<
¥¹$ã<Ù$é<üéIU,ðI ØÌ ùIÍììç öI“"ìç å˼¦Jìç¹è˜"
¥¹ìç$þIfuncÁ$ˆJbdü¡T]l¨T ØÌìç ¹T˜è ¶T“"ìç å˼æTìçˆê˜"
¥¹ìç$¾Tüç$ÈT_aÔÙJ´ÝJ®°²´¸ŒžÒ”ížÒ•ííËër,Úé!äÒö!šDropÁ$ëŒ"§œ¬°Ÿtvü¤3ikWYBDdö5üë, ¥¹ ¥¹¥žž ‚ª úº¥¹ý
¥¹¬ ­ -/žÍÌ©ñyhíg¯ ¢2.ŸŸžÍ´³ žÍ¢"¢”Ô $×  žÍ¡ Ü ¡
¢œÎ¥¤¤‚ª ÓËÍ¥¦üœ"£¥¹ËÍ££
¥¥¹È‘ÌŠ< ËÍ£ £
¦¥¹$–ì¨‚ª óËÍ©ªê!ë!ª\’4—§§¥¹¬¨˜ ˜ËÍ ˜¥¹§ ±§
ª¥¹üÜ ¥¬¬‚ª áËÍ­÷!­üƒ!L† ËÍ ¥¹« «
­¥¹$•üâi§ ïíe¼îËè¿*Ë͘ô
 Asynchronous channels.Á
úüQ
N This module provides various channels that can be used to communicate betweenÁ¼q
 asynchronous tasks.Á<þJÁÎÿâêæ“„«
Ëæ“žËÊ”
©Ì¼•
·Í˜¤Œ
îÀõÅŒ¢
êÀöÛ—
ÚÀ÷Ô˜”Ä
æÀø‹™
ëÀùÝ”ë
ßÀúô¤ 
òüš Œ¶
ý¾–
Çþë(¬€
¢ÿÍ*œ—
¼ƒ+tÝ
ÀÂÞ1ô­
¥½3äÍ
¿ö3¼¨
ÈÅì=äö
ØÝÑ?Ô”
óÞô™
÷ßç:”½
¨àˆ@¬Œ
÷áùë›
ãùKtØ
¢ä¶Odè
ÙåÚO´ö
ÜæP<¿
áèç±PŒÈ
äéçÔ"4˜E ëñ

Àž©·¤¬ïÏÃÄìüÇ52 Returns whether the error is the `Empty` variant.ÁDˆïÏÂÂ
Ã$‘ô¿ü„63 Returns whether the error is the `Closed` variant.ÁLÆïÏÂÂ
ļ±
¥ÆÆ‚ª
ëÐÇÈÉä€ üÏ
,) Converts the error into its inner value.ÁT‡ ëÐ¥¹ÅÅ
Ç¥¹$’ ìÚ ü› :7 Returns whether the error is the `WouldBlock` variant.Á<á Ÿ ŸëÐÅ é Å
È¥¹ üšüß
6Í„   ëÐÅ «Å
É¥¹\
DG$'”Þ

Àßêîò·ÚæëÇæ“ ÎÏËæ“žÎÏËœ‘DF üÎÐÓŠ\b ÎÑÓŠÎÑPinÁ~ „¾ÎÒ FusedFutureÁ\ž ÎÔFutureÁ4« ‚ØÎÕk<Í ÌÎ×· œØÎØWakerÁ,Ü ãÎÙÔ"4ÃT ¹ó¼ ü!- ñÌT áts ¹¤‡ Ÿ¡‹”¸ |~jlSU„¹ ÛÑÛÜü$ üÐ; 8 Returns whether the value is the `NewlyClosed` variant.Á|— ÛÑÚÚ
Û üâ& ü = : Returns whether the value is the `AlreadyClosed` variant.ÁŒé ÛÑÚÚ
Ü ¼¿
ÙÓÞü†"  ÙÓÝÝ
Þüð ”û ¥àà‚ª Ž ÕñåÊø[|áâã"$¼Ã  ßßÛ¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙã㢋äwakerÁ¸ È
4åêé‚Äþ ,‚ ßß–Ô¤¶  ßßÛ¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙ¥¹üÏ2 ¥å傪 Ô ÕæÀcæüˆv  ¡¢£ ¡Õ ¢ c cˆ¢cµ
 `£cÜ­ `àB¤GS
£ƒ¯ä ˜ ä
楹$™ ×§ ìŸ ¥è肪 ¤ Õé 
üì- ó ¥¹Õçç
饹» ô© Œ³ ê¥ëê뇓ü©³ š“ Šꇓ"‡“íìííì35üΡ „Ø ¤¥¦§ ¤ ¥üüœ‘þ´‘oÿó oÈ‘oÔ‘o4‹LÌgsÉßßÝáÿâºã»ñåÊø[|¡Ø ¦ÌÌkλ¸Ï local_wakerÁ¸ÐextÁ¸Ñ_markerÁ¸Ò_marker2Á¸f'EwÚ]¾å§œØžØŸØÈ Øˆ¡Ø¢Ø´‰‰Nµý¤ÃÛ¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙ¡Øê ò ê
ì¡Ø »L cxÁº üõe ”ø ¨© ¨ ©š—ê  ê
í¡Ø$• » üÓ! ¤Ý î¥ïîüÓ° š“ ò "‡“ñðññð35üû œ… ª«¬­ ª «üüœ‘þ´‘oÿó oÈ‘oÔ‘o4‹LÌgsÉÙÓ ¬ÌÌkλ¸ÏÚ—¸Ðó—¸Ñ„˜¸Ò™˜¸f'EwÚ]¾å­œØžØŸØÈ Øˆ¡Ø¢Ø´‰‰Nµý¤Ãšî ¢ î
ð¡Ø » Ššç üœe ¬Ÿ ®¯ ® ¯Õî ¾ î
ñ¡Ø$¿ » üÜ"1 ü… E B A Future that is returned by the `receive` function on a channel.ÁüË E B The future gets resolved with `Some(value)` when a value could beÁô‘!  received from the channel.Áü°!J G If the channels gets closed and no items are still enqueued inside theÁüû!/ , channel, the future will resolve to `None`.Á.ü«"0  futures do nothing unless polledÁ¤ç" óšô¥õôóõÍì“ÖL€# Íì™Ö ‹# ™ÖüÚ#; ÊÕ[—&Úkî·ö÷øü" []WYU<å# òòÛ¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙ î™ÖüÃ$2 LÎ$ òòÕü™%+ D¤% òòÓŠFu\»Ÿ“Öü'] úšû¥üüúûå¤L' ö¤ ¢'  “Ö$œ' Ìì™Ö$¥' ÊÕ' 79<>üä'V þšÿ¥þÿå¤Lí' ö¤ ø' ÊÕÀcé' !#&(üÁ(@ Ä( °±² °ÊÕ ± c cˆ¢cµ
 `£cÜ­ `àB¤GS
²ƒ¯ý È( ý
“Ö™Ö$É( ± Ï( üÅ)H ƒš¥ƒå¤LÎ) ö¤ Ù) ÊՃ؄ØÊ) *,/1\”* 4™* Û¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙ™Öü²*F $µ* ³´µ„¾„¾¤Š†¾ ˜X$]È=„kt• ³ÊÕ ´ÌÌkλ¸ÏÚ—¸Ðó—¸Ñ„˜¸Ò™˜¸f'EwÚ]¾åµœØžØŸØÈ Øˆ¡Ø¢Ø´‰‰Nµý¤Ãž¬ Ä* 
“Ö™Ö$º* ŠšÐ* ü…2M šŠ¥Šå¤LŽ2 ö¤ ™2 ÊÕŒŒŠ2  "%'üÙ2 lÜ2  ÊÕˆ ê2 ˆ
Œ“Ö™Ö$ë2 ü£3F Žš¥Žå¤L¬3 ö¤ ·3 ÊÕ"¨3 !#&(”ð3 $ó3 · ·ÊÕ ø3 
“Ö™Ö$ý3 üÀ9. üÞ6B ? A Future that is returned by the `send` function on a channel.Áü¡7> ; The future gets resolved with `None` when a value could beÁÜà7  written to the channel.Áüü7D A If the channel gets closed the send operation will fail, and theÁüÁ8M J Future will resolve to `ChannelSendError(T)` and return the item to send.Á90 …£ŒË9 š¥å¤Lá9 ö¤ ì9 ‡¥ü¸:8 —¥ ÓÖþO²Ç°˜Ý9 BDGIL<Ã: Û¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙ ê™Öüž;5 L©; üüœ‘þ´‘oÿó oÈ‘oÔ‘o4‹LÌgsÉßßÝáÿâºã»ñåÊø[|™Öü÷;+ D‚< ާüß=Z šš¥œœšå¤Lï= ö¤ €> ƒ¨$ú= “¨$ƒ> ÓÖë= &(+-ü¿>S žšŸ¥  žŸå¤LÈ> ö¤ Ó> ÓÖ¡Àc¡Ä> !#&(ü™?@ œ? ¸¹º ¸ÓÖ ¹ c cˆ¢cµ
 `£cÜ­ `àB¤GS
ºƒ¯  ? 
¡“Ö™Ö$¡? ± §? üš@: £š¤¥¥£¤¥å¤L£@ ö¤ ®@ ÓÖ¦Ÿ@  üŽA% üÛ@. + Tries to cancel the ongoing send operationÁ4•A » »ÓÖž¬¢ œA ¢
¦“Ö™Ö$¡A üÀCE ¨š©¥ªª©¨å¤LÉC ö¤ ÔC ÓÖ«¬ƒØ„جÅC *,/1\ŒD 4D §§Ö¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
žæ“ ˆ D÷êB™ÖüÀDs $ÃD ¼½¾„¾„¾¤Š†¾ ˜X$]È=„kt• ¼ÓÖ ½ÌÌkλ¸ÏÚ—¸Ðó—¸Ñ„˜¸Ò™˜¸f'EwÚ]¾å¾œØžØŸØÈ Øˆ¡Ø¢Ø´‰‰Nµý¤Ã¸À§ ÛD §
¬“Ö™Ö$ÑD ŠšïD ü®OJ ®š¯¥°¯®°å¤L·O ö¤ ÂO ÓÖ±±³O  "%'üÿO lP ¿ ¿ÓÖ­ P ­
±“Ö™Ö$‘P üÉPC ³š´¥µµ´³å¤LÒP ö¤ ÝP ÓÖ"ÎP !#&(”“Q $Q À ÀÓÖ² ›Q ²
“Ö™Ö$ Q d•T »¤ŒT ÌûS D™T ιӊ·¸ÑÓŠ¨·¸Ñ¤Š„¾·¸Ò¼Š·¸ÔÛŠŽ‚Ø·¸ÕkÌ·¸×·œØ·¸Ø¢‹ã·¸ÙÝÝß·¸Åê·¸˜ìî·¸ôèò·¸š &
·¸ü;··¸¾–\‰ Ç·¸Û— Ú·¸Ô˜”¢ æ·¸‹™l‚ ë·¸æ“r ·¸ÏËæ“ ž·¸ÏËœ‘{ ü·¸Ð,¬T t»T »ÕÔ"͹¹ºÓŠ¥ ¹º¸ÑÓŠ ¹º¸Ñ¤Š´ „¾¹º¸Ò¼Š² ¹º¸ÔÛŠ´ ‚عº¸Õk» ̹º¸×· œØ¹º¸Ø¢‹Å 㹺¸ÙÝß¹º¸ÅM깺¸˜*¸üU·¹º¸¾–ǹº¸Û—!Ú¹º¸Ô˜$湺¸‹™'빺¸æ“œ"¹º¸ÏËæ“½"ž¹º¸ÏËœ‘­"ü¹º¸Ð,ØT üòW- üëTE µ ü¹UE „¡ô‡V Ò¡ü®VJ ú¡üW/ ΢.ü¹W0 …£¤ýW š¼¥½¼½Íì›ØL’X š“ X Ø×yOˆl†/¾¿ÀÔ-/24üüXY <‡Y »»Û¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙ†J†JK‰Jµ 7ŠJphantomÁ7J¤7·0ØQdèî¡Øö¾ü“Z2 LžZ »»ÕüùZ+ D„[ »»ÓŠFu\»Ÿ›Øü‰]] šÂ¥Ã÷ÑL•] š“ ¦]  ›Ø$ ] Ìì¡Ø$©] Ø×1368ü„^J šÅ¥ÆÆÅ·ÑL‰^ š“ ”^ Ø×ÇÀcÇ "üÝ^@ à^ ÁÂà ÁØ×  c cˆ¢cµ
 `£cÜ­ `àB¤GS
Ã¯Ä ä^ Ä
ǛءØ$å^ ± ë^ ü`@ šÉ¥ÊÊÉ·ÑL†` š“ ‘` Ø×Ë̃؄ØÌ$&)+\Ð` 4Õ` ÈÈšüö`u $ù` ÄÅÆ„¾„¾¤Š†¾ ˜X$]È=„kt• ÄØ× ÅÌÌkλ¸ÏÚ—¸Ðó—¸Ñ„˜¸Ò™˜¸f'EwÚ]¾åÆ«ŸÈ ™a È
̛ءØ$a Ššµa ü’kE šÎ¥ÏÏηÑL—k š“ ¢k Ø×ÐÐ!üæk lék Ç ÇØ×Í ÷k Í
ЛءØ$øk üÐl> šÒ¥ÓÒÓ·ÑLÕl š“ àl Ø×Ô"Ô "m $ m È ÈØ×Ñ ¥m Ñ
ԛءØ$ªm üòs* üÔpB Ÿ²üŸq> ë²Üæq ²³üŠrD ׳ü×rD A Future will resolve to `ChannelSendError(T)` and return the itemÁd¤s to send.Á.ü¹s0 …£Œýs šÖ¥××Ö·ÑLt š“ št ÛØ±”_ý} ëØÙÚò-/24üûtV <†u ÕÕÛ¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙ†J†JK‰Jµ 7ŠJ†Ò7‹J¤7·0ØQdèê¡Øö¾üv5 Lšv ÕÕš—üøv+ Dƒw ÕÕúÓü¸w2 šÜ¥ÝÜÝ·ÑL½w š“ Èw ÛØÞü´x% üùw. ‘½4»x É ÉÛØšÛ Âx Û
ޛءØ$Çx üŽ}N šà¥ááà·ÑLš} š“ «} âÔ$¥} òÔ$®} ÛØ "%'üé}G šã¥äãä·ÑLî} š“ ù} ÛØåÀcå "ü¿~@ Â~ ÊËÌ ÊÛØ Ë c cˆ¢cµ
 `£cÜ­ `àB¤GS
̃¯â Æ~ â
囨¡Ø$Ç~ ± Í~ üà= šç¥èçè·Ñ š“ ð ÛØéêƒØ„Øê$&)+\¬€ 4±€ ææÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
žæ“ ˆ D÷êB¡Øüè€ $ë€ ÍÎÏ„¾„¾¤Š†¾ ˜X$]È=„kt• ÍÛØ ÎÌÌkλ¸ÏÚ—¸Ðó—¸Ñ„˜¸Ò™˜¸f'EwÚ]¾åϜ؞؟ØÈ Øˆ¡Ø¢Ø´‰‰Nµý¤Ãêçæ  æ
ê›Ø¡Ø$ Šš§ üºŽB šì¥ííì·ÑL¿Ž š“ ÊŽ ÛØîî "ü‹  Ð ÐÛØë œ ë
î›Ø¡Ø$ üõ; šð¥ñðñ·Ñ š“  ÛØò"ò!#”¿  Ñ ÑÛØï Ç ï
ò›Ø¡Ø t’” 
u7x7f7i7V7Y7F7I76797'7*7tŠ
777777\Ú

À¢¼¾Ã˜¤B îÿõô¤X òÿüæ“„n ÿƒË擞ÿƒË¾–\€ ÇÿþÛ—l‘ Úÿ÷Ô˜”  æÿøó‘ ÿœ‘ üÿŠŠ‚„‰ Ê
ÿ¦‚ Ì
ÿŒÓŠ ÿÓŠÿk<ä Ìÿ· œØÿ¤ "ÿÝ€ ÿƒ+t“C ÀÂÔ"4ÝD Åý,5 °³ž¡Ž^aJM69 ü») +.¼‚ üþ̰ ë”Ï Çɵ·Dø §©˜ü–= d™ ÿÒ Òó‘oˆ™’o5Cñ­<ûÒƒÙÓ ¯
†(<¦  ÒÚëÚ‰Û Õ´½  ÿ¥‚ª Ñ Î'˜ê'ÿ»ÿš†(ÿ$?D$¥¹$?D$˜šhj d ÿ„Ý  ÿŒ’üà ' ÿô¼ï ¥œœ‚ª ô ‰öžŸ ¡Ü

ÿ‰ö
¥¹üÇ ? ÿÓ Ó‰ö¥¹Ö¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
˜Ï Ï 
ž¥¹ » ü‹"  ÿÔ Ô‰öÛÑ  
Ÿ¥¹$™ üû \… ÿÕÖר Õ‰ö ÖÕ ×ÌÌkλ¸ÏÚ—¸Ðó—¸Ñ„˜¸Ò™˜¸f'EwÚ]¾å؜؞؟ØÈ Øˆ¡Ø¢Ø´‰‰Nµý¤ÃŒ’ š 
 ¥¹ » Ššã üá!I lä! ÿÙÚ Ù‰ö ÚÕ ò! 
¡¥¹$÷! »Lý! üÝ+8 ü¢(F C A channel which can be used to exchange a single value between twoÁ¬é(  concurrent tasks.Áÿ( úüƒ)@ = Tasks can wait for the value to get delivered via `receive`.ÁüÄ)Q N The returned Future will get fulfilled when a value is sent into the channel.Á* úüš*N K The value can only be extracted by a single receiving task. Once the valueÁüé*M J has been retrieved from the Channel, the Channel is closed and subsequentÁü·+% " receive calls will return `None`.Á¬è+ 𣥤¤£·ÑLþ+ š“ “, ›ØD‰, ÚÙÒ¯#S5O$ë¥57:<üœ,( ,œ, ÿ¢¢""¤%@ &È‘ 5á»I'yÆD›ØÎ'˜ê'ÿ»ÿš†(ÿ$?D$¡ØüÇ-a 𧥍¨§·ÑLÓ- š“ ï- ö‚DÞ- Ìì›Ø$é- òÔ$ò- ÚÙ1368üò.a šª¥«ª«·ÑLþ. š“ š/ ö‚D‰/ âÔ$”/ òÔ$/ ÚÙ(*-/üÙ/Y š­¥®­®·ÑLÞ/ š“ ó/ ö‚Dé/ ÚÙ¯Àc¯#%(*ü¹0@ ¼0 ÛÜÝ ÛÚÙ Ü c cˆ¢cµ
 `£cÜ­ `àB¤GS
݃¯¬ À0 ¬
¯›Ø¡Ø$Á0 ± Ç0 ü¾1@ š±¥²±²·ÑLÃ1 š“ Ø1 ö‚DÎ1 ÚÙ³´µ$&)+ü½23 ü…23 0 Creates a new OneshotChannel in the given stateÁÄ2 ÚÙ°°
³›Ø¡Øü†6? üÜ3) & Writes a single value to the channel.ÁŠ4 úü’4A > This will notify waiters about the availability of the value.ÁüØ4@ = If a value had been written to the channel before, or if theÁü59 6 channel is closed, the new value will be rejected andÁüÛ5& # returned inside the error variant.Á$6 Þ ÞÚÙ¡Øêç° ’6 °
´›Ø¡Ø$“6 »,™6 üç8" ¼ù6  Closes the channel.Á•7 úü7K H This will notify waiters about closure, by fulfilling pending `Future`sÁ„í7
with `None`.Áü‚8B ? `send(value)` attempts which follow this call will fail with aÁÌÉ8  [`ChannelSendError`].Á,î8 ß ßÚÙÛѰ ô8 °
µ›Ø¡Ø$õ8 ü¯:; ü¹9O L Returns a future that gets fulfilled when a value is written to the channelÁì:  or the channel is closed.Á<¶: à àÚÙòòôöÊ÷»øÐ[—&Úkî·à›Ø¡Ø° ¾: °
›Ø¡Ø$¿: ü¤<` š¸¥¹¸¹·ÑL©< š“ ¾< ö‚D´< ÚÙº»ðñ»º.035ü‹=š œ•= áâãä áÚÙ âÕ ãÌÌkλ¸ÏÚ—¸Ðó—¸Ñ„˜¸Ò™˜¸f'EwÚ]¾å䫟· ²= ·
º›Ø¡Ø$³= »LÁ= Šš÷= üè>d ¬ë> åæ åÚÙ æÕ· Š? ·
»›Ø¡Ø$‹? »L™? üù@ ü¿@9 6 A [`GenericOneshotChannel`] which is not thread-safe.Áœ‚A ¥½½‚ª –A ¢¢ë(¥˜)ÿÒ¯#S5O$ëæ¸¥¹9;TØA »À|ÆA ¼ÀA 4ÜA ÿÀ˜¤î¾¿õô¨ò¾¿üŠ‚ÿ Ê
¾¿ÓŠé¾¿Óо¿kñ̾¿·ôœØ¾¿¤÷"¾¿Ý€ú¾¿µ'r ¾¿Î'о¿ë(H ¢¾¿Í*¬¼¾¿ð*A¾¾¿üD³D þ¿Ô"dž¿ýæ“꾿ƒË擞¾¿ƒË¾–óǾ¿þÛ—öÚ¾¿÷Ô˜ù澿øó‘ü¾¿œ‘ÿü¾¿Š¦‚ìÌ
¾¿Œ,íA ÔŠC ü¼BI F A [`GenericOneshotChannel`] implementation backed by [`parking_lot`].ÁÇ¥ÁÁ‚ª ¢C ¢¢ë(¥˜)ÿÒ¯#S5O$ëÃÃ݀ĺ­í’zðsûC¥¹dfdƒD d¯D »¤Œ›D Ì•D ÿŘ îÃÄõôòÃÄüŠ‚f Ê
ÃÄÓŠPÃÄÓŠiÃÄkXÌÃÄ·[œØÃĤ^"ÃÄÝ€aÃĵ'Ù ÃÄÎ'ñÃÄë(¯¢ÃÄÍ*¼ÃÄð*¨¾ÃÄügÃÃă+ÜÀÃÄÂæ“PÃÄƒËæ“mžÃă˾–YÇÃÄþÛ—\ÚÃÄ÷Ô˜_æÃÄøó‘bÃÄœ‘eüÃÄŠ¦‚RÌ
ÃÄŒ,ÆD tÕD ÊÈÑÕéôô¤ E »ÅÇìÔ"ôÅÅÆ˜¦îÅÆÄõŠ‚é Ê
ÅÆÄÓŠ×ÅÆÄÓŠôÅÆÄkçÌÅÆÄ·îœØÅÆÄ¤õ"ÅÆÄÝ€üůĵ'x ÅÆÄÎ'ÅÆÄë(V¢ÅÆÄÍ*¾¼ÅÆÄüÃÅÆÄƒ+{ÀÅÆÄÂþ.lÖs öü/|•u 
 `£cÜ­ `àB¤GS
٠ÙV Ù
ܛءØ$ÚV ± àV üïW{ šÞ¥ßßÞ·ÑLôW š“ ÿW ö‚DáX ºÛàÀcà#%(*üY@ „Y ðñò ðºÛ ñ c cˆ¢cµ
 `£cÜ­ `àB¤GS
òƒ¯Ý ˆY Ý
à›Ø¡Ø$‰Y ± Y ü Zm šâ¥ããâ·ÑL¥Z š“ °Z ö‚D„[ ýÚä"ä#%(*”¤[ $§[ ó óýÚá ¬[ á
䛨¡Ø$±[ üŸ]o šæ¥ççæ·ÑL¤] š“ ¯] ö‚D…^ ºÛè"è#%(*”¥^ $¨^ ô ôºÛå ­^ å
è›Ø¡Ø$²^ üˆcã ü `F C Creates a new oneshot channel which can be used to exchange valuesÁüï`) & of type `T` between concurrent tasks.Áü¡a3 0 The ends of the Channel are represented throughÁüÝa% " the returned Sender and Receiver.Áb úü—bE B As soon es either the senders or receivers is closed, the channelÁÔåb  itself will be closed.Á¼c ýÚºÛšê¥ëêë·ÑL§c š“ ²c ö‚DÍd òÔ$æd
雨¡Ø)+.0üügn ší¥îîí·ÑLh š“ Œh ö‚D×h ›Ø<âh ýÚï&(+-üÛk? üi) 쉷i úüÇiA «Šü•j@ öŠüâj9 À‹ü¨k& ƒŒ$âk õ õýÚ¡Øêçì çk ì
ï›Ø¡Ø$èk »,îk üílp šñ¥òñò·ÑLòl š“ ýl ö‚DÊm ŽÃ<Õm ºÛó#%(*ü¡o; üômP M Returns a future that gets fulfilled when a value is written to the channel.ÁüÑnC @ If the channels gets closed, the future will resolve to `None`.Á<¨o ö öºÛØ×ð °o ð
󛨡Ø$±o TÄr »À|ªr ¼¤r 4Èr ÅöøúÅ+ÙÈôõª, ÑôõÞ,ˆ Õôõˆ.š éôõð*`ôôõÔ"+ÅôõƘ¾,îôõÆÄõŠ‚, Ê
ôõÆÄÓŠ÷+ôõÆÄÓŠ,ôõÆÄk,ÌôõÆÄ·,œØôõÆÄ¤%,"ôõÆÄÝ€0,ôõÆÄµ'°+ ôõÆÄÎ'Ð*ôõÆÄë(–$¢ôõÆÄÍ*¼ôõÆÄüJÃôõÆÄƒ+Ç,ÀôõÆÄÂæ“C.ôõÆÄƒËæ“h.žôõÆÄƒË¾–\.ÇôõÆÄþÛ—g.ÚôõÆÄ÷Ô˜r.æôõÆÄøó‘}.ôõÆÄœ‘ˆ.üôõÆÄЦ‚}.Ì
ôõÆÄŒô»ôõÇì,ár ÌÍs üørH E A [`GenericOneshotSender`] implementation backed by [`parking_lot`].Áä¥÷÷‚ª äs ÑѪ,Ô˜)ÅÝ»o' êüÖ󞥹9;ÜŒu üµtJ G A [`GenericOneshotReceiver`] implementation backed by [`parking_lot`].Á¥ùù‚ª ¥u ÕÕÞ,ؘ)Å(…󞥹9;üyp üùu"  Creates a new oneshot channel.Á¨v úü¸v5 2 Refer to [`generic_oneshot_channel`] for details.Áúv úüŠw@ = Example for creating a channel to transmit an integer value:Á×w ú<çw Ù°üûw> ; # use futures_intrusive::channel::shared::oneshot_channel;ÁüÆx6 3 let (sender, receiver) = oneshot_channel::<i32>();Á<‰y Ù°bù϶ѥûû‚ª ´y Ì쥹$ˆz
ú¥¹ d«{ tç{ 
3j6j'j*jìÎ
j”
Θ
À¥¿ÁƘ¤r
îõô¤ˆ
òüæ“„ž
Ëæ“žË¾–
ÇþÛ—
Úˆ÷Ô˜”Ð
æøó‘T—
Œœ‘
üŠ‚„¹
Ê
ަ‚
Ì
ÓŠ
ÓŠk<”
Ì·$
œØ¤
"Ý€
ö3¼×E
ÃÅÔ"4³G
È,e
²µ £Œ^aJM69
üë)
+.¼²
üþÌà
ë”ÿ
Çɵ·D¨
§©˜üÆ=

÷ ÷ô ß
†(<Ö

ÒÚ˜ëÚ˜‰Û˜˜˜Ãõ´í

¥šš‚ª 
Î'ê'œ»†(F1±°êѶ¡¥¹F1±°êѶ¡œhj”À


,
Œ’üó '
ôüŸ
+
¥ŸŸ‚ª ¤
Ø¥¹
ŒÜ ¡¢£¤')ÜÑ
Ô
ŒÜžž
 ¥¹ü‹
?
ø øŒÜ¥¹‡ùž
ž
¡¥¹$˜
»
üÏ"

ù ùŒÜÛÑž Ø
ž
¢¥¹
ü¿

úûüý úŒÜ ûÕ üÌÌkλ¸ÏÚ—¸Ðó—¸Ñ„˜¸Ò™˜¸f'EwÚ]¾åýµüž Þ
ž
£¥¹
»
Šš§
ü®#I
l±#
þÿ þŒÜ ÿÕž ¿#
ž
¤¥¹$Ä#
»LÊ#
üö,A
üï)N
K A channel which can be used to exchange a single value between two or moreÁ¬¾*
‡þÔ*
úüØ*L
I The value which gets sent will get stored inside the Channel, and can be矴+9
6 retrieved by an arbitrary number of tasks afterwards.Áß+
úüã+@
²þü¤,Q
üþô-
𦥧¦§·ÑL -
š“ µ-
ö‚D«-
ŽÜÒ#’|ÞpŸ¨.035ü¾-(
,¾-
¥¥""¤%@ &È‘ 5á»I'yÆD›ØÎ'ê'œ»†(F1±°êѶ¡¡Øüé.j
šª¥««ª·ÑLõ.
š“ /
ö‚D€/
™…$/
òÔ$”/
ŽÜ(*-/ü0j
š­¥®®­·ÑL©0
š“ Å0
ö‚D´0
âÔ$¿0
òÔ$È0
ŽÜ(*-/ü1b
š°¥±±°·ÑL’1
š“ §1
ö‚D1
ŽÜ²Àc²#%(*üö1@
ù1
 ŽÜ  c cˆ¢cµ
 `£cÜ­ `àB¤GS
ƒ¯¯ ý1
¯
²›Ø¡Ø$þ1
± „2
ü„3]
š´¥µµ´·ÑL‰3
š“ ž3
ö‚D”3
Ø¡Ø,Û3
ŽÜ·¸¹469;ü©4<
üè3<
9 Creates a new OneshotBroadcastChannel in the given stateÁ°4
ŽÜ³³
›Ø¡Øü„8?
üÚ5)
쉈6
úü6A
«ŠüÖ6@
öŠü›79
À‹üÙ7&
ƒŒ$8
ƒ ƒŽÜ¡Øêç³ 8
³
·›Ø¡Ø$8
»,—8
üå:"
¼÷8
œ“9
úü›9K
É„ë9
Žü€:B
·ŽÌÇ:
,ì:
 ŽÜÛѳ ò:
³
¸›Ø¡Ø$ó:
ü­<;
ü·;O
ì‹<
Ü<´<
 ŽÜòòôöÊ÷»øÐ[—&Úkءس ¼<
³
¹›Ø¡Ø$½<
ü¢>}
𻥼¼»·ÑL§>
š“ ¼>
ö‚D²>
Ëì,™?
ŽÜ½¾ðñ½¾68;=ü¦?š
ϡ?
ˆ ŽÜ Õ ˆÌÌkλ¸ÏÚ—¸Ðó—¸Ñ„˜¸Ò™˜¸f'EwÚ]¾å«Ÿº Í?
º
½›Ø¡Ø$Î?
»LÜ?
Šš@
üƒAd
 A
Š ŠŽÜ Õº ¥A
º
¾›Ø¡Ø$¦A
»L´A
üC(
üÚBB
? A [`GenericOneshotBroadcastChannel`] which is not thread-safe.Áä¦C
¥ÀÀ‚ª ÃC
¥¥Þ1¨˜)Ò#’|ÞpŸæ¸¥¹9;TD
»À|€D
¼úC
4D
ØîÁÂõôòÁÂüŠ‚] Ê
ÁÂŽÓŠGÁÂÓŠ`ÁÂkOÌÁ·RœØÁ¤U"ÁÂÝ€XÁµ'Ð ÁÂÎ'6ÁÂÞ1P
¥Á½3¬¿ÁÂð*AÁÁÂüD‰G
ÆÁÂÔ"ÂÈÁÂæ“IÁÂËæ“fžÁÂ˾–QÇÁÂþÛ—TÚÁˆ÷Ô˜WæÁÂøó‘ZÁÂŒœ‘]üÁ¦‚JÌ
ÁÂ,§D
üÎE#
ü÷DR
O A [`GenericOneshotBroadcastChannel`] implementation backed by [`parking_lot`].Á/¥ÄÄ‚ª ïE
¥¥Þ1¨˜)Ò#’|ÞpŸóž¥¹9;dÙF
d…G
»¤ŒñF
ÌëF
òȘJîÆÇõôNòÆÇüŠ‚£ Ê
ÆÇŽÓŠÆÇÓŠ¦ÆÇkÌÆÇ·˜œØÆÇ¤"ÆÇÝ€žÆÇµ' ÆÇÎ'|ÆÇÞ1
¥ÆÇ½3ò¿ÆÇð*ÁÆÇüFÆÆÇö3ÃÆÇÅæ“ŽÆÇËæ“«žÆÇ˾–ÇÆÇþÛ—ÚÆÇˆ÷Ô˜œæÆÇøó‘ŸÆÇŒœ‘¢üÆÇ¦‚Ì
ÆÇ,œG
t«G
ËÔØðûô¤öG
»ÈÊìÔ"1ÈÈɘåîÈÉÇõŠ‚& Ê
ÈÉÇŽÓŠÈÉÇÓŠ1ÈÉÇk$ÌÈÉÇ·+œØÈÉǤ2"ÈÉÇÝ€9ÈÉǵ'µ ÈÉÇÎ'ÈÉÇÞ1=¥ÈÉǽ3¿ÈÉÇüáÆÈÉÇö3¸ÃÈÉÇÅ“8´°~
ýƒ¹8ÄŠ€
ÿƒá8ÌÓ„
ƒæ“iÈÉÇËæ“ŠžÈÉÇ˾–yÇÈÉÇþÛ—ÚÈÉLj÷Ô˜æÈÉÇøó‘ŽÈÉÇŒœ‘üÈÉǦ‚Ì
ÈÉÇ,ÈG
üÞG,
éü•H5
üœH
Ț̥ÍÍÌ·ÑL½H
š“ ÈH
ö‚DðH
‚«<‰I
ðÜÔ
ÕpT\à9Î68;=ü¨I5
<¨I
ÈËËŽÜüýJ®
šÐ¥ÑÑзÑL‚K
š“ K
ö‚DŒL
Ëì,¥L
ðÜÒÓðñÒÓ68;=üÂLº
œÌL
ŒŽ ŒðÜ Õ ŽÌÌkλ¸ÏÚ—¸Ðó—¸Ñ„˜¸Ò™˜¸f'EwÚ]¾å«ŸÏ ñL
Ï
қءØ$òL
»LˆM
ŠšÆM
üÚN|
¬ÝN
 ðÜ ÕÏ „O
Ï
ӛءØ$…O
»LO
üùQ6
ü¸PF
ì®ì‡Q
»¯­Q
úü¹Q7
î¯ì„R
šÕ¥ÖÕÖ·ÑL¢R
š“ ­R
ö‚DÕR
Ëì,îR
‚«<öR
îÝÏwoÒuùÆ‚×ëACFHü•Sf
,•S
ÈÔÔ†J†JK‰Jµ 7ŠJ†Ò7‹J¤7·0ØQdèðÜö¾üÀV8
üTH
¡²ìáT
»¯‡U
úü“UK
Œ³üçUP
á³üËV
šÙ¥ÚÚÙ·ÑLëV
š“ öV
ö‚DžW
Ëì,·W
‚«<¿W
±Ýž0oi®‡¾åÛïACFHüÞWf
,ÞW
ÈØØÓüËY™
šÝ¥ÞÝÞ·ÑLÐY
š“ ÛY
ö‚D»Z
Ëì,ÔZ
‚«<ÜZ
±ÝßÙß358:¼ûZ
,þZ
 ±Ý±ÝÜ „[
Ü
ߛءØ$…[
üŽ\¤
šá¥âáâ·ÑL“\
š“ ž\
ö‚D“]
Ëì,¬]
îÝãÀcã+-02üÉ]@
Ì]
 îÝ  c cˆ¢cµ
 `£cÜ­ `àB¤GS
ƒ¯à Ð]
à
ã›Ø¡Ø$Ñ]
± ×]
üï^¦
šå¥ææå·ÑLô^
š“ ÿ^
ö‚Dö_
Ëì,`
±ÝçÀcç+-02ü¬`@
¯`
˜ ±Ý  c cˆ¢cµ
 `£cÜ­ `àB¤GS
˜ƒ¯ä ³`
ä
ç›Ø¡Ø$´`
± º`
üÔaŒ
šé¥êéê·ÑLÙa
š“ äa
ö‚DÁb
Ëì,Úb
îÝë"ë+-02”÷b
$úb
 îÝè ÿb
è
ë›Ø¡Ø$„c
üòdŽ
ší¥îíî·ÑL÷d
š“ e
ö‚Dáe
Ëì,úe
±Ýï"ï+-02”—f
$šf
š š±Ýì Ÿf
ì
ï›Ø¡Ø$¤f
üÜl‡
üÄiP
M Creates a new oneshot broadcast channel which can be used to exchange valuesÁüj)
¢¾üÏj3
Õ¾ü‹kG
D the returned `Sender` and `Receiver`. The `Receiver` can be cloned.ÁÛk
úüçkI
F As soon es either the senders or all receivers is closed, the channelÁÔ¹l
›Àüãl!
îݱݚñ¥òñò·ÑL…m
š“ m
ö‚D½n
òÔ$Ön
Ëì,Ýn
ð›Ø¡Ø1368ür
šô¥õôõ·ÑL”r
š“ Ÿr
ö‚Dór
ŽÃ<þr
Ëì,s
îÝö+-02üv?
ü³s)
ì‰és
úüùsA
«ŠüÇt@
öŠü”u9
À‹üÚu&
ƒŒ$”v
 îÝ¡Øêçó ™v
ó
ö›Ø¡Ø$šv
», v
üŸw
šø¥ùøù·ÑL¤w
š“ ¯w
ö‚D…x
ŽÃ<x
Ëì,¨x
±Ýú+-02üòy;
üÅxP
óÄü¢yC
ÍÅ<ùy
œ œ±ÝØ×÷ z
÷
ú›Ø¡Ø$z
T•}
»À|û|
¼õ|
4™}
ÈýÿÅ+Þ
Ëûü†5 ÔûüÃ5å Øûü“7' ðûüð*`ûûüÔ"L&Èûüɘ(îûüÉÇõŠ‚I' Ê
ûüÉÇŽÓŠ;'ûüÉÇÓŠ\'ûüÉÇkS'ÌûüÉÇ·^'œØûüÉǤi'"ûüÉÇÝ€t'ûüÉǵ'ô& ûüÉÇÎ'b&ûüÉÇÞ1„!¥ûüÉǽ3è¿ûüÉÇü0ÆûüÉÇö3 (ÃûüÉÇÅæ“ˆ)ûüÉÇËæ“­)žûüÉÇ˾– )ÇûüÉÇþÛ—«)ÚûüÉLj÷Ô˜¶)æûüÉÇøó‘Á)ûüÉÇŒœ‘Ì)üûüÉǦ‚Á)Ì
ûüÉÇô"»ûüÊì,²}
ü§~"
üÉ}Q
N A [`GenericOneshotBroadcastSender`] implementation backed by [`parking_lot`].Áõ¥þþ‚ª Ç~
ÔÔ†5ט)ÈÏwoÒuùƂ󞥹9;ü$
ü¡S
P A [`GenericOneshotBroadcastReceiver`] implementation backed by [`parking_lot`].Á«¥‚ª £€
ØØÃ5Û˜)Èž0oi®‡¾å󞥹:<üÌ„¡
ü€,
) Creates a new oneshot broadcast channel.Á¹
úüÉ?
< Refer to [`generic_oneshot_broadcast_channel`] for details.Á•‚
úü¥‚@
‹Òò‚
ú<‚ƒ
Ù°ü–ƒH
E # use futures_intrusive::channel::shared::oneshot_broadcast_channel;Áüëƒ@
= let (sender, receiver) = oneshot_broadcast_channel::<i32>();Á<¸„
Ù°v˜­á®¥‚ª í„
½Õ$à…
÷Ý,ç…
¥¹ "d•‡
tч
¼Ž
 ˜£˜”˜—˜ü0
˜œÂ

À¤¨ÈÊØóõú÷øæ“„HËæ“žË¾–\ZÇŒþ󑜑üŠ‚„º Ê
¦‚Ì
ÓŠÓŠ¤Š„¾¼ŠÛŠ‚Ø˜k<ÒÌš·œØ¢‹ãœ¤"žÝ€D‚Ÿˆ@¬ºu÷ùÔ"4wüÛ,@¤§wz,lül)kn[^¼³O<?Ìá-t€d”Ô”üþëíü”;ßáÍϺ¼Dð¬®ÌÞ¡¤¨ü¸B? Returns the initial StateId, which is guaranteed to return theÁüÿ$! oldest buffered value available.Á¯ÌÞ  
¡¼Õ Ïà£üœ 3£ ÌÞÏࢢ
£=D§ üÕ!¤ß¤¥¥¤¥‡“üÕ»š“ ô¤‡“"‡“§¦§¦§35üý¦œ‡žŸ   žüüœ‘þ´‘oÿó oÈ‘oÔ‘o4‹LÌgsÉÏà ŸÌÌkλ¸ÏÚ—¸Ðó—¸Ñ„˜¸Ò™˜¸f'EwÚ]¾å œØžØŸØÈ Øˆ¡Ø¢Ø´‰‰Nµý¤ÃÛ¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙÌޡؤ ¤¤
¦¡Ø»Ššéü©e¬¬¡¢ ¡ ¢Ç»¤ ˤ
§¡Ø»üì/ü’UR A Future that is returned by the `receive` function on a state broadcast channel.ÁüèQN The future gets resolved with `Some((state_id, state))` when a value could beÁôºÒ¡ÙúüÝOL `state` represents the new state which had been retrieved from the channel.Á­úü±GD `state_id` is the [`StateId`] which can be passed as a parameter toÁüùB? `receive()` in order to fetch the next state from the channel.Á¼úüÀJú¡ü‹/΢.ü»0…£”÷©šª¥«ª«©å¤ö¤ ؙև¥üú0—¥ žáªü—6â!¬­®ÇŠRTWYL<ú¨¨Û¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙ ¤™ÖüØ'¨¨Ç»ü£ ¨¨ާü€c°š±¥²²°±å¤Lö¤ ¡ƒ¨$›½Ä“¨žáŒ.035üé[´šµ¥´µå¤ö¤ ý½Ä,€žá·Àc·î)+.0üË@Σ¤¥ £žá ¤ c cˆ¢cµ
 `£cÜ­ `àB¤GS
¥ƒ¯³ Ò³
·“Ö™Ö± ÙüÍM¹šº¥»»¹ºå¤ö¤ á½Äžá¼½ƒØ„ؽÒ2479¸¸Û¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙÌÞ™ÖüÊh¦§¨„¾„¾¤Š†¾ ˜X$]È=„kt• ¦žá §ÌÌkλ¸ÏÚ—¸Ðó—¸Ñ„˜¸Ò™˜¸f'EwÚ]¾å¨œØžØŸØÈ Øˆ¡Ø¢Ø´‰‰Nµý¤Ã·Ë¸ å¸
½“Ö™ÖŠšùü¹%V¿šÀ¥Á¿ÁÀå¤LÂ%ö¤ Í%½Ä,Ð%žá¾%(*-/ü–&l™&© ©žá¾ §&¾
“֙Ö$¨&üà&KÄšÅ¥ÆÆÄÅå¤Lé&ö¤ ô&½Ä,÷&žáÇ"Çå&)+.0”²'$µ'ª ªžáà º'Ã
Ǔ֙Ö$¿'üž*=d¡*« «ó‘oˆ™’o5Cñ­<ûÒƒÏà ·*
Ȇ(<®*Dù,ÈÒÚÉëÚɉÛÉÉÈÉ Ç»´Í.dÔ.¥ËË‚ª á.ÊÊÎ'ÌóÍ=λφ(÷S¶˜ÄŽ%¥¹÷S¶˜ÄŽ%ÌÍÎÏvx|š/Lš/ÊÊŒÑ/DÑ/ÊÊÌÞ0,0ÊÊŒ’üƒ1'<ƒ1ÊÊìÒü¯1+¥ÑÑ‚ª ´1÷Ý,Ô1åÔÒÓÔÕÖ×"$Üá1ä1åÔÐÐ
Ò¥¹ü¹4?$¼4¬ ¬åÔ¥¹‡ùÐ Á4Ð
Ó¥¹$Æ4»,Ì4ü›7",ž7­ ­åÔÛÑÐ ¤7Ð
Ô¥¹$©7ü©9D\¬9® ®åÔÌÞÛ¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙÌÞ¥¹Ð ¸9Ð
Õ¥¹$½9=DÃ9üþ=©œˆ>¯°±² ¯åÔ °Ç» ±ÌÌkλ¸ÏÚ—¸Ðó—¸Ñ„˜¸Ò™˜¸f'EwÚ]¾å²œØžØŸØÈ Øˆ¡Ø¢Ø´‰‰Nµý¤ÃÜÙÐ ¥>Ð
Ö¥¹$ª>»L¸>Ššî>ü NIl£N³´ ³åÔ ´Ç»Ð ±NÐ
×¥¹$¶N»L¼NüñV?üßTLI A channel which can be used to synchronize the state between a sender anÁü¬U" arbitrary number of receivers.ÁÏUúüÓU%" The sender can publish its state.ÁùUúüýUPM The receivers can wait for state updates by announcing the most recent stateÁüÎV" that is already known to them.ÁäüVšÙ¥ÚÚÙ·ÑL™Wš“ ®Wö‚D¤W¦â-HæãÛ.035ü·W(,·WØØ""¤%@ &È‘ 5á»I'yÆD›ØÊÊÎ'ÌóÍ=λφ(÷S¶˜ÄŽ%¡ØüâXhšÝ¥ÞÞÝ·ÑLîXš“ ŠYö‚DùX™…$„YòÔ$Y¦â(*-/ü”Zhšà¥ááà·ÑL Zš“ ¼Zö‚D«ZâÔ$¶ZòÔ$¿Z¦â(*-/ü‚[`šã¥äãä·ÑL‡[š“ œ[ö‚D’[¦âåÀcå#%(*üé[@ì[µ· µ¦â  c cˆ¢cµ
 `£cÜ­ `àB¤GS
·ƒ¯â ð[â
囨¡Ø$ñ[± ÷[üõ\[šç¥èçè·ÑLú\š“ ]ö‚D…]Ëì,Ê]¦âéêëìí/146ü˜^Vü×]<9 Creates a new State Broadcast Channel in the given stateÁŸ^¦âææËì,è^
雨¡Øüb?üå_)쉓`úü›`A«Šüá`DA If the maximum amount of values had been written to the channel,ÁüªaC@ or if the channel is closed, the new value will be rejected andÁüòa&ƒŒ$¤b¸ ¸¦â¡Øêçæ ©bæ
ê›Ø¡Ø$ªb»,°büþd"¼cœ¬cúü´cKÉ„„dŽü™dB·ŽÌàd,…e¹ ¹¦âÛÑæ ‹eæ
ë›Ø¡Ø$ŒeüóhcüÐeOì¤fÜüÆfFC `state_id` specifies the minimum state ID that should be retrievedÁü‘g by the `receive` operation.Áµgúü½gC@ The returned [`StateReceiveFuture`] will get fulfilled with theÁü…hLI retrieved value as well as the [`StateId`] which is required to retrieveÁÄÖh the following state.Á<úhº º¦âÌÞ¨¨ç:¬Ê­»®Ðªü—6â!º›Ø¡Øæ ‹iæ
ì›Ø¡Ø$Œi=Dšiü‰mDü˜kQN Attempt to retrieve a value whose `StateId` is greater than the one provided.ÁîkúüökSP Returns `None` if no value is found in the channel, or if the current `StateId`ÁüÎl63 of the value is less or equal to the one provided.Á\m» »¦âÌÞâ½æ œmæ
í›Ø¡Ø$m=D£mü‰nnšï¥ððï·ÑLŽnš“ £nö‚D™nËì,¦n¦âñò¦§òñ68;=üþn¥œˆo¼½¾¿ ¼¦â ½Ç» ¾ÌÌkλ¸ÏÚ—¸Ðó—¸Ñ„˜¸Ò™˜¸f'EwÚ]¾å¿½î ¥oî
ñ›Ø¡Ø$¦o»L´oŠšêoüîpd¬ñpÀÁ À¦â ÁÇ»î qî
ò›Ø¡Ø$‘q»LŸqü†s&üÅr@= A [`GenericStateBroadcastChannel`] which is not thread-safe.ÁÔs¥ôô‚ª ªsØØì=Û˜)-Hæã渥¹9;T÷s»À|ås¼ßs4ûs÷Š‚º" Ê
õöÓŠ¤"õöÓŠ½"õö¤Š¬"„¾õö¼Š¯"õöÛŠ²"‚Øõö˜kµ"Ìõöš·¸"œØõö¢‹»"ãõöœ¤¾""õöžÝ€Á"õöŸ˜!¤õöç::¨õöµ'ý ÈõöÎ'Êõöì=÷
ØõöÑ?óõöð*õõöüDèvúõöÔ"S#üõöÛô™<–÷õöô™øõöÛ—õöÔ˜”ù õöæ“V%õöËæ“s%žõö˾–_%ÇõöŒþó‘c%õöœ‘f%üõö¦‚S%Ì
õö,Œtü±u!üÜtPM A [`GenericStateBroadcastChannel`] implementation backed by [`parking_lot`].ÁÜ$¥øø‚ª ÐuØØì=Û˜)-Hæã󞥹9;d¸vdäv»¤ŒÐvÌÊvüŠ‚r& Ê
úûÓŠ\&úûÓŠu&úû¤Šd&„¾úû¼Šg&úûÛŠj&‚Øúû˜km&Ìúûš·p&œØúû¢‹s&ãúûœ¤v&"úûžÝ€y&úûŸ˜Ì$¤úûç:ò¨úûµ'µ ÈúûÎ'ÍÊúûì=¯ØúûÑ?ºóúûð*Oõúûü¸úúûˆ@'÷úûùô™·÷úûô™ÌøúûÛ—·úûÔ˜úûæ“ )úûËæ“()žúû˾–)ÇúûŒþó‘)
 `£cÜ­ `àB¤GS
ʃ¯ ÝŽ
˜›Ø¡Ø$ÞŽ± äŽüø>šš¥š·Ñš“ ˆâ㜃؄Ø&(*,â½üöËÌÍ„¾„¾¤Š†¾ ˜X$]È=„kt• Ëâã ÌÌÌkλ¸ÏÚ—¸Ðó—¸Ñ„˜¸Ò™˜¸f'EwÚ]¾åͽ ™‘
›Ø¡Ø$Ššµ‘ü—›CšŸ¥  Ÿ·ÑLœ›š“ §›âã¡¡ "üé›lì›Î Îâãž ú›ž
¡›Ø¡Ø$û›üÓœ<𣥤¤£·ÑLØœš“ ãœâã¥"¥!#”žÏ Ïâ㢠¦¢
¥›Ø¡Øü”¢+üÓ Fì®좡»¯È¡úüÔ¡7Ÿ¢š§¥¨§¨·ÑL²¢š“ ½¢ö‚Då¢Ëì,þ¢‚«<†£ãäRݬâç ©½FHJLü¥£m,¥£ü¦¦†J†JK‰Jµ 7ŠJ†Ò7‹J¤7·0ØQdèˆãö¾üצ-ü§¤H¡²ìø¤»¯ž¥úüª¥KŒ³üþ¥P᳤⦚«¥¬¬«·ÑL÷¦š“ ‚§ö‚Dª§Ëì,ç‚«<˧ åÅ£${y¤`­ÅFHJLüê§m,ê§üªªƤü쨚¯¥°°¯·ÑLñ¨š“ ü¨ö‚DÚ©Ëì,ó©ãä±Àc±/135üª@“ªÐÑÒ Ðãä Ñ c cˆ¢cµ
 `£cÜ­ `àB¤GS
Òƒ¯® —ª®
±›Ø¡Ø$˜ª± žªü««š³¥´³´·ÑL°«š“ »«ö‚D›¬Ëì,´¬ åµÀcµ/135üѬ@Ô¬ÓÔÕ Ó å Ô c cˆ¢cµ
 `£cÜ­ `àB¤GS
Õƒ¯² ج²
µ›Ø¡Ø$Ù¬± ߬üî­š·¥¸¸··ÑLó­š“ þ­ö‚DÑ®Ëì,ê®ãä¹Ù¹/135¼‡¯,НÖ Öãäãä ¯
¹›Ø¡Ø$‘¯ü•²š»¥¼¼»·ÑLš²š“ ¥²ö‚D÷²Ëì,³ãä½"½/135”­³$°³× ×ãäº µ³º
½›Ø¡Ø$º³üá¶š¿¥À¿À·ÑLæ¶š“ ñ¶ö‚DÆ·Ëì,ß· åÁÙÁ/135¼ü·,ÿ·Ø Ø å å¾ …¸¾
Á›Ø¡Ø$†¸üŽ»ƒšÃ¥ÄÄ÷ÑL“»š“ ž»ö‚Dò»Ëì,‹¼ åÅ"Å/135”¨¼$«¼Ù Ù å °¼Â
śءØ$µ¼üÎÂïüÞ¿NK Creates a new state broadcast channel which can be used to exchange valuesÁüµÀ)¢¾üçÀ3Õ¾ü£Á%’¿ÑÁúüÝÁEͿԫ›ÀüÕÂãä åšÇ¥ÈÇÈ·ÑLõš“ €Ãö‚D—ÄËì,°ÄòÔ$¸Ä
ƛءØ68:<üÍȚʥËÊË·ÑLÒÈš“ ÝÈö‚D¦ÉŽÃ<±ÉËì,ÉÉãäÌ0246üÀÌ?üæÉ)쉜Êúü¬ÊA«ŠüúÊ@öŠüÇË9À‹üÌ&ƒŒ$ÇÌÚ Úã䡨êçÉ ÌÌÉ
̛ءØ$ÍÌ»,ÓÌüÒ͚ΥÏÏηÑL×Íš“ âÍö‚D­ÎŽÃ<¸ÎËì,ÐΠåÐÑ3579üÏÒ{üíÎOìÉÏÜüóÏFÀìüÆÐíòÐúü‚ÑCÅíüÒÑL’î¼«Ò the following stateÁ<ÖÒÛ Û åÌÞâãÍ ïÒÍ
ЛءØ$ðÒ=D†Óüã×süÒÕQÆð°ÖúüÀÖS­ñü ×6Šò\ê×Ü Ü åÌÞâ½Í ‡ØÍ
ћءØ$ˆØ=DžØT“Ú»À|ùÙ¼óÙ4—ÚüÔÖØœ†Ê„ÄÒÓÿ®Í¼ÀÒÓÛ@[ÒÓç:ÃŒÒÓ¨C5
¦ÒÓÚCþ ªÒÓ¼E ÆÒÓð*¨ÒÒÓÔ"·CüÒÓýŠ‚êD Ê
ÒÓýûÓŠÜDÒÓýûÓŠýDÒÓýû¤ŠôD„¾ÒÓýû¼ŠÿDÒÓýûÛŠ
E‚ØÒÓýû˜kEÌÒÓýûš· EœØÒÓýû¢‹+EãÒÓýûœ¤6E"ÒÓýûžÝ€AEÒÓýûŸ˜œC¤ÒÓýûµ'y7 ÈÒÓýûÎ'™6ÊÒÓýûì=ƒ0ØÒÓýûÑ?–$óÒÓýûüˆ"úÒÓýûˆ@ôE÷ÒÓýûùô™—"÷ÒÓýûô™´"øÒÓýûÛ—§"ÒÓýûÔ˜®"ÒÓýûæ“ HÒÓýûËæ“0HžÒÓýû˾–$HÇÒÓýûŒþó‘0HÒÓýûœ‘;HüÒÓýû¦‚0HÌ
ÒÓýû,°Ú¼šÛüÇÚFC A [`GenericStateSender`] implementation backed by [`parking_lot`].Á8¥ÕÕ‚ª ¯Û¦¦¨C©˜)üRݬâç 󞥹:<ÌÓÜüþÛHE A [`GenericStateReceiver`] implementation backed by [`parking_lot`].Áã¥×ׂª êܪªÚC­˜)üÅ£${y¤`󞥹:<ü€áü¼Ý*' Creates a new state broadcast channel.ÁóÝúüƒÞ=: Refer to [`generic_state_broadcast_channel`] for details.ÁÍÞúüÝÞ@‹Òªßú<ºßÙ°üÎßFC # use futures_intrusive::channel::shared::state_broadcast_channel;Áü¡à>; let (sender, receiver) = state_broadcast_channel::<i32>();Á<ìàÙ°¦°ÆîÇ¥ÙÙ‚ª Ÿá÷Ý,üá½Õ$„â
Ø¥¹ "d¯ãtëã
ëäîäßäâäÒäÕäÆäÉäüõ,
¿äD¤

ÀŒ¢ÙÜßèó‘Tqâ䜑D}üâå%âèkŽâélŠ‚„Á Ê
âꦂÌ
âëÓŠâíÓŠâí¤Š„¾âîÛŠ‚Øâð FusedStreamÁ\ÄSâòStreamÁ4ÑEâók<åÌâõ·œØâö¢‹ãâ÷¤"âùÝ€D•âú˜¤²îâüõô¤ÈòâýüÅŒÞêâþöš Œõâÿý¾–ÇâþÛ—l•Úâ÷Ô˜”¤æâø‹™ëâƒùÝ”ËßâúÊ”©â̼•·âÍ’P<ƒ½áç±PŒ¶¾äçÔ"4£ÁêáüK#×ÚÈËœŒÂű´¼º£œïD„`d“Tü“.;>'*ü“O"þòõãæÙܯɳ £Œx{dgPS=@),ü‚BŒ…âÝ Ýô  
†(<—ÒÚˆëÚˆ‰ÛˆˆˆÃõüÕ
Hί
âÞ Þó‘oˆ™’o5Cñ­<ûÒƒÕ¥ŠŠ ö
‚ª ê

¥¹†(<í

ÒÚëÚ‰Û¥¹ üüœ‘þ´‘oÿó oÈ‘oÔ‘o4‹LÌgsÉÕü—e.\‹äšâß ßôß Å
Œ†(<¼Ìôâ¥ŽŽ‚ª ˆ“ª ±ÊŒ›±Ê¥¹Î'óâ¦
â™Jâ°Jâ¡ÞUÚ+ÎÑx¥¹±Ê¡ÞUÚ+ÎÑx£¥¨ªââ±Êüæ/âôüÅ/âÜÕüù=¥ÔÙ“ª ÅÙŒ¤‚ª þåÙ˜šœžŸ ¡)+FHü½'Àâ±ÊåÙ
¥¹±Ê¦
œªâà àåÙ ³
˜¥¹±Êüœ"âá áåÙÛÑ ¥
¥¹±Êü³Jââ âåÙ¥¹Ö¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
ßëÐ ¿
š¥¹±Ê»üý$³„‡%âãäåæ ãåÙ äÈ× åÌÌkλ¸ÏÚ—¸Ðó—¸Ñ„˜¸Ò™˜¸f'EwÚ]¾åæÈ™Œ’ß ¡%
¥¹±Ê$¦%»L´%Šší%üý7@.\í7ü€8!âç çåÙß ¢8
œ¥¹±Ê$§8üû<FÔþ<âè èåÙÛ¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙ¥¹ß ™=
¥¹±Ê$ž=üƒEH\†Eâé éåÙÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
¸äïÏ ’E
ž¥¹±Ê$—EüòL¯œüLâêëìí êåÙ ëÕ ìÌÌkλ¸ÏÚ—¸Ðó—¸Ñ„˜¸Ò™˜¸f'EwÚ]¾åíœØžØŸØÈ Øˆ¡Ø¢Ø´‰‰Nµý¤Ãóã ™M
Ÿ¥¹±Ê$žM»L¬MŠšâMüáWh”äWâîï îåÙ ïÈ× €X
 ¥¹±Ê$…X»L“XüÙ`y.\É`¬Ü`âðñ ðåÙ ñÕß û`
¡¥¹±Ê$€a»LŽaüóo4üÊjFC A channel which can be used to exchange values of type `T` betweenÁ¬‘k‡þ§kúü«kIF `A` represents the backing buffer for a Channel. E.g. a channel whichÁüõk74 can buffer up to 4 `i32` values can be created via:Á­lú<±lÙ°ü¹l30 # use futures_intrusive::channel::LocalChannel;ÁüílC@ let channel: LocalChannel<i32, [i32; 4]> = LocalChannel::new();Á<±mÙ°¹múü½mKŒ³ü‰nPá³üÚn7î¯ü’oHE The returned Future will get resolved when the value has been storedÁ¼Ûo inside the channel.Átþo𣥤¥¥£¤·ÑLpš“ ¢pÍìÀæ ¥pö‚D˜pÀ挵pÀæ¡ØD½pŠænzH‰+µ`¦`begacüÎp+,Îp⢢""¤%@ &È‘ 5á»I'yÆD›ØÎ'óâ¦
â™Jâ°Jâ¡ÞUÚ+ÎÑx¡ØÀæüüq‡š¨¥©ª¨©ª ¾ðDòrš“ ¤r–ð ­rö‚D“r™…$žròÔ$§r¯ðŒêr·ÑLˆrÌìÀæ$þrŠæVX[]üÍs€š¬¥­®­®¬¾ðDÃtš“ õs–ð þsö‚DäsâÔ$ïsòÔ$øs¯ðŒ»t·ÑLÙsŠæ
EGJLüÓtxš°¥±²±°²¾ðDÁuš“ ít–ð ðtö‚Dãt¯ðŒ¹u·ÑLØtŠæ³Àc³@BEGüÒu@Õuòóô òŠæ ó c cˆ¢cµ
 `£cÜ­ `àB¤GS
ôƒ¯¯ Ùu¯
³›Ø¡ØÀæ$Úu± àuüÉv_šµ¥·µ·¾ðDžwš“ ãv–ð ævö‚DÙv¯ðŒ–w·ÑLÎvŠæ¸¹º»¼½¾¿ "MORT¤šxü¯w>; Creates a new Channel, utilizing the default capacity thatÁüòw# the RingBuffer in `A` provides.Á¡xŠæ´´
¸›Ø¡ØÀæüñz-ü›yDA Creates a new Channel, which has storage for a `capacity` items.ÁüäyIF Depending on the utilized `RingBuf` type, the capacity argument mightÁü²z:7 be ignored and the default capacity might be utilized.ÁløzŠæ´´
¹›Ø¡ØÀæ¾D†{ü•~?ü|KH Returns a future that gets fulfilled when the value has been written toÁ„í|
the channel.Áü‚}IF If the channel gets closed while the send is in progress, sending theÁüÐ}@= value will fail, and the future will deliver the value back.Á$œ~õ õŠæ¡Øš Ê»˜ÐþO²Ç°õ›Ø¡Ø´ ¡~´
º›Ø¡ØÀæ$¢~»,¨~üŽ…?ü’€.+ Attempt to send the value without waiting.ÁÅ€úüÍ€DA This operation is not supported for unbuffered channels and willÁü–JG panic if the capacity of the `RingBuf` is zero. The reason for this isÁüåHE that the actual value transfer on unbuffered channels always happensÁü²‚KH when a receiving task copies the value out of the sending task while itÁü‚ƒGD is waiting. If the sending task does not wait, the value can not beÁü΃IF transferred. Since this method can therefore never yield a reasonableÁüœ„HE result with unbuffered channels, it panics in order to highlight theÁüé„  use of an inappropriate API.ÁD•…ö öŠæ¡ØÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
·¹ºØ•»ˆ¼½ó”¾ˆ¼t6|Ìä ¡Ø´ ž…´
»›Ø¡ØÀæ$Ÿ…»,¥…üøˆ;üÛ‡PóÄü°ˆCÍÅ<ÿˆ÷ ÷ŠæòòôöÊ÷»øÐ[—&Úkî·÷›Ø¡Ø´ ‡‰´
¼›Ø¡ØÀæ$ˆ‰ü²‹7üïŠ>; Attempt to receive a value of the channel without waiting.Á\¹‹ø øŠæÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
¡ØïÏ´ Å‹´
½›Ø¡ØÀæ$Æ‹üä6üšŽ@= Returns a stream that will receive values from this channel.ÁߎúüçŽ@= This stream does not yield `None` when the channel is empty,Áü¬30 instead it yields `None` when it is terminated.Á4ëù ùŠæë› Ê⡨œâ…ªˆÊWù›Ø¡ØÀæ´ ò´
¾›Ø¡ØÀæüå’"¼…‘œü¡‘30 All pending and future send attempts will fail.ÁüÙ‘HE Receive attempts will continue to succeed as long as there are itemsÁü¦’:7 stored inside the channel. Further attempts will fail.Á,ì’ú úŠæÛÑ´ ò’´
¿›Ø¡ØÀæ$ó’üµ“|šÁ¥ÂÃÁÂþðD§”š“ Ï“–ð Ò“ö‚DÅ“¯ðŒŸ”·ÑLº“ŠæÄÅìíÅÄ!PRTVü¸” „”ûüýþ ûŠæ üš— ýÌÌkλ¸ÏÚ—¸Ðó—¸Ñ„˜¸Ò™˜¸f'EwÚ]¾åþÆ™À Ü”À
ěءØÀæ$Ý”»L딊š¤•ü»—d”¾—ÿ ÿŠæ š—À Ú—À
śءØÀæ$Û—»Lé—ü㘚ǥÈÉÈÇɾðDØ™š“ ý˜–ð €™ö‚Dó˜
èêëé’P”7áêëéç±P7äêëéçÃW4§¹ÔàÙWDò¼ÖàÊ<‡Â ØàX„éÄÚà¡X”°ÆÜàÃX”¦È Þàë›Î
êëéó‘õ:êëé䜑ý:üêëé如Á:Ì
êëéë¾–f9ÇêëéþÛ—m9Úêëé÷Ô˜t9æêëéø‹™{9ëêëéƒùÊ”i9©êëé̼•p9·êëéÍ,¸Á´ÎÁÂô÷ãæü¢Ã1Ì©Ãêšó¥ôõõôó·ÑLÃÚ“ ÎÖð ÑÃö‚Dù«<’įðŒªÄ¾ðD²Äìç(×uJó¾¼ö÷øY[]_ac¤©Å<©Åêòò§¦´£ÆL£Æêòò§¦üöÆ(<öÆêòòŠæü·È¹šú¥ûüúûü¾ðDæÉš“ ÇÈ–ð ÊÈö‚DÅɯðŒÞÉ·ÑL¼Èìçýþðñþý!PRTVü‡Êºœ‘ÊŒŽ ìç ŒÕ ÌÌkλ¸ÏÚ—¸Ðó—¸Ñ„˜¸Ò™˜¸f'EwÚ]¾åŽ«Ÿù ¶Êù
ý›Ø¡ØÀæ$·Ê»LÍÊŠš‹ËüŸÌ|¬¢Ì ìç Õù ÉÌù
þ›Ø¡ØÀæ$ÊÌ»LàÌüÏš¥¾ðD­Ðš“ ‘Ï–ð ”Ïö‚DŒÐ¯ðŒ¥Ð·ÑL†Ïìçƒìíƒ!PRTVüÎÐÀ„ØÐ ìç š— ÌÌkλ¸ÏÚ—¸Ðó—¸Ñ„˜¸Ò™˜¸f'EwÚ]¾åÆ™ÿ úÐÿ
ƒ›Ø¡ØÀæ$ûлL‘ÑŠšÒÑüéÒ|”ìÒ ìç š—ÿ Óÿ
›Ø¡ØÀæ$‘Ó»L§ÓüêÖ)üÄÔFì®ì“Õ»¯¹ÕúüÅÕ7î¯ü…Ö\Y The returned Future will get resolved when the value has been stored inside the channel.ÁlõÖš¥ˆˆ·ÑLƒ×š“ Ž×–ð ‘×ö‚D¹×¯ðŒÒ×¾ðDÚׂ«<ôרèƒH&Ôï–¢XZ\^`bü“ØC,“Øê†J†JK‰Jµ 7ŠJ†Ò7‹J¤7·0ØQdèìçö¾ü›Û+üëØH¡²ì¼Ù»¯âÙúüîÙKŒ³üÂÚPá³|¦Ûš¥ŒŒ·ÑL¶Ûš“ ÁÛ–ð ÄÛö‚DìÛ¯ðŒ…ܾðDÜ‚«<§Ü™é%tÜ›ÏÕxgެXZ\^`büÆÜC,ÆÜꊊâÓüžÝšš¥¾ðD®Þš“ ®Ý–ð ±Ýö‚DÞ¯ðŒ¦Þ·ÑL£ÝØèÀcEGIKüÏÞ@ÒÞ˜ Øè ˜ c cˆ¢cµ
 `£cÜ­ `àB¤GS
ƒ¯ ÖÞ
›Ø¡ØÀæ$×Þ± ÝÞüåßœš¥¾ðD÷àš“ õß–ð øßö‚DÖà¯ðŒïà·ÑLêß™é˜Àc˜EGIKü˜á@›ášœ š™é  c cˆ¢cµ
 `£cÜ­ `àB¤GS
œƒ¯ Ÿá
˜›Ø¡ØÀæ$ á± ¦áü°âšš¥œšœ¾ðDµãš“ Àâ–ð Ãâö‚D”ã¯ðŒ­ã·ÑLµâØèÙEGIK¼Öã,Ùã ØèØè ßã
›Ø¡ØÀæ$àãüßæŽšŸ¥ ¡Ÿ¡ ¾ðDãçš“ ïæ–ð òæö‚DÂç¯ðŒÛç·ÑL俨è¢"¢EGIK”„è$‡èž žØèž Œèž
¢›Ø¡ØÀæ$‘èü¸ë𤥥¦¦¤¥¾ðD¿ìš“ Èë–ð Ëëö‚Džì¯ðŒ·ì·ÑL½ë™é§Ù§EGIK¼àì,ãìŸ Ÿ™é™é£ éì£
§›Ø¡ØÀæ$êìüíïš©¥ª«©ª«¾ðDóðš“ ýï–ð €ðö‚DÒð¯ðŒëð·ÑLòï™é¬"¬EGIK””ñ$—ñ   ™é¨ œñ¨
¬›Ø¡ØÀæ$¡ñüÅúžü¡öRO Creates a new Channel which can be used to exchange values of type `T` betweenÁüüöEB concurrent tasks. The ends of the Channel are represented throughÁüÊ÷%’¿üø÷IF Both the Sender and Receiver can be cloned in order to let more tasksÁôÊø interact with the Channel.ÁñøúüýøJG As soon es either all Senders or all Receivers are closed, the ChannelÁÔÐù›Àóùúüÿù=: The channel can buffer up to `capacity` items internally.Á|ÌúØè™é𮥝°°¯®·ÑLÜúš“ çú–ð êúö‚D£ü¯ðŒ¼ü¾ðDÄüòÔ$Þü
­›Ø¡ØÀæ¾DúúUWY[]_ü°€š²¥³´²³´¾ðD¿š“ À€–ð ÀŽÃö‚D”Àæ¯ðŒ··ÑLµ€Øèµ·XZ\^üøƒ?üàK±ü„¸‚…ýüÕ‚IŸýü«ƒ@òý$ÿƒ¡ ¡Øè¡ØÛر „„±
µ›Ø¡ØÀæ$…„»,‹„ü‡Œ?ü»†.ýÿö†úü†‡DÀüׇJü®ˆHçüƒ‰Kº‚üÛ‰Gƒü¯ŠIâƒü…‹H¶„üÚ‹ ‰…DŽŒ¢ ¢Øè¡ØÛ†± —Œ±
›Ø¡ØÀæ$˜Œ»,žŒüœ"¼—œü»/, All pending future send attempts will fail.Áü÷HþŽüÌŽC@ stored inside the channel. Further attempts will return `None`.Á,££ £ØèÛѱ ©±
·›Ø¡ØÀæüš¹¥º»º»¹¾ðDž‘š“ –ð  ŽÃö‚Õë<Œ‘¯ðŒ–‘·ÑL’™é¼½¾¿XZ\^üì’;ü¿‘PóÄüœ’CÍÅ<ó’¤ ¤™éØ×¸ û’¸
¼›Ø¡ØÀæ$ü’üî•7ü©•85 Attempt to receive form the channel without waiting.Á\õ•¥ ¥™é†‹¸ ¸
½›Ø¡ØÀæ$‚–üù˜"¼ô–œü˜—/ýîüÔ—HþŽü©˜CÆï,€™¦ ¦™éÛѸ †™¸
¾›Ø¡ØÀæ$‡™üΛ9üä™@œ‹±šúüÁš@ô‹üŽ›3¿Œ\Õ›™é†ê¸¸
¿›Ø¡ØÀæ$á›üŸ¢ŽšÁ¥ÂÃÁÂþðD££š“ ¯¢–ð ²¢ö‚Dø¢Õë<‘£¯ðŒ›£·ÑL¤¢†êÄ FHJLüÄ¥"¼Ä£œüè£3ÀŽü¨¤HþŽüý¤:Ñ,Ë¥§ §†êÛÑÀ Ñ¥À
ěءØÀæ$Ò¥ü°¦šÆ¥ÇÈÈÇÆ¾ðD¿§š“ À¦–ð æö‚D”§Õë<­§¯ðŒ·§·ÑLµ¦†êÉ
ô§Æü×ÅCª’ ä+¥ÝÝ‚ª ÃÆ×” 
üŸÈeü£Ç%" Creates a new unbuffered channel.ÁÕÇúüåÇ-* Refer to [`generic_channel`] for details.Á€,ʘ ¥ßß‚ª ¹È½Õ$ÿÈ
Þ¥¹dÕÊt‘Ë
""44FF
XXnn
»¤Œã
ÌÝ
Àë
ü‹
I
F Channel implementations where Sender and Receiver sides are cloneableÁ
and owned.Áüì
L
I The Futures produced by channels in this module don't require a lifetimeÁ
parameter.Á
ª,ªöÑîÞ,¯ôÕîˆ.¾î éîþ.‘ûöîü›/”ûøîüº/—û úîü†5ÈÔïÃ5鯨ï“7 ðï“8ý8ÿïƒá8 ïƒôìý»ìš È2Õì¿RQ'íôRè%Ší‰Uï ­íÃWÀ/ÔíàÙWÂ/ÖíàÊÄ/ ØíàXÆ/Úíà¡XÈ/ÜíàÃXÊ/ ÞíàãœÈ
¨íç:#†Œð¨C¦ðÚCX~ªð¼E
w ÆðÂF‰‹ÔðÚÝF‹‹ÖðÚúF ØðÚüñ $
Ôª
ìÙ
ü‹
'
üÇ
%

d‡KüKH Asynchronous synchronization primitives based on intrusive collections.ÁLúüPJG This module provides various primitives for synchronizing concurrentlyÁ´› executing futures.Á$KóÓ é
å[¼ôÌ Œ]Ì© Í ã^¬¨ Î €_¼Ãà Ï ´_„›Ç Ñ Ê Ì_”­È Ò Ê ºfdêµ
ß
ñbŒøý à
»d´‹
á
êgT£Ë
â
„h|³Í
ã
«h¤ÄÐ
ä
¤Õ
æ
Ý
¥T“×
ç
Ý
Œi|ŸÚ
è
Ý
°o„á·  Æmìó  ÁlÄ’  Ãpt°È ˜ ÿpÜÀË  Ùp´ÝÉ š ×t´²ù œ  £süÊ#å   ¦rôóØ ž  ·qLÎÏ   Ô éq´ÙÒ ¡ Ô ÈqŒñÐ ¢ Ô ‹v|„  £   Ávä™  ¤   ¢v¼·  ¥   ´³”·ò† ‹ – ©  à Š´ó‘Twóöœ‘üó÷Š‚„™ Ê
󸦂Ì
óù¤ŠË„¾óú¼ŠóýÛŠ‚Øóþk<’Ìó·$›œØó ¢‹ãó¤"óÝ€ó´_„PÇ Ê Ì_”¡QÈ Ê ,KüK)/2 #¼’òdÔÔÔåçÔÖüÔ;Èʸ£¥D°†¬ëóÀZÿóˆ ºó öu„““ öu„““‡ ˆ œ³óß„êóöêœÿ¨­ Š Ô¾Áó¨­ 
Š ŒúT ó óZŒ …[ó †(óÜÁÿŠ|ÜÁÿŠ|Œ d’ 4 ó  ü¤ #ó ó‘oˆ™’o5Cñ­<ûÒƒ¨­ |Ì ”¯ “ ” • üâ "å ó”¯ Ž Ž
…[4é œí

ó¬ ¬”¯ Ž  ö
Ž

Œ« ® ó­ ­”¯ Ž  ² Ž
 ÒÚëÚ‰Û  üüœ‘þ´‘oÿó oÈ‘oÔ‘o4‹LÌgsɨ­ Ä4„ó® ®”¯ Ž  Ž
üžˆó¯°±² ¯”¯  °˳  ±ÌÌkλ¸ÏÚ—¸Ðó—¸Ñ„˜¸Ò™˜¸f'EwÚ]¾å²È™Ž  ºŽ
$¿»Ššÿü» Eó³´ ³”¯  ´˳ Ž  Ì Ž
»L× üº(7üÙ&NK A synchronization primitive which can be either in the set or reset state.Á¨'úü¬'MJ Tasks can wait for the event to get set by obtaining a Future via `wait`.Áüú'?< This Future will get fulfilled when the event has been set.Á¼Å(š·ÑLÝ(ö‚Dè(×닆æcZü0˜ &(üø(#,ø(ó  ""¤%@ &È‘ 5á»I'yÆD›Ø”¯ üê)Wšš š ·ÑLö)ö‚D*™…$Œ*×ëü+Wšœ œ ·ÑL›+ö‚D¦+âÔ$±+×ëüì+Ušž ž ·ÑLñ+ö‚Dü+×ëŸ ÀcŸ üÈ,@Ë,µ· µ×ë  c cˆ¢cµ
 `£cÜ­ `àB¤GS
·ƒ¯  Ï,
Ÿ ›Ø$Ð,± Ö,üÈ-<š¡ ¡ ·ÑLÍ-ö‚DØ-×ë¢ £ ¤ ¥ ¦ § ¨ %'üÅ.>ü‹.52 Creates a new ManualResetEvent in the given stateÁÌ.×ë   
¢ ›Ø…[4Ð.Œé0œŽ0 Sets the event.Á¦0úü®063 Setting the event will notify all pending waiters.Áð0¸ ¸×ë   ô0 
£ ›Ø$õ0œÂ1¬¨1 Resets the event.Á,É1¹ ¹×ë   Ï1 
¤ ›Ø$Ð1ä®2ü…2$! Returns whether the event is setÁ4µ2º º×ë   ¼2 
¥ ›Ø$½2ü¿3:üû2?< Returns a future that gets fulfilled when the event is set.Á$Æ3» »×ë© © Œ]¬ ½]ó­ »óßÉRfû'Í£»›Ø   Ë3 
¦ ›Ø$Ì3ü‘5„D›5ó¼½¾¿ ¼×ë ½˳  ¾ÌÌkλ¸ÏÚ—¸Ðó—¸Ñ„˜¸Ò™˜¸f'EwÚ]¾å¿È™   ­5 
§ ›Ø$®5»L¼5Ššî5üÕ6AlØ6óÀÁ À×ë Á˳    æ6 
¨ ›Ø$ç6»Lí6üÙ8=üÕ7RO A Future that is resolved once the corresponding ManualResetEvent has been setÁ.ü¨80…£Ìä8ª š« ª « å¤L‚9›œD9“Öüê95§ìßÉRfû'Í£¬ ­ Á þ8AC7,ê9ó© © Û¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙ å[˜ ˜)󋆿cZü0“ÖüË:#LË:ó© © ˳ ü¡<a¯ š° ° ¯ å¤L±<›œD¼<ƒ¨$Ç<§ì­< üˆ=_² š³ ³ ² å¤L‘=›œDœ=§ì´ Àc´ =!#üî=@ñ=ÂÃÄ Â§ì àc cˆ¢cµ
 `£cÜ­ `àB¤GS
ă¯±  õ=±
´ “Ö$ö=± ü=ü÷>Uš· · å¤L€?›œD‹?§ì¸ ¹ ƒØ„ع ü>*,\Ó?4Ø?µ µ üê??$í?ÅÆÇ„¾„¾¤Š†¾ ˜X$]È=„kt• Å§ì ÆÌÌkλ¸ÏÚ—¸Ðó—¸Ñ„˜¸Ò™˜¸f'EwÚ]¾åÇÈ™µ  ü?µ
¹ “Ö$ò?Ššˆ@üšGZ» š¼ ¼ » å¤L£G›œD®G§ì½ ½ ŸG "üûGlþGÈ È§ìº  ŒHº
½ “Ö$HüÃHS¿ šÀ ¿ À å¤LÌH›œD×H§ìÁ "Á ÈH!#I$ IÉ É§ì¾  ¥I¾
Á “Ö$ªIôáLü¥L;8 A [`GenericManualResetEvent`] which is not thread-safe.Á¬êL å[˜ ˜)󋆿cZü0æ¸üèM$ü¥MB? A [`GenericWaitForEventFuture`] for [`LocalManualResetEvent`].Á¼ñMÄ Ä © © Œ]¬ ½]ó­ »óßÉRfû'ͣ渉NTÑN»À|¿N¼¹N4ÕNóÇ È Š‚ Ê
Å Æ ø¤Šj„¾Å Æ ú¼ŠmÅ Æ ýÛŠp‚ØÅ Æ þksÌÅ Æ ·vœØÅ Æ ¢‹yãÅ Æ ¤|"Å Æ Ý€Å Æ ÀZÅ Æ óZ0Å Æ å[Ì Å Æ Œ]>© Å Æ ã^H Å Æ €_Íà Å Æ ð*eÅ Å Æ Í´Å Æ ó‘,Å Æ öœ‘0üÅ Æ ÷¦‚Ì
Å Æ ù,æN̆Pü¶OKH A [`GenericManualResetEvent`] implementation backed by [`parking_lot`].ÁÌ å[˜ ˜)󋆿cZü0óžü˜QüÖP=: A [`GenericWaitForEventFuture`] for [`ManualResetEvent`].ÁCÉ É © © Œ]¬ ½]ó­ »óßÉRfû'Í£óž´QdRÄÔEH9<-0!$Ä€  òë ð ý –
µ
Ë
Í
Ð
Ó
¾ó‘T—Ó Ö œ‘üÓ × Š‚„¹ Ê
Ó Ø ¦‚Ì
Ó Ù 
UnsafeCellÁTòî0Ó Û r,ˆé!Ó Ý äÒDö!Ó Þ ¤Š£„¾Ó ß ¼ŠÓ â ÛŠ‚ØÓ ã k<íÌÓ å ·œØÓ æ ¢‹ãÓ ç LockApiMutexÁdŸ"Ó é Ý€D­Ó ê ¤,ÄŠÕ
Ý
¥T³‹×
Ý
Œi|ÁŒÚ
Ý
,kük)šŠ¼²~kn„ìWüà%KN;>/Ô¯#&ü¯;

úüçéD‹,–ѾÀ¬ÜÓ ë ë ÀZì ÿÓ í ºÓ `eÖ”†>ä`eÖ”†>äì í œ¤Ó ë ë ß„ÛÓ ë ë ŸíœðËâ ï Ô¯ ² Ó Ëâ î î
ï ŒÕ

Ó ð ð Àañ ÒaÓ ò áaÓ ó †(Ó gæídàDgæídàDñ ò ó lí

Ó ð ð |€ L€ Ó ð ð ü• #<• Ó ð ð ó‘oˆ™’o5Cñ­<ûÒƒËâ |½ ·ä õ ö ÷ ø ù ú û ü ìÓ Ö Ó ·ä ô ô
õ Òa<Ú ü§1”ªÓ Ê Ê·ä ßô  ½ô
ö ÜÃÓ Ë Ë·ä ô  Ðô
÷ üò%Ó Ì Ì·ä ßô  üô
ø $üò#Ó Í Í·ä ô  ƒô
ù üêˆÓ ÎÏÐÑ Î·ä  Ïüüœ‘þ´‘oÿó oÈ‘oÔ‘o4‹LÌgsÉËâ  ÐÌÌkλ¸ÏÚ—¸Ðó—¸Ñ„˜¸Ò™˜¸f'EwÚ]¾åÑÈ™ô  ô
ú $‹ »L™ ŠšË üî>iœø>Ó ÒÓ Ò·ä  Ó±ê ô  •?ô
û $š?»L¨?üóDmlöDÓ ÔÕ Ô·ä  Õ±ê ßô  Eô
ü $E»L EüâQ<üÉP@= An RAII guard returned by the `lock` and `try_lock` methods.ÁüŠQIF When this structure is dropped (falls out of scope), the lock will beÁlÔQ
unlocked.ÁŒíQþ šÿ ¥
þ
ÿ å¤LƒRö¤ ˜R›œDŽR‡¥›RÛÉ üÛR%‡¥ ý ý ñb
›`Ó ¦*>öê©“Ö™Ö¦*>öê©
ÿQˆþ ƒ,ÛRÓ ý ý µ
µ
ºf¸
»Ó ¹
ºÓ ÉCi˜~¥–›“Ö™Öü…Sk8Öšƒ
¥
Öƒ

å¤LŠSö¤ ŸS›œD•S¿c™Ö„¢Sî
Àc
358:ü÷S@úS×ØÙ ×î Ø c cˆ¢cµ
 `£cÜ­ `àB¤GS
Ùƒ¯
 þS
8“Ö™Ö$ÿS± …TüøTI8Úš
¥ˆ
Ú
ˆ