aamos-ledger-rust/target/debug/deps/libslab-35aba13cdef5bade.rmeta

rust
á2#rustc 1.96.0 (ac68faa20 2026-05-25)ÁíàÄTËŸ ÜJîÄ)'ß\¥!-3d1337db07d0b3aeÁÀë‰Š]!ÜÛê(¹Þ—šên-5be7b69c3ff7b5b8Á¤²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Ór2Ù $¨ûib‚-cf21ca6f2bb15dcdÁë
‹ás«LÖ€îâƒ×É¯Œ-ee6f3747e38367f0Á¤,¸!»À|˜!Œ—!serdeÁ,»"»àŒ£"íÀ¤builderÁBuilderÁ	¥	slabÁ	vacant_list_brokenÁ	first_vacant_indexÁ¥
with_capacityÁpairÁbuildÁ	

SlabÁ ¥ entriesÁ ‘ ó	%¥%ƒ%†)¥)>,×IntoIterÁ/¥/�
/‘IterÁ3'aÁ3¥3�
3‘8¥8ƒIterMutÁ;…;¥;�
;‘DrainÁ@…@¥@innerÁ@‘E¥Eæ	E�	EcapacityÁEreserveÁE
reserve_exactÁE
shrink_to_fitÁErecreate_vacant_listÁEcompactÁN—NCleanupGuardÁP…P¥PÈP	decrementÁNU¥UãEclearÁE‘Eis_emptyÁEùEúEgetÁEget_mutÁEget2_mutÁEget_disjoint_mutÁ`Ÿ```E
get_uncheckedÁEget_unchecked_mutÁEget2_unchecked_mutÁEkey_ofÁEinsertÁE
vacant_keyÁEvacant_entryÁE	insert_atÁE
try_removeÁEremoveÁEcontainsÁEretainÁp—EdrainÁs¥s°sÖw¥w×z¥z›zÖ
zê	…¥›Ö
ê
………¥…›…Ö
…ê‹¥‹ù�š�¥�×
’¥’×•¥•×˜¥˜×›¥›×ž…ž¥ž·žkeyÁ£¥£›£ó	£	size_hintÁ¨¥¨	next_backÁ«¥«‘®¥°…°¥°›°ó	°§¶¥¶Ä¹¥¹‘¼¥¾…¾¥¾›¾ó	¾§Ä¥ÄÄÇ¥Ç‘Ê¥Ì¥Ì›Ìó	Ì§Ñ¥ÑÄ Ô¥Ô‘!×¥GetDisjointMutErrorÁÙIndexVacantÁÚ
ÙIndexOutOfBoundsÁÜ
ÙOverlappingIndicesÁÞ
"à×#âƒ$%å�&çÖVacantEntryÁé…é¥éÈé€'î…î¥î×EntryÁò¥òVacantÁô
ôˆòOccupiedÁ÷
÷ˆ(ú¥úƒ
'
(
(
-
-
-
8
:
I
J
K
L
M
N
N
U
W
X
Y
Z
[
\
]
^
_
`
e
f
g
h
h
i
j
k
l
m
n
o
p
p
r
v
y
‘
‘
‘
”
”
”
•
—
—
—
˜
š
š
š
›
�
�
�
¢
¦
§
ª

´
µ
¶
¸
¹
»
¼
Â
Ã
Ä
Æ
Ç
É
Ê
Ì
Ï
Ð
Ñ
Ó
Ô
Ö
×
á
á
á
ã
æ
æ
è
ñ
ñ
ñ
ü
Ø  ï	"�
#‘$ó	ÕêüTí¼¥³¥¿cÙÚÛ§ÜÝ¿ÞßÜ[áÁÉÀa_ØúÐìúµßúú™úÄcú¾ú¿céé®ìÈí€€ðä?Ûo ß…¥Ø33ú
6�
7‘l1]j"C68ÆØòôõ‘öˆ÷ø¬ùˆH@Ú¹º~ãŒ"PPš
SÈTÂ
~Å}´áBU¸8ÆÙ¢¥³"¥³!ÇL¥ÇL…  ï	"�
#‘$ó	ÕêüTí¼ÆÇL…Ú!ÃL¥³!ã¿c¥¿c//Ö
1�
2‘)l‚ö&cƒã¿cÓ¿c;;µ>�
?‘JŠ¡ðC1¦ð8Æ¿c@@ßCùD‘ß¢Ú£X8ÆùMÏ"ŒMÏ"ÃMÏ"òPÏ"ùM33ú
6�
7‘l1]j"C6…ÆŒMÓÃMÓòPÓùM;;µ>�
?‘JŠ¡ðC1¦ð…ÆŒM—#ÃM—#òP—#ùMÚ#ŒMÚ#ÃMÚ#òPÚ#% âÙ83úò) àÙîé� ’/•3˜;›@äÙåÙçÙ,Ù.ÙUPs w z 
…
‹ £/°3¾;Ì@¨/¶3Ä;Ñ@«/¹3Ç;Ô@®/¼3Ê;×@Øí³¿cÐì,µß™Äc¾Œ"Ù¢³"ÇLÃLùMŒMÃMòPTÒ?
DÒ?
±B– +ü¶?Z	 ã„@³!ð?³!�@–@Gü‘?…¥$§?ªBªBöBbufÁ÷<®B‘÷<9)
-ÜnL– çEçEèEGlobalÁ¿±‡§í#‰4”<	òãõ(– 3³!:AD§<	òãø(– 3ã:A /3;@òÙéíÀä!¤,•"Á$â"÷<öè"ªBù$ÿ"Œ5‹d…#ÃL
FusedIteratorÁl“#òPMaybeUninitÁ\²#ÑÛ×Ê# `íÏ#ë
Ô#Â ž,Ù#‰fü¥ûüÚ2/ Pre-allocated storage for a uniform data type.Á�úü‘PM `Slab` provides pre-allocated storage for a single data type. If many valuesÁüâEB of a single type are being allocated, it can be more efficient toÁü¨NK pre-allocate the necessary storage. Since the size of the type is uniform,Áü÷FC memory fragmentation can be avoided. Storing, clearing, and lookupÁü¾! operations become very cheap.ÁàúüäOL While `Slab` may look like other Rust collections, it is not intended to beÁü´OL used as a general purpose collection. The primary difference between `Slab`Áü„DA and `Vec` is that `Slab` returns the key when storing the value.ÁÉúüÍKH It is important to note that keys may be reused. In other words, once aÁü™MJ value associated with a given key is removed from a slab, that key may beÁüç+( returned from future calls to `insert`.Á“	ú¼—	 # Performance notesÁ¯	úü³	LI Methods that remove values and return them, such as [`Slab::remove`] andÁü€
LI [`Slab::try_remove`], might copy the removed values to the stack even ifÁüÍ
LI their return values are unused. For types that don't have drop glue, theÁüš,) compiler can usually elide these copies.ÁÇútË # ExamplesÁÚúüÞ  Basic storing and retrieval.Áÿú<ƒ ```Á”‹ # use slab::*;Áüž let mut slab = Slab::new();Á¾úüÂ%" let hello = slab.insert("hello");Áüè%" let world = slab.insert("world");ÁŽ
úü’
%" assert_eq!(slab[hello], "hello");Áü¸
%" assert_eq!(slab[world], "world");ÁÞ
úÔâ
 slab[world] = "earth";Áüý
%" assert_eq!(slab[world], "earth");Á<£é8«úü¯OL Sometimes it is useful to be able to associate the key with the value beingÁüÿOL inserted in the slab. This can be done with the `vacant_entry` API as such:ÁÏú<Óé8”Ûù8üî•9ŽúŒ’ let hello = {Áü¤(%     let entry = slab.vacant_entry();ÁôÍ     let key = entry.key();Áìúüð%"     entry.insert((key, "hello"));Á\–     keyÁ4¢ };Á©úü%" assert_eq!(hello, slab[hello].0);ÁüÓ'$ assert_eq!("hello", slab[hello].1);Á<ûé8ƒúü‡LI It is generally a good idea to specify the desired capacity of a slab atÁüÔHE creation time. Note that `Slab` will grow the internal capacity whenÁü�QN attempting to insert a new value once the existing capacity has been reached.Áüï To avoid this, add a check.Á�ú<“é8”›ù8ü®-* let mut slab = Slab::with_capacity(1024);ÁÜú¼à // ... use the slabÁøúüü&# if slab.len() == slab.capacity() {Áä£     panic!("slab full");Á,À }ÁÆúüÊ30 slab.insert("the slab is not at capacity yet");Á<þé8†úüŠ # Capacity and reallocationÁªúü®JG The capacity of a slab is the amount of space allocated for any futureÁüùMJ values that will be inserted in the slab. This is not to be confused withÁüÇIF the *length* of the slab, which specifies the number of actual valuesÁü‘NK currently being inserted. If a slab's length is equal to its capacity, theÁüàFC next value inserted into the slab will require growing the slab byÁŒ§ reallocating.Á¹úü½LI For example, a slab with capacity 10 and length 0 would be an empty slabÁüŠOL with space for 10 more stored values. Storing 10 or fewer elements into theÁüÚNK slab will not change its capacity or cause reallocation to occur. However,Áü©LI if the slab length is increased to 11 (due to another `insert`), it willÁüöPM have to reallocate, which can be slow. For this reason, it is recommended toÁüÇPM use [`Slab::with_capacity`] whenever possible to specify how many values theÁô˜ slab is expected to store.Á·ú¤» # ImplementationÁÐúüÔIF `Slab` is backed by a `Vec` of slots. Each slot is either occupied orÁüžLI vacant. `Slab` maintains a stack of vacant slots using a linked list. ToÁüëKH find a vacant slot, the stack is popped. When a slot is released, it isÁÔ· pushed onto the stack.ÁÒúüÖPM If there are no more available slots in the stack, then `Vec::reserve(1)` isÁü§ %" called and a new slot is created.ÁÍ úüÑ ;8 [`Slab::with_capacity`]: struct.Slab.html#with_capacityÁü¡ üÃ"|‡ /3;@òÙéí±À²¤±Á°÷<ö¯ªBù®Œ5‹ÃL½,ŸòPÝ,“ÑÛ×’ `í‘ë
�Â ž�‰f–™œ„×!“Ì�"ˆ\Ã"<Ç"	ü,òï	$ ,#%äE<W¥

Íìã_		³ÈÓ
ìS‘ÑÊí£,åãS‘ÑÊí£,å
[]lh$h		¥Ä{”{		ü™!”™		Û¼Ý¼Þ¼©ß¼à¼Ûá¼ˆcSñŸ«‡zÙ³!”¿¥ÈVÄÖV
üØ4læ³!ÖV
ã¥Dôü°3$¾ýýÖV³!ãÃ
ã$È€Î»,Úü—$,¥ÖV¥
ã$«TÕ"óÜ"Tò"$ø",,LL´§#j$Ã#~~‘‘…ˆx{”ø$üâ#1. Pre-allocated storage for a uniform data typeÁ”$úü˜$41 See the [module documentation] for more details.ÁÍ$úüÑ$&# [module documentation]: index.htmlÁ$ƒ%¥!!ÈVˆ%¥ÕêüTí¼"#$ ´¨%<¨%  “*Tü%ü%  ³!\ü&$ü&  ³!üŒ'-¥&&ÈV‘'Øã,³'¥'(ÙÚ'((*¼À',Ã'þþ¥¥%É'%
'ã$Ê'üá('Tä(ÿ€ÿ¥€¥õY%ï(%
(ã$ô(sourceÁ4ú(Ü†*¥**ÈV‹*¥+´+¤¨*<«*¥))
+ãüÅ-)ú-Åc-üõ-8ø-�‚ƒ�ú‚ c cˆ¢cµ
 `£c¦) `àB¤GS
ƒÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
õYŸÈŸÈ ÈErrorÁO˜éBL,ü-,
-$ý-±ƒ.üŽ1.»À|ü0¼ö0ú´°6üô5;8 A consuming iterator over the values stored in a `Slab`ÁD»6¥00ÈVÄ6Ï")l‚ö&cƒ12üÍ61<Í6//™™	EnumerateÁ›ù‚9œü‚9¿Ê-hðär�ˆ?ˆ?Ö
‹?¦)÷<Œ?phantomÁ÷<�?capÁ÷<Ž?¤÷<�?µ÷<�?þ÷<µqS·l·– Ó*T„7„7//³!´È7ü“741 An iterator over the values stored in the `Slab`Á$Ó7…4¥554ÍìÆÜ7Æ…§eÅ$l1]j"C667Ø724üå73<å733™™¹d›ù‚9œü‚9¿Ê-hðär�ÄlÄlú
Çlµ™lÈl
end_or_lenÁ™lÉl_markerÁ™lŒœjSž…òôõ‘öˆ÷ø¬ùˆH@Ú¹º~ÆTž8ž833³!ì88„¥99„ñg²8Ó:Ù:¼Ñ8,Ô8……ÓÓ8Ú88
:8Æ$Û8Ì�:üÓ9;8 A mutable iterator over the values stored in the `Slab`Á<š:…<¥==<ñg¦:�hÚ,e§%JŠ¡ðC1¦ð>?¢:+-ü¯:6<¯:;;™™¹d›ù‚9œü‚9¿Ê-hðär�ÜlÜlµßlµ™làl¯h™lálÅh™lÚ½íDþïl%…íiTë:ë:;;³!¼�;üú:" A draining iterator for `Slab`Á,¨;…A¥BABñg²;�hž@@ßCùD‘ß¢Ú£X…Æß¢Ú£XCD®;egü»;,»;@@ˆ>ˆ>ßŒ>
tail_startÁ÷<�>tail_lenÁ÷<Ž>ù÷<�>Á÷<…üò)«§…íiÓ*Tà;à;@@³!|·<¥FFÈV¼<¥GHIJKLMNXYZ[\]^_`efghijklmnoprCEÔ‘?üÍ<" Construct a new, empty `Slab`.Áô<úüü<EB The function does not allocate and the returned slab will have noÁüÆ=IF capacity until `insert` is called or capacity is explicitly reserved.Á”>útœ>�8¯>ú<·>é8”Ã>ù8üÚ>&# let slab: Slab<i32> = Slab::new();Á<…?é8ž?¥EE
GãüëG0üœ@>; Construct a new, empty `Slab` with the specified capacity.Áß@úüç@FC The returned slab will be able to store exactly `capacity` withoutÁü²AA> reallocating. If `capacity` is 0, the slab will not allocate.ÁøAúü€BLI It is important to note that this function does not specify the *length*ÁüÑBJG of the returned slab, but only the capacity. For an explanation of theÁü C=: difference between length and capacity, see [Capacity andÁüâC85 reallocation](index.html#capacity-and-reallocation).ÁŸDút§D�8ºDú<ÂDé8”ÎDù8üåD+( let mut slab = Slab::with_capacity(10);Á•Eúü�EHE // The slab contains no values, even though it has capacity for moreÁôêE assert_eq!(slab.len(), 0);Á�Fúü•F1. // These are all done without reallocating...Á¤ËF for i in 0..10 {Á¼äF     slab.insert(i);Á,€GßDŠGúü’G/, // ...but this may make the slab reallocateÁ¤ÆG slab.insert(11);Á<ßGé8lòG³!¥EE
Hã¥D€Hü�KüžIHE Return the number of values the slab can store without reallocating.ÁëIútóI�8†Jú<ŽJé8”šJù8ü±J2/ let slab: Slab<i32> = Slab::with_capacity(10);ÁüèJ$! assert_eq!(slab.capacity(), 10);Á<‘Ké8D¤K††¥³!EKE
Iã$®KüÄS,üêKGD Reserve capacity for at least `additional` more values to be storedÁ¼¶L without allocating.ÁÒLúüÚLJG `reserve` does nothing if the slab already has sufficient capacity forÁü©MLI `additional` more values. If more capacity is required, a new segment ofÁüúMLI memory will be allocated and all existing values will be copied into it.ÁüËNKH As such, if the slab is already very large, a call to `reserve` can endÁ¼›O up being expensive.Á·Oúü¿OGD The slab may reserve more than `additional` extra space in order toÁü‹PJG avoid frequent reallocations. Use `reserve_exact` instead to guaranteeÁüÚP/, that only the requested space is allocated.ÁŽQúd–Q	 # PanicsÁ§Qúü¯Q:7 Panics if the new capacity exceeds `isize::MAX` bytes.ÁîQútöQ�8‰Rú<‘Ré8”�Rù8ü´R•9ÌØR slab.insert("hello");Á¬öR slab.reserve(10);Áü�S#  assert!(slab.capacity() >= 11);Á<¸Sé8<ËS‡‡¥³!õYEÓSE
Jã$ØS
additionalÁTÞSü¦]2ü¿UGD Reserve the minimum capacity required to store exactly `additional`Á„‹V
 more values.Á Vúü¨VLI `reserve_exact` does nothing if the slab already has sufficient capacityÁüùVMJ for `additional` more values. If more capacity is required, a new segmentÁüËWKH of memory will be allocated and all existing values will be copied intoÁü›XLI it.  As such, if the slab is already very large, a call to `reserve` canÁÜìX end up being expensive.ÁŒYúü”YJG Note that the allocator may give the slab more space than it requests.ÁüãYFC Therefore capacity can not be relied upon to be precisely minimal.Áü®Z74 Prefer `reserve` if future insertions are expected.ÁêZúdòZó…ƒ[úü‹[:•†Ê[útÒ[�8å[ú<í[é8”ù[ù8ü�\•9Ì´\¡‡ÜÒ\ slab.reserve_exact(10);Áüò\#â‡<š]é8l]ˆˆ¥³!õYE»]E
Kã$À]ãˆTÆ]ü½iü_RO Shrink the capacity of the slab as much as possible without invalidating keys.Á„`úüŒ`HE Because values cannot be moved to a different index, the slab cannotÁüÙ`" shrink past any stored values.Áü€aNK It will drop down as close as possible to the length but the allocator mayÁüÓaSP still inform the underlying vector that there is space for a few more elements.Á«búü³bMJ This function can take O(n) time even when the capacity cannot be reducedÁü…cLI or the allocation is shrunk in place. Repeated calls run in O(1) though.ÁÖcútÞc�8ñcú<ùcé8”…dù8üœd+ºyÌdúœÔd for i in 0..3 {Á¼ìd×{,ˆeßD’eúÌše slab.shrink_to_fit();Áü¸e:7 assert!(slab.capacity() >= 3 && slab.capacity() < 10);Á<÷eé8ƒfúü‹fGD The slab cannot shrink past the last present value even if previousÁ¼×f values are removed:Áófú<ûfé8”‡gù8üžg+ºyÎgúœÖg for i in 0..4 {Á¼îg×{,ŠhßD”húœœh slab.remove(0);Áœ´h slab.remove(3);ÁÌhúÌÔhô–üòh:——<±ié8lÄi‰‰¥õYEÒiE
Lã$×iüÌt"¤ÏtŠŠ¥õYEätE
Mã$étü¥‡düûzZW Reduce the capacity as much as possible, changing the key for elements when necessary.ÁÚ{úüâ{RO To allow updating references to the elements which must be moved to a new key,Áü¹|MJ this function takes a closure which is called before moving each element.Áü‹}JG The second and third parameters to the closure are the current key andÁÌÚ} new key respectively.Áüø}JG In case changing the key for one element turns out not to be possible,ÁüÇ~DA the move can be cancelled by returning `false` from the closure.Áü�DA In that case no further attempts at relocating elements is made.ÁüÙHE If the closure unwinds, the slab will be left in a consistent state,Áü¦€@= but the value that the closure panicked on might be removed.Áë€útó€�8†�ú<Ž�é8”š�ù8±�úü¹�+ºyìé� let a = slab.insert('a');Á¬‹‚ slab.insert('b');Á¬¥‚ slab.insert('c');Áœ¿‚ slab.remove(a);Áü×‚)& slab.compact(|&mut value, from, to| {Áü…ƒ30     assert_eq!((value, from, to), ('c', 2, 0));Ád½ƒ	     trueÁ<Îƒ });ÁüÚƒ:7 assert!(slab.capacity() >= 2 && slab.capacity() < 10);Á<™„é8¥„úü„:7 The value is not moved when the closure returns `Err`:Áì„ú<ô„é8”€…ù8—…úüŸ…,) let mut slab = Slab::with_capacity(100);ÁìÐ…ø¢ìò… let b = slab.insert('b');Áœ”†Ý£ü¬†/, slab.compact(|&mut value, from, to| false);Áüà†41 assert_eq!(slab.iter().next(), Some((b, &'b')));Á<™‡é8<¬‡
6�
7‘l1]j"C6’ãEã§E
[ã$ä§üç®,üð¨85 Return an iterator that allows modifying each value.Á©úüµ©I•¶üƒªDé¶üÌªE¸·ü–«6ˆ¸Ñ«útÙ«�8ì«ú<ô«é8”€¬ù8ü—¬•9»¬úôÃ¬ let key1 = slab.insert(0);Áôæ¬ let key2 = slab.insert(1);Á‰úü‘'$ for (key, val) in slab.iter_mut() {ÁÄ½     if key == key1 {Á´Ú         *val += 2;ÁLõ     }Á,ƒ®ßD�®úô•® assert_eq!(slab[key1], 2);Áô¸® assert_eq!(slab[key2], 1);Á<Û®é8Dî®““¥;;µ>�
?‘JŠ¡ðC1¦ð“ãE÷®E
\ã$ü®ü½³+ü’°B? Return a reference to the value associated with the given key.ÁÙ°úüá°C@ If the given key is not associated with a value, then `None` isÁl©±
 returned.Á»±útÃ±�8Ö±ú<Þ±é8”ê±ù8ü�²•9ü¥²#  let key = slab.insert("hello");ÁÍ²úüÕ².+ assert_eq!(slab.get(key), Some(&"hello"));Áüˆ³$! assert_eq!(slab.get(123), None);Á<±³é8Ä³””¥³!Û¼Ý¼Þ¼©ß¼à¼Ûá¼ˆcSñŸ«‡zÙ”ãEÈ³E
]ã$É³€Ï³üÕ¸7üò´JG Return a mutable reference to the value associated with the given key.ÁÁµúüÉµCÈÃl‘¶•Ä£¶út«¶�8¾¶ú<Æ¶é8”Ò¶ù8üé¶•9ü�·#üÄµ·úü½·*' *slab.get_mut(key).unwrap() = "world";Áì·úüô·#  assert_eq!(slab[key], "world");Áüœ¸(% assert_eq!(slab.get_mut(123), None);Á<É¸é8<Ü¸••¥³!Û¼Ý¼Þ¼©ß¼à¼Ûá¼ˆcSñŸ«‡zÙ•ãEä¸E
^ã$é¸€ï¸ü™ÁPü§ºGD Return two mutable references to the values associated with the twoÁôóº given keys simultaneously.Á–»úüž»LI If any one of the given keys is not associated with a value, then `None`Á„ï»
 is returned.Á„¼úüŒ¼LI This function can be used to get two mutable references out of one slab,ÁüÝ¼LI so that you can manipulate both of them at the same time, eg. swap them.Á®½úd¶½ó…Ç½úüÏ½?< This function will panic if `key1` and `key2` are the same.Á“¾út›¾�8®¾ú<¶¾é8”Â¾ù8ŒÙ¾ use std::mem;Áï¾úü÷¾•9ô›¿ let key1 = slab.insert(1);Áô¾¿ let key2 = slab.insert(2);Áüá¿>; let (value1, value2) = slab.get2_mut(key1, key2).unwrap();Áô¤À mem::swap(value1, value2);ÁôÇÀûÀôêÀ£Á<�Áé8D Á––¥³!³!Û¼Ý¼Þ¼©ß¼à¼Ûá¼ˆcSñŸ«‡zÙ–ãœÕE©ÁE
_ã$®Ákey1Á$´Ákey2Á$ÁÁü°È‡ü‚Ç74 Returns mutable references to many indices at once.Á¾ÇúüÆÇEB Returns [`GetDisjointMutError`] if the indices are out of bounds,ÁÜ�È overlapping, or vacant.Á„·È——¥³!ŸÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
—ãŸúEŸaaáÈEŸ³!tÈÈ
`ãŸ$æÈkeysÁ$ôÈ'ÎÈ³!üÉÙ4ü¨ÕIF Return a reference to the value associated with the given key withoutÁüöÕ performing bounds checking.ÁšÖúü¢Ö2/ For a safe alternative see [`get`](Slab::get).ÁÙÖúüáÖ+( This function should be used with care.Á‘×úd™×	 # SafetyÁª×úü²×" The key must be within bounds.ÁÙ×útá×�8ô×ú<ü×é8”ˆØù8üŸØ•9ìÃØ let key = slab.insert(2);ÁåØúdíØ	 unsafe {ÁüþØ0-     assert_eq!(slab.get_unchecked(key), &2);Á,³ÙßD<½Ùé8l×Ù˜˜¥³!˜ãEåÙE
eã$æÙ€ìÙü…à@ü”ÛIF Return a mutable reference to the value associated with the given keyÁüâÛ'$ without performing bounds checking.ÁŽÜúü–Ü:7 For a safe alternative see [`get_mut`](Slab::get_mut).ÁÕÜúüÝÜ+�Ú�Ýúd•ÝÏÚ¦Ýúü®Ý"óÚÕÝútÝÝ�8ðÝú<øÝé8”„Þù8ü›Þ•9ì¿ÞîÛáÞúdéÞ¢ÜüúÞ.+     let val = slab.get_unchecked_mut(key);Á”ß     *val = 13;Á,ÄßßDÎßúôÖß assert_eq!(slab[key], 13);Á<ùßé8Œ“à™™¥³!™ãE¥àE
fã$ªà€°àüèYüäáGªÌü°âKH given keys simultaneously without performing bounds checking and safetyÁ¼€ã 
 `£c¦) `àB¤GS
«ºb�¦Ç�
‘ã$§Ç×ÇüïÉ;¥““ÈVôÉÝ³TŸÊÏ"”Àc”ü±Ê:´Ê¬®¬Ï" c cˆ¢cµ
 `£c¦) `àB¤GS
®ºb’¸Ê’
”ã$¹Ê×¿ÊüÝË;8¯¥–¯–ñgâË¿cÆT�ÌÓ—Àc—#%üŸÌ:¢Ì°±²°Ó± c cˆ¢cµ
 `£c¦) `àB¤GS
²ºb•¦Ì•
—8Æ$§Ì×ÌüÇÍ>8³¥™™³ñgÌÍú·TúÍ—#šÀcšüŒÎ:�Î´µ¶´—#µ c cˆ¢cµ
 `£c¦) `àB¤GS
¶ºb˜“Î˜
š8Æ$”Î×šÎü·Ï#8·¥œ·œñg¼ÏÚ#�Àc�üáÏ:äÏ¸¹º¸Ú#¹ c cˆ¢cµ
 `£c¦) `àB¤GS
ººb›èÏ›
�8Æ$éÏ×ïÏôîÐ…Ÿ¥ Ÿ ñg÷Ðˆ¡¢óÐüÚÕ(ü“ÑLI Insert a value in the entry, returning a mutable reference to the value.ÁäÑúüìÑHE To get the key associated with the value, use `key` prior to callingÁl¹Ò