core/target/debug/deps/libslab-e5be9c6b85739482.rmeta

rust
ê,#rustc 1.93.0 (254b59607 2026-01-19)Á³VOÐêùÿ²?ÑL¼�§Ì±-a7a40eb546f9e2b0Á“õ…·fÊvŠ¦%g--c48c539199cbc88bÁá\ƒ¦è3$|]åŒ[IÚ	tæ-14b12edc9f8cd90bÁë&Gf·Ã ¬ëñq:¤»b-bb76018b1173caf6ÁÃ	9mÙ„«ÐÒþá•c‘B;-030c5b0bba47cc8fÁrustc_std_workspace_coreÁÛ¹þÓ7>H%¸ÚÉ’›-4b81d37a5530864dÁüÃùs<Uß7VyóHr#QÏ-c66cc7807550ce25Áminiz_oxideÁõFÖˆÚ™ª‹"ÞXzLVª-62cbc7af83058505Áadler2Á—wÉD‘åµ¯�|6¨%Œ
+-2f171dd2394b4b62Á	hashbrownÁ,ïcV¼¨ø¢:Ê\'Èßˆ-9571ba9e0f6c7a90Árustc_std_workspace_allocÁ%¥Èxµù·¼5Ä3Bœ-aac566ad65903fa4Á
std_detectÁMmáýZ^9õ	Îà§e˜÷e-2edb296e590136d8Árustc_demangleÁ@¼§VÉNb˜æ¨fHÌ+V3-53b132e4a2fa6e26Ácfg_ifÁfÝv�.Å"ÒÜuPp¹ˆ¶-f76b385d7d4d7f3eÁ	addr2lineÁÕú-WiúQVÓ¬
µT§�5-fe25100bd73e48e4ÁgimliÁ¹xLáÇí÷‘o±Ñ8£Å-265ba9e6e4f70b3fÁobjectÁÔ³ÝzÓÿ¶ò°öM›¼òü`-9ae0d1f8ea52a318ÁmemchrÁRÎ÷×Ž™te~QÓ¿ØC\Ò-0bff3c8e8f4e489eÁ Â–©H�tGNÏ·ˆ!á-d69228d077d46f36Áá,„¶<ä“,î|äŒã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ÁNFÁ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Š		•™½æ
Š	
…•…™…½…æ
…Š	‹™‹ò�IÁ�™�Í
’™’Í•™•Í˜™˜Í›™›Íž•ž™žÈž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
‘
‘
‘
”
”
”
•
—
—
—
˜
š
š
š
›
�
�
�
¢
¦
§
ª

´
µ
¶
¸
¹
»
¼
Â
Ã
Ä
Æ
Ç
É
Ê
Ì
Ï
Ð
Ñ
Ó
Ô
Ö
×
á
á
á
ã
æ
æ
è
ñ
ñ
ñ
ü
Þ  ÿ	"‘
#¾	$¥œ/ÄÜ˜?ƒ@™Ä·à`ÙÚÛ¹ÜÝÑÞßî‹ÌïI@“æ.Þ‹¬â‹ž‹‹£‹å`‹Ï‹à`ééÀìØí’óðØ@æá#·•™Þ33Š6‘
7¾	‚ m×xš$8ÔÞòôõ£öì÷ø¾ùìê+’gÍ=Öô� PP«
SØTÓ
×&¥TI4J_8Ô¦˜·¶ ·¾!®J·®J•  ÿ	"‘
#¾	$¥œ/ÄÜ˜?ƒ@Ô®J•å!ªJ·¾!ôà`·à`//æ
1‘
2¾	#S;’Ý¼ôà`áà`;;Å>‘
?¾	
ºB›_J8Ôà`@@ïC‰D¾	åÞŽæx¶ÄÃ8ÔÞKÙ"òJÙ"©KÙ"ÖNÙ"ÞK33Š6‘
7¾	‚ m×xš$•ÔòJá©KáÖNáÞK;;Å>‘
?¾	
ºB›_J•ÔòJ #©K #ÖN #ÞKâ#òJâ#©Kâ#ÖNâ#% âÙ83úò) àÙîé� ’/•3˜;›@äÙåÙçÙ,Ù.ÙUPs w z 
…
‹ £/°3¾;Ì@¨/¶3Ä;Ñ@«/¹3Ç;Ô@®/¼3Ê;×@ÞíÄà`¬â,ž£å`Ï� ¦˜¶ ®JªJÞKòJ©KÖNTž=
Dž=
æA£ +ü‚=Z
 ôÐ=¾!¼=¾!Û=â=GüÝ<…·$ó<ßAßAâAbufÁ«<ãA¾	«<µ[<™é£ •E•E–EGlobalÁÏ€ûkW¬ s‡4à9
òôõ(£ 3¾!:ADó9
òôø(£ 3ô:A /3;@òÙé³“°á,áœ$® «<´ ßA£	$Ë î2ŸdÑ ªJ£lß ÖNMaybeUninitÁ\þ �ÒÍ–!Á]memÁ›!ÕÞ !Áî,¥!ªcüîö¡y|è8à$}�ç8¬|‡$–8Î$œ å8þ$¡¥À8warningsÁD¦$®8rust_2018_idiomsÁ„°$Á8è,ÃÈä8áLÉ$Ò8unused_variablesÁ„ÔüvtüÚ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`.Á“	Ë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");Á<ïÎ7÷Ëüû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:Á›
Ë<Ÿ
Î7”§
Ý7üº
ø7Ú
ËŒÞ
 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);Á<ÇÎ7ÏËüÓ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.ÁÛË<ßÎ7”çÝ7üú-* 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");Á<ÊÎ7ÒËüÖ # 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;@òÙé³¢“£á¢œ¡«< ßA£	Ÿî2ŸžªJ£�ÖNÑ,‘�ÒÍ�Á]ƒ-ŒÕÞ‹ÁîŠªc‡Š�„£„ÌÍy\� <“ 	Ž,òÿ	$ ¤#%äE<W™

©âô_		ÃØã
üƒ¯)�yfôƒ¯)�yf
Y[lh$h		·Ä{”{		ü™!”™		ø°ú°û°Ðü°ý°�þ°ìH�ËˆXêE>¾!”¿™ºTÄÈT
üØ4læ¾!ÈT
ôµDôü°3$¾ýýÈT¾!ôÃ
ô$È’Î˜,Úü—$,¥ÈT·
ô$«¼¡ æ¨ ÚÝü¾ /Ò$Ä ÆÉ¹¼´ó ¥ä�!˜›ˆ‹{~nq”Ä"ü®!1. Pre-allocated storage for a uniform data typeÁà!Ëüä!41 See the [module documentation] for more details.Á™"Ëü�"&# [module documentation]: index.htmlÁ$Ï"™!!ºTÔ"·œ/ÄÜ˜?ƒ@"#$´ô"<ô"  –*TÈ#È#  ¾!\È$$È$  ¾!üØ$-™&&ºTÝ$Þô,ÿ$·'(ßà'((*¼Œ%,�%þþ··%•%%
'ô$–%ü&'T°&ÿ€ÿ·€·âW%»&%
(ô$À&sourceÁ4Æ&ÜÒ'™**ºT×'·+Å+¤ô'<÷'·))
+ôü‘+)‹-æ`-üÁ+8Ä+�‚ƒ�‹‚Á`Á`œÃ`èÁ]Ä`©)Á]Ê\É:•ƒê³í³î³Òï³ìð³ñ³“ò³ìäs{©¶‘âWÑ¼Ñ¼Ò¼”štÀ.,È+,
-$É+þÏ+üÚ..»Ä.Ç.×.8¶<È.Ð.7“,Ò.¼Â.‹´ü3üÀ3;8 A consuming iterator over the values stored in a `Slab`ÁD‡4™00ºT�4Ù"#S;’Ý¼12ü™41<™4//¯¢¯¢�±¢£	ä6²¢Ãä6fLLAMNÅ‚¼>¼>æ
¿>©)«<À>phantomÁ«<Á>capÁ«<Â>á«<Ã>÷«<Ä>Ï«<Ö“<]¿‘�F£ Õ*TÐ4Ð4//¾!´”5üß441 An iterator over the values stored in the `Slab`Á$Ÿ5•4™554©âÔ¨5Ô•§^Ì$‚ m×xš$67¤513ü±53<±533¯¢¯¢�±¢£	ä6²¢Ãä6fLLAMNÅ‚ÙiÙiŠÜi÷®iÝi
end_or_lenÁ®iÞi_markerÁ®it¸%ýN(•òôõ£öì÷ø¾ùìê+’gÍ=ÖÔTê5ê533¾!ìù58„™99„åeþ5á:ß:¼�6, 6……áá8¦68
:8Ô$§6ÌÛ7üŸ7;8 A mutable iterator over the values stored in the `Slab`Á<æ7•<™==<åeò7õeÚ,^%
ºB›_J>?î7*,üû76<û7;;¯¢¯¢�±¢£	ä6²¢Ãä6fLLAMNÅ‚ñiñiÅôi÷®iõi¡f®iöi·f®iÇzRhgQ•ÞgT·8·8;;¾!¼é8üÆ8" A draining iterator for `Slab`Á,ô8•A™BABåeþ8õe®@@ïC‰D¾	åÞŽæx¶ÄÃ•ÔåÞŽæx¶ÄÃCDú8ceü‡9,‡9@@»=»=ï¿=
tail_startÁ«<À=tail_lenÁ«<Á=£	«<Â=œ«<ÛÛ`qÌ�Ç•ÞgÕ*T¬9¬9@@¾!|ƒ:™FFºTˆ:·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è;ù6û;Ë<ƒ<Î7”�<Ý7ü¦<&# let slab: Slab<i32> = Slab::new();Á<Ñ<Î7ê<·EE
Gôü·E0üè=>; Construct a new, empty `Slab` with the specified capacity.Á«>Ëü³>FC The returned slab will be able to store exactly `capacity` withoutÁüþ>A> reallocating. If `capacity` is 0, the slab will not allocate.ÁÄ?ËüÌ?LI It is important to note that this function does not specify the *length*Áü�@JG of the returned slab, but only the capacity. For an explanation of theÁüì@=: difference between length and capacity, see [Capacity andÁü®A85 reallocation](index.html#capacity-and-reallocation).ÁëAËtóAù6†BË<ŽBÎ7”šBÝ7ü±B+( let mut slab = Slab::with_capacity(10);ÁáBËüéBHE // The slab contains no values, even though it has capacity for moreÁô¶C assert_eq!(slab.len(), 0);ÁÙCËüáC1. // These are all done without reallocating...Á¤—D for i in 0..10 {Á¼°D     slab.insert(i);Á,ÌD–CÖDËüÞD/, // ...but this may make the slab reallocateÁ¤’E slab.insert(11);Á<«EÎ7l¾E¾!·EE
HôµDÌEüéHüêFHE Return the number of values the slab can store without reallocating.Á·GËt¿Gù6ÒGË<ÚGÎ7”æGÝ7üýG2/ let slab: Slab<i32> = Slab::with_capacity(10);Áü´H$! assert_eq!(slab.capacity(), 10);Á<ÝHÎ7DðH††·¾!EùHE
Iô$úHü�Q,ü¶IGD Reserve capacity for at least `additional` more values to be storedÁ¼‚J without allocating.ÁžJËü¦JJG `reserve` does nothing if the slab already has sufficient capacity forÁüõJLI `additional` more values. If more capacity is required, a new segment ofÁüÆKLI memory will be allocated and all existing values will be copied into it.Áü—LKH As such, if the slab is already very large, a call to `reserve` can endÁ¼çL up being expensive.ÁƒMËü‹MGD The slab may reserve more than `additional` extra space in order toÁü×MJG avoid frequent reallocations. Use `reserve_exact` instead to guaranteeÁü¦N/, that only the requested space is allocated.ÁÚNËdâN	 # PanicsÁóNËüûN:7 Panics if the new capacity exceeds `isize::MAX` bytes.ÁºOËtÂOù6ÕOË<ÝOÎ7”éOÝ7ü€Pø7Ì¤P slab.insert("hello");Á¬ÂP slab.reserve(10);ÁüÜP#  assert!(slab.capacity() >= 11);Á<„QÎ7<—Q‡‡·¾!âWEŸQE
Jô$¤Q
additionalÁTªQüòZ2ü‹SGD Reserve the minimum capacity required to store exactly `additional`Á„×S
 more values.ÁìSËüôSLI `reserve_exact` does nothing if the slab already has sufficient capacityÁüÅTMJ for `additional` more values. If more capacity is required, a new segmentÁü—UKH of memory will be allocated and all existing values will be copied intoÁüçULI it.  As such, if the slab is already very large, a call to `reserve` canÁÜ¸V end up being expensive.ÁØVËüàVJG Note that the allocator may give the slab more space than it requests.Áü¯WFC Therefore capacity can not be relied upon to be precisely minimal.ÁüúW74 Prefer `reserve` if future insertions are expected.Á¶XËd¾XšƒÏXËü×X:ºƒ–YËtžYù6±YË<¹YÎ7”ÅYÝ7üÜYø7Ì€Z¿„ÜžZ slab.reserve_exact(10);Áü¾Z#þ„<æZÎ7lùZˆˆ·¾!âWE‡[E
Kô$Œ[ý…T’[ü‰güù\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.ÁüÌ^NK It will drop down as close as possible to the length but the allocator mayÁüŸ_SP still inform the underlying vector that there is space for a few more elements.Á÷_Ëüÿ_MJ This function can take O(n) time even when the capacity cannot be reducedÁüÑ`LI or the allocation is shrunk in place. Repeated calls run in O(1) though.Á¢aËtªaù6½aË<ÅaÎ7”ÑaÝ7üèa+†w˜bËœ b for i in 0..3 {Á¼¸bœy,Ôb–CÞbËÌæb slab.shrink_to_fit();Áü„c:7 assert!(slab.capacity() >= 3 && slab.capacity() < 10);Á<ÃcÎ7ÏcËü×cGD The slab cannot shrink past the last present value even if previousÁ¼£d values are removed:Á¿dË<ÇdÎ7”ÓdÝ7üêd+†wšeËœ¢e for i in 0..4 {Á¼ºeœy,Öe–CàeËœèe slab.remove(0);Áœ€f slab.remove(3);Á˜fËÌ fÞ“ü¾f:€”<ýfÎ7l�g‰‰·âWEžgE
Lô$£gü˜r"¤›rŠŠ·âWE°rE
Mô$µrüñ„düÇxZW Reduce the capacity as much as possible, changing the key for elements when necessary.Á¦yËü®yRO To allow updating references to the elements which must be moved to a new key,Áü…zMJ this function takes a closure which is called before moving each element.Áü×zJG 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¿~ù6Ò~Ë<Ú~Î7”æ~Ý7ý~Ëü…+†wìµ 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);Á<å�Î7ñ�Ëüù�:7 The value is not moved when the closure returns `Err`:Á¸‚Ë<À‚Î7”Ì‚Ý7ã‚Ëüë‚,) 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')));Á<å„Î7<ø„ŒŒ·£
âWE£
OOƒ…E©â¦€…‹– ¦
7¾	‚ m×xš$’ôE¯¥E
[ô$°¥ü³¬,ü¼¦85 Return an iterator that allows modifying each value.Áù¦Ëü�§I‚²üÏ§DÕ²ü˜¨E£³üâ¨6ò³�©Ët¥©ù6¸©Ë<À©Î7”Ì©Ý7üã©ø7‡ªËô�ª let key1 = slab.insert(0);Áô²ª let key2 = slab.insert(1);ÁÕªËüÝª'$ for (key, val) in slab.iter_mut() {ÁÄ‰«     if key == key1 {Á´¦«         *val += 2;ÁLÁ«     }Á,Ï«–CÙ«Ëôá« assert_eq!(slab[key1], 2);Áô„¬ assert_eq!(slab[key2], 1);Á<§¬Î7Dº¬““·;;Å>‘
?¾	
ºB›_J“ô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�¯ù6¢¯Ë<ª¯Î7”¶¯Ý7üÍ¯ø7üñ¯#  let key = slab.insert("hello");Á™°Ëü¡°.+ assert_eq!(slab.get(key), Some(&"hello"));ÁüÔ°$! assert_eq!(slab.get(123), None);Á<ý°Î7�±””·¾!ø°ú°û°Ðü°ý°�þ°ìH�ËˆXêE>”ôE”±E
]ô$•±’›±ü¡¶7ü¾²JG Return a mutable reference to the value associated with the given key.Á�³Ëü•³C€¿lÝ³Ì¿ï³Ët÷³ù6Š´Ë<’´Î7”ž´Ý7üµ´ø7üÙ´#¬À�µËü‰µ*' *slab.get_mut(key).unwrap() = "world";Á¸µËüÀµ#  assert_eq!(slab[key], "world");Áüèµ(% assert_eq!(slab.get_mut(123), None);Á<•¶Î7<¨¶••·¾!ø°ú°û°Ðü°ý°�þ°ìH�ËˆXêE>•ô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ç»ù6ú»Ë<‚¼Î7”Ž¼Ý7Œ¥¼ use std::mem;Á»¼ËüÃ¼ø7ôç¼ let key1 = slab.insert(1);ÁôŠ½ let key2 = slab.insert(2);Áü½>; let (value1, value2) = slab.get2_mut(key1, key2).unwrap();Áôð½ mem::swap(value1, value2);Áô“¾º¼ô¶¾á¼<Ù¾Î7Dì¾––·¾!¾!ø°ú°û°Ðü°ý°�þ°ìH�ËˆXêE>–ô–Ð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.Á„ƒÆ——·¾!Íê³í³î³Òï³ìð³ñ³“ò³ìäs{©¶‘—ôÍ‹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Õù6ÀÕË<ÈÕÎ7”ÔÕÝ7üëÕø7ì�Ö let key = slab.insert(2);Á±ÖËd¹Ö	 unsafe {ÁüÊÖ0-     assert_eq!(slab.get_unchecked(key), &2);Á,ÿÖ–C<‰×Î7l£×˜˜·¾!˜ô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©Ûù6¼ÛË<ÄÛÎ7”ÐÛÝ7üçÛø7ì‹ÜÒÖÜËdµÜ„×üÆÜ.+     let val = slab.get_unchecked_mut(key);Á”ùÜ     *val = 13;Á,�Ý–CšÝËô¢Ý assert_eq!(slab[key], 13);Á<ÅÝÎ7ŒßÝ™™·¾!™ôEñÝE
fô$öÝ’üÝüùåYü°ßGÀÇüüßKH given keys simultaneously without performing bounds checking and safetyÁ¼Ìà condition checking.ÁèàËüðà<9 For a safe alternative see [`get2_mut`](Slab::get2_mut).Á±áË
 `insert`.Á”ÎËtœÎù6¯ÎË<·ÎÎ7”ÃÎÝ7üÚÎø7þÎËŒ†ÏÆ<üœÏ(à<ôÉÏ�=ìÏËüôÏ%Â=\žÐï=4®Ð‚>¹ÐËüÁÐ%œ>üëÐ'Ê><—ÑÎ74ªÑ—Ô�¡žž
¡•Ô$±Ñ–·ÑÔ®×ü�Ó.+ Return the key associated with this entry.ÁÐÓËüØÓB? A value stored in this entry will be associated with this key.ÁŸÔËt§Ôù6ºÔË<ÂÔÎ7”ÎÔÝ7üåÔø7‰ÕËŒ‘ÕÆ<ü§Õ(à<ôÔÕ�=÷ÕËüÿÕ%Â=\©Öï=4¹Ö‚>ÄÖËüÌÖ%œ>üöÖ'Ê><¢×Î7µ×»»—¾!ž¹×ž
¢•Ô$º×üþ× ™¤¤ºTƒØÙ"¥¦§ßKàKäK§¦%'L¥Ø$ªØ££Á"üÂØ($ÅØ¼¼Ù"ø°ú°û°Ðü°ý°�þ°ìH�ËˆXêE>Ù"ßK£ÊØ£
¦ô$ÏØüëÚ-LîÚ½½Ù"¾!íU£øÚ£
§ô$ùÚüÇÛ+™©©ºTÌÛÙ"ªóJªüùÛ-LüÛ¾¾Ù"í¿¨†Ü¨
ªô$‹Üü·Þ)™¬¬ºT¼ÞÙ"ªK´çÞêÞ¿¿Ù"¾!«îÞ«
ô$ïÞüšß%™¯¯ºTŸßÙ"
üÙß$•±™²²±åeâßÌ$³´µßKàKäK´µÞß,.L„à$‰à°°›Ÿü¥à($¨àÀÀÌ$ø°ú°û°Ðü°ý°�þ°ìH�ËˆXêE>Ì$ßK°à°