Files
boc/aamos-ledger-rust/target/debug/deps/libhashbrown-a971313051c2b5a1.rmeta
T

2764 lines
874 KiB
Plaintext
Raw Normal View History

rust
è¥
#rustc 1.96.0 (ac68faa20 2026-05-25)ÁíàÄTËŸ ÜJîÄ)'ß\¥!-3d1337db07d0b3aeÁ¤²XctÔ'ÐÓ©z¨ɽÓ-a4945860e1c53b00Á¤°ð ¾ä-±($²ï=©Ã-7e98a21bfd32b0edÁÀö ReadmeDoctestsÁt Ý<­ ¦»nightlyÁœ§
AllocErrorÁT)$innerÁ,½»óœ£Ÿ»allocator-api2ÁÔR\\:»default-hasherÁÔR4G»èR RandomStateÁ\d»è24R
DefaultHasherÁlö»èÔ½Rforward_writesÁtê»èÔÀS$†Stest_mapÁD¿¶ $´¶ likelyÁ4Œ»óœTûD”»órayonÁ,)»ÙŒserdeÁ,N»óŒ6˜
equivalentÁTµ?» raw-entryÁ¬?˜ŠD¥Ô $šÔ ˜test_map_with_mmap_allocationsÁôÏô $‡ô  raw_entryÁLê »£¬Î  rustc_entryÁ\ 
»rustc-internal-apiÁôû ¡ test_setÁD÷Ä$ìĵtestsÁ,¡’ $–’ °»èÔƒÙ»ÙŒ–Ù»ÙŒÚÙ»ÙŒ¤
EquivalentÁTü»´Ï1µ
ðµ¼€
1impÁ
ðµ1lsxÁŒ
»óœ‰
1œ¤
»ó1genericÁ<Â
ðµfìôœ¥
ìõ´º
ü¤-
µ 

üöu
ì¼¼
ðà ¼Ý
ílittleÁĆ
µ
ü²
»ó´ì¾ܦ
ð³´Ë
µ
üÿ
|
XÄ
À
1ω
ðµ2ìôÍìõËɵ ÆÄÂì¿ðà ½íÎ µµ ³±¯»ó_쾬𳪵 ¨¦¤¡ž ístdallocÁmacrosÁcfg_ifÁ¦¤Ÿ       AllocatorÁallocateÁ
deallocateÁ Ð ß  > do_allocÁcontrolÁbitmaskÁ#remove_lowest_bitÁ# any_bit_setÁ#lowest_set_bitÁ#trailing_zerosÁ#nonzero_trailing_zerosÁ#
leading_zerosÁ**IntoIterÁ*ê..ó groupÁ111111tagÁ8888<EMPTYÁ<DELETEDÁ<is_fullÁ<
is_specialÁ<special_is_emptyÁ<B MIN_HASH_LENÁ8D×8 TagSliceExtÁFfill_tagÁF
fill_emptyÁ8IÓhasherÁ@SSSSSSSSSS S
S S S
SSSSSSSSSSSSSS offset_fromÁo¥Sqcapacity_overflowÁq alloc_errÁSSizedTypePropertiesÁt
IS_ZERO_SIZEDÁt
NEEDS_DROPÁSw¥Sh1ÁSz move_nextÁScapacity_to_bucketsÁS'ensure_bucket_bytes_at_least_ctrl_alignÁSbucket_mask_to_capacityÁSæ ¥calculate_layout_forÁSBucketÁƒ¥ƒµ S¥Sˆ¥ˆƒS¥from_base_indexÁ
to_base_indexÁas_ptrÁ as_non_nullÁnext_nÁãreadÁwriteÁÉ'aÁas_mutÁ§SRawTableÁ¥tableÁ¤ÚS
RawTableInnerÁŸ bucket_maskÁŸctrlÁŸ growth_leftÁŸitemsÁS¤¥¤æ ¤
with_capacityÁS¨¥¨¨ TABLE_LAYOUTÁ¨new_inÁ¨new_uninitializedÁ¨with_capacity_inÁ¨¨¨data_endÁ¨allocation_sizeÁ¨ bucket_indexÁ¨bucketÁ¨
erase_no_dropÁ¨eraseÁ¨removeÁ¨
remove_taggedÁ¨ remove_entryÁ¸impl FnMut(&T) -> boolÁ¨
clear_no_dropÁ¨clearÁ» ¨ shrink_toÁ½impl Fn(&T) -> u64Á¨reserveÁ¿æ¨ try_reserveÁÁæ¨reserve_rehashÁÃæÃ Ã ¨resizeÁÇæÇ ¨insertÁÊæ¨ insert_entryÁÌæ¨replace_bucket_withÁΨfind_or_find_insert_indexÁÐÐæÐ ¨insert_at_indexÁ¨insert_tagged_at_indexÁ¨findÁÖÖ ¨getÁÙ¨get_mutÁÛ¨
get_bucketÁ¨get_bucket_mutÁ¨checked_bucketÁ¨get_disjoint_mutÁàŸà àimpl FnMut(usize, &T) -> boolÁà à å ¨get_disjoint_unchecked_mutÁçŸç çÛç ç ì ¨get_disjoint_mut_pointersÁîŸî îÛî î ó ó ¨capacityÁ¨¨is_emptyÁ¨ num_bucketsÁ¨is_bucket_fullÁ¨ù¨ iter_hashÁ¨iter_hash_bucketsÁ¨full_buckets_indicesÁ¨drainÁ¨drain_iter_fromÁ¨into_iter_fromÁ¨into_allocationÁS ƒ¥ƒS
¥S NEWÁæ S prev_pow2ÁSmaximum_buckets_inÁS ޵Žfallible_with_capacityÁ ŽêŽfix_insert_indexÁŽfind_insert_index_in_groupÁŽfind_or_find_insert_index_innerÁŽprepare_insert_indexÁŽfind_insert_indexÁŽ
find_innerÁŽprepare_rehash_in_placeÁŽù¥Ž
drop_elementsÁŸ¥Ždrop_inner_tableÁ¡¥¡Ž©¤¥Ž
bucket_ptrÁŽî§¥Ž probe_seqÁŽrecord_item_insert_atÁŽis_in_same_groupÁ« Ž
set_ctrl_hashÁŽreplace_ctrl_hashÁŽset_ctrlÁŽªŽ
ctrl_sliceÁŽÇ ŽÚ Žnum_ctrl_bytesÁŽis_empty_singletonÁŽprepare_resizeÁ§ Žreserve_rehash_innerÁ»Ž¢!Ž resize_innerÁ¾Žrehash_in_placeÁÀ Ž free_bucketsÁÂŽallocation_infoÁŽallocation_size_or_zeroÁŽ®ŽÌS
È¥ÈȃÈÌ S
RawTableCloneÁÎclone_from_specÁSÐ¥ÐSÓ¥ÓÓclone_from_implÁÖ SØ¥ØØ>SÜ¥ÜÜãSà¥àààæàêS RawIterRangeÁæ¥æ
current_groupÁædataÁæ next_ctrlÁæþSì¥ìæ ì next_implÁïDO_CHECK_PTR_RANGEÁì fold_implÁññSô¥Sö¥Sø¥øƒSû¥ûûó þ û size_hintÁS¥SRawIterÁƒ¥ƒùƒÉS¥%SŠ¥ŠƒS¥>S¥ó  ê-foldÁS¥S¥S>S ŸÑ,S!¡¡ó ¡ê-S"S#S RawIntoIterÁ§¥§§ù§
allocationÁ§ÚS$­¥­­ùS%±¥±S&´¥´S'·¥··ãS(»¥»»>S)¿¥¿¿¿ó ¿ê-S*Å¥ÅS+È¥ÈSRawDrainÁ˧˥ËËùËæË
orig_tableÁËÚS,Ó¥ÓÓùS-×¥×S.Ú¥ÚS/Ý¥ÝÝãS0á¥áááó áê-S1ç¥çS2ê¥êS RawIterHashÁí¥íŸí_markerÁS3ñ¥ñæ óS4õ¥õƒS5ø¥ø>S6û>S7ýæ S8ÿ¥ÿÿó S9ƒƒó S RawExtractIfÁ§¥ùæS:Œ¥ŒŒó utilÁ¨û invalid_mutÁ¥external_trait_implsÁؘ˜˜˜˜˜˜˜˜˜ ˜
˜ ˜ ˜
˜˜˜˜˜˜˜˜˜˜˜˜˜³œ³§³¤³³ hash_builderÁ³æ˜ºœº§º¤ººƒº˜ make_hasherÁÁ¢Á§Á¤ÁÁ ˜equivalent_keyÁǢǜǧÇÇ ˜ make_hashÁͤ͢˜ÐœÐ§Ð¤Ð with_hasherÁÐwith_capacity_and_hasherÁ˜ÖœÖ§Ö¤ÖÖ¨Öwith_hasher_inÁÖwith_capacity_and_hasher_inÁÖšÖŸ ÖkeysÁÖ¼Ö
values_mutÁÖùÖúÖÖ· Ö¾!ÖretainÁèÖ
extract_ifÁêÖÃÖ into_keysÁÖ into_valuesÁ˜ïœï§ï¤ïïïï
shrink_to_fitÁïÕïentryÁï entry_refÁù§ù'bÁù¢ïÎý¢ï
get_key_valueÁÿ¢ïget_key_value_mutÁ¢ï contains_keyÁƒ¢ïá¢ï¢Ÿ   Œ ï get_many_mutÁŽ¢ŽŸŽ Ž ï¢Ÿ   ˜ ïget_many_unchecked_mutÁš¢šŸš š ïget_disjoint_key_value_mutÁŸ¢ŸŸŸ Ÿ Ÿ ¤ ïget_many_key_value_mutÁ¦¢¦Ÿ¦ ¦ ï$get_disjoint_key_value_unchecked_mutÁ«¢«Ÿ« « « ° ï get_many_key_value_unchecked_mutÁ²¢²Ÿ² ² ïget_disjoint_mut_innerÁ·¢·Ÿ· · · ï get_disjoint_unchecked_mut_innerÁ½¢½Ÿ½ ½ ½ ïbuild_hashes_innerÁâßà à à ïõïinsert_unique_uncheckedÁï
try_insertÁïÙÌ¢ïü΢ïþ˜ÑœÑ§Ñ¤ÑÑÖ × ˜ÙœÙ§Ù¤Ù˜ÞœÞ§Þ¤ÞÞטäœä§ä¤ää>˜êœê¢ê§ê¤êê°êÖ˜IterÁò§òœò§òŸòÚ˜ øœø§øƒ˜
üœü§üטIterMutÁ§œ§ŸÚ˜ œ§˜ œ§ù˜æœ§Ÿ˜
œ§ù˜IntoKeysÁœ§Ÿ˜œœœ§œœ>˜¡œ¡§¡¡¡ó ¦ ¡ê-¡‘/©©© ˜­œ­§­­˜²œ²§²˜œ§×º ˜
IntoValuesÁ¼œ¼§¼¼Ÿ˜ÁœÁ§ÁÁ>˜ÆœÆ§ÆÆÆó Ë Æê-Æ‘/ÎÎÎ ˜ÒœÒ§ÒҘלקטۜۧÛÛ×ß ˜KeysÁá§áœá§áŸ˜æœæ§æƒ˜êœê§êטValuesÁî§îœî§îŸ˜óœó§óƒ˜÷œ÷§÷טDrainÁû§ûœû§ûûŸ˜œ§ù˜ ExtractIfÁ§œ§±Ÿ˜ŽœŽ§ŽŽŽŽó  Žê-˜œ§˜ ValuesMutÁ§œ§Ÿ˜EntryÁ § œ § ¤  OccupiedÁ¦
¦ˆ VacantÁ©
©ˆ˜¬œ¬§¬¤¬¬×˜
OccupiedEntryÁ²§²œ²§²¤²²§²elemÁ²æ˜ »œ»§»¤»˜!ÀœÀ§À¤À˜"ŜŧŤÅÅט VacantEntryÁ˧˜˧ˤË˧ËkeyÁËæ˜#ԜԧԤÔÔטEntryRefÁÚ§Úƒ>ڜڢڧڤÚÚ÷Qâ
âˆÚ”Rå
刘$èœè¢è§è¤èèטVacantEntryRefÁï'mapÁï'keyÁïœï¢ï§ï¤ïï§ïïTïæ˜%úœú¢ú§ú¤úúט
OccupiedErrorÁ§œ§¤Ý=»˜&œ§¤×˜'œ§¤×˜(§œ§¤æê˜)ž§žœž§ž¤žžžæžê˜*§œ§§§¤§§§æ§ê˜+¯œ¯§¯>˜,³§³œ³§³³ó ³ê-³‘/ººº ˜-¾œ¾§¾˜.Ϥ˜/ŜŧÅ>˜0ɧɜɧÉÉó Éê-É‘/ÐÐÐ ˜1ԜԧԘ2؜ا˜3ۜۧÛט4ߜߧßß>˜5äœä§äääó äê-ä‘/ëë˜6îœî§îî˜7óœó§ó˜8÷œ÷§÷÷ט9üœü§ü>˜:§œ§ó ê-‘/˜;œ§ ˜< œ §˜=œ § >˜> § œ§ó ê-‘/   ˜?¡ œ¡ §¡ ˜@¥ œ¥ §˜A¨ œ¨ §¨ >˜B¬ §¬ œ¬ §¬ ¬ ó ¬ ê-¬ ‘/³ ³ ³ ˜C· œ· §· ˜D» œ» §˜E¾ œ¾ §¾ ×Á ˜Fà œà §à à à ó à ê-à ‘/Ê Ê ˜GÍ œÍ §Í Í ˜HÒ œÒ §Ò ˜IÖ œÖ §Ö Ö ×˜JÛ §Û œÛ §Û ¤Û Û õÛ  or_insertÁÛ or_insert_entryÁÛ or_insert_withÁä Û or_insert_with_keyÁæ Û ïTÛ 
and_modifyÁé Û and_replace_entry_withÁë Û into_mapÁ˜Kî §î œî §î ¤î î 
or_defaultÁ˜Lõ §õ œõ §õ ¤õ õ ïTõ  replace_keyÁõ replace_key_uncheckedÁõ üõ Îõ áõ into_mutÁõ 
into_entryÁõ õõ Ùõ replace_entry_withÁ

õ ·f˜M
§
œ
§
¤

ïT
into_keyÁ
õ

·f˜N
§
ƒ>
œ
¢
§
¤

õ
‡e
¯ež

Íe 

ïT
÷e£

·f˜O¦
§¦
ƒ>¦
œ¦
¢¦
§¦
¤¦
¦
ôf¦
or_default_entryÁ˜P°
ìV°
øV°
ϡ
¢°
§°
¤°
°
ïT°
õ°
insert_with_keyÁ°
insert_with_key_uncheckedÁ°
°
insert_entry_with_keyÁ°
insert_entry_with_key_uncheckedÁ°
·f˜QÀ
œÀ
§À
¤À
À
ùÅ
¥Å
˜RÈ
œÈ
§È
¤È
È
extendÁÍ
¥Í
˜SÐ
§Ð
œÐ
§Ð
¤Ð
Ð
ãmÖ
¥Ö
˜TÙ
§Ù
œÙ
§Ù
¤Ù
Ù
ãmß
¥ß
˜assert_covarianceÁâ
map_keyÁã
'newÁâ
map_valÁå
ªoâ
iter_keyÁç
§ç
ªoâ
iter_valÁê
§ê
ªoâ

into_iter_keyÁí
ªoí
â

into_iter_valÁð
ªoð
â
keys_keyÁó
§ó
ªoâ
keys_valÁö
§ö
ªoâ

values_keyÁù
§ù
ªoâ

values_valÁü
§ü
ªoâ
¾!ÿ
ªo
scopeguardÁ       
ScopeGuardÁˆ ¥ˆ ˆ dropfnÁˆ » £ ¥   ¥  
into_innerÁ  ¥  å ´  ¥    ¥  ãsetÁ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡  ¡ 
¡  ¡  ¡ 
¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¿ ¥¿ ¤¿ ¿ Ø¡ Ä ¥Ä ¤Ä Ä ƒÄ ¡ Ê ¥Ê ¤Ê Ê Ÿ Ê ùÊ Ê · Ê ¾!Ê ¯<Ó Ó Ê Å<Ö Ê Ã¡ Ù ¥Ù ¤Ù ¸:Ù Ë:¡ Þ ¥Þ ¤Þ Þ ¨Þ ˜;Þ ®;Þ š¡ æ ¥æ ¤æ æ æ æ À=æ Õæ 
differenceÁî §æ symmetric_differenceÁð §æ  intersectionÁò §æ Cô §æ containsÁö ¢æ Îø ¢æ 
get_or_insertÁæ get_or_insert_withÁû ¢û æ Ý=æ  is_disjointÁæ  is_subsetÁ æ  is_supersetÁæ õæ ¢Dæ replaceÁæ Ù ¢æ takeÁˆ ¢æ þ¡  ¥ ¤   ¡  ¥ ¤ ¡  ¥ ¤  ס š ¥š ¤š š ÷¡  Ÿ ¥Ÿ ¤Ÿ Ÿ ù£ š¡ 
¥ ¥¥ ¤¥ ¥ ãm© š© ¡  ¬ §¬ ¥¬ ¤¬ ¬ ãm± š¡  ³ ¥³ ¤³ ³ >¡ 
¸ ¥¸ ¤¸ ¸ °¸ ±¡ ¾ ¥¾ ¤¾ ¾ °¾ ¯¡ Ä ¥Ä ¤Ä Ä °Ä µ¡ Ê ¥Ê ¤Ê Ê °Ê Ú¡ Ð ¥Ð ¤Ð Ð ²¡ Õ ¥Õ ¤Õ Õ °Ù ¡ Û ¥Û ¤Û Û ¡ à ¥à ¤à à Ûä ¡ íFæ §æ œæ ù¡ æê œê ê ù¡ Oî §î œî î ù¡ éOó §ó œó ó ó ±ó Ÿ¡  IntersectionÁú §ú ¥ú ¤ú ú ùú ¹
¡ 
DifferenceÁ
§
¥
¤

ù
¹
¡ SymmetricDifferenceÁˆ
§ˆ
¥ˆ
¤ˆ
ˆ
ù¡ ôŽ
§Ž
¥Ž
¤Ž
Ž
ù¡ 
§
¥
¤


æ
ê¡ œ
¥œ
¤œ
œ
œ
æœ
ê¡ £
ϣ
ƒ¡ ¦
œ¦
>¡ ©
§©
ϩ
©
ó ©
ê-©
/¯
¯
¡ ²
œ²
¡ µ
œ¡ ·
œ·
ס º
ϼ
º
>¡ ¾
œ¾
¾
¾
ó ¾
ê-¾
/Ä
Ä
Ä
¡ È
œÈ
È
¡  Ì
œÌ
¡ !Ï
œÏ
Ï
×Ò
¡ "Ô
œÔ
Ô
Ô
ó Ô
ê-Ô
/Ú
Ú
Ú
¡ #Þ
œÞ
Þ
¡ $â
ω
¡ %å
ό
å
×è
¡ &ê
ϐ
ê
ê
ê
ó ï
ï
ê
ê-¡ 'ó
ϗ
ó
¡ (÷
¥÷
¤÷
÷
ƒ¡ )ü
§ü
¥ü
¤ü
ü
ü
ó ü
ê-ü
‘/ ¡ *ˆ¥ˆ¤ˆˆ×¡ +¥¤¡ ,¥¤ƒ¡ -§¥¤ó ê-‘/žžž ¡ .¢¥¢¤¢¡ /¦¥¦¤¦¦×¡ 0«¥«¤««ƒ¡ 1°§°¥°¤°°°ó °ê-°‘/¸¸¡ 2»¥»¤»¡ 3¿¥¿¤¿¿×¡ 4ĥĤÄă¡ 5ɥɤɡ 6ͥͤÍÍס 7Ò§Ò¥Ò¤ÒÒÒó Òê-Ò‘/ÚÚ¡ ÂQݧݥݤÝÝ÷Qâ
âˆÝ”Rå
刡 8è¥è¤èèס ÜRí§í¥í¤íퟡ 9ó¥ó¤óóס ¬Tø§ø¥ø¤øøŸ¡ :þ¥þ¤þþס ;ƒ§ƒ¥ƒ¤ƒƒõƒ‡eƒÎ¡ <¥¤ÎÙ¡ =§¥¤Î
into_valueÁõ¡ ‚oïsšªoùœ§œªo꟪oŸñw¢§¢ªo¢‹x¦§¦ªo¦¯xª§ªªoªC®§®ªo®¾!²ªo²æµµµµµµµµµµ µ
µ µ µ
µµµµµµµµ HashTableÁË¥ËË@µÏ¥Ïæ ÏêµÓ¥ÓÓ§ÓÎÓ¨ÓµÙÓfind_mutÁÛÓ
find_entryÁÝÓfind_bucket_indexÁßÓÝ=ááæÓget_bucket_entryÁÓget_bucket_entry_uncheckedÁÓøÓget_bucket_uncheckedÁÓŠÓget_bucket_unchecked_mutÁÓ
insert_uniqueÁêæÓÃÓÀ=íæÓÕïæÓñæÓóæÓÇ ÓŸ ÓÓ· ÓùÓúÓ unsafe_iterÁÓ iter_bucketsÁÓø Ó
iter_hash_mutÁÓ‰!Ó¯<impl FnMut(&mut T) -> boolÁÓ¾!ÓÅ<ƒÓŸ Û Ó»?ŠŸŠ ŠÛŠ ÓŸ Û Ó•@Ÿ Û Óþµš¥šššæšêµ § ¥   æ êµ§§§¥§§§æ§êµ®¥®®>µ²¥²²ƒ²µ·¥··×µÂQ»§»¥»»÷Q¿
¿ˆ»”RÂ
ˆµÅ¥ÅÅ×µ ɧɥÉÉõɇeɯeÏimpl FnOnce() -> TÁÉ÷eÑimpl FnOnce(&mut T)ÁÉ
into_tableÁµÜRÔ§Ô¥ÔÔ©Ôæµ
Ú¥Úµ ݥݵ à¥àà×µ
ä§ä¥ääÙäÎäáäƒhäÞžääµhTð§ð¥ðð²ðÖðæµ÷¥÷÷×µû§û¥ûûõûÞžµ AbsentEntryÁ§¥æµ¥×µŠ§Š¥ŠŠÞžµíF§¥ŸÚµ¥>µ§¥ó ê-‘/ µ¡¥¡µ¤¥µ¦§¦¥¦ƒµª¥ª×µÛG­§­¥­Ÿ­Úµ²§²¥²ùµ¥>µ¹§¹¥¹¹ó ¹ê-¹‘/¿¿¿ µÃ¥ÃµÆ¥µÈ¥È×µ
UnsafeIterÁ˧˥˟ËڵЧХÐùµÔ¥Ô>µ ×§×¥××ó ×ê-ב/ÝÝÝ µ!á¥áµ"䥵#æ¥æ×µ IterBucketsÁé§é¥éŸéÚµ$î¥îƒµ%ñ¥ñ>µ&ô¥ôôó ôê-µ'ù¥ùµ(ü¥µ)þ¥þ×µIterHashÁ§¥ŸÚµ*¥>µ+§¥ó ‘/ŽŽŽ µ,¥µ-§¥ƒµ.˜¥˜×µ IterHashMutÁ§¥ŸÚµ/ ¥ >µ0£§£¥££ó £‘/¨¨¨ µ1¬¥µ2®¥®×µIterHashBucketsÁ±§±¥±Ÿ±Úµ3¥ƒµ4¹¥¹>µ5¼¥¼¼ó µ6À¥µ7Â¥Â×µæÅ¥ÅÅŸµ8É¥ÉÉùµ9Í¥ÍÍ>µ:Ñ¥ÑÑÑó Ñê-Ñ‘/××µ;Ú¥ÚÚµ<Þ¥Þµ=á¥áá×µOå§å¥å埵>ê§ê¥êêùµ?ï¥ïïïó ïê-ï‘/õõµ@ø¥øøµAü¥üµBÿ¥ÿÿ×µéOƒ§ƒ¥ƒƒƒ±ƒŸµCŠ¥ŠŠŠŠó  Šê-µD¥hash_mapÁhash_setÁ
hash_tableÁæ œ £¢£œ£§× GlobalÁª
   ®ƒBitMaskÁ°
°ˆµƒ BitMaskIterÁ·
·ˆºƒ1à ¼¼¼¼¼¼¼ BitMaskWordÁ¼NonZeroBitMaskWordÁ¼BITMASK_STRIDEÁ¼BITMASK_ITER_MASKÁ¼ÇWIDTHÁÇ static_emptyÁÉ É AlignedTagsÁË_alignÁÌ ËtagsÁÎ É ALIGNED_TAGSÁÐ Ç¬Ç load_alignedÁÇ
store_alignedÁÇ match_tagÁÇ match_emptyÁÇmatch_empty_or_deletedÁÇ
match_fullÁÇ,convert_special_to_empty_and_full_to_deletedÁ1¼GroupÁÛ
Ûˆ¼¼¼àƒ8TagÁâ
âˆ888çƒ88ê8ìÖRDefaultHashBuilderÁRïƒRñ×Ró>S FallibilityÁõFallibleÁö
õ
InfallibleÁø
S;S<S=üƒSProbeSeqÁþposÁþstrideÁS>ƒS TableLayoutÁƒƒ
ctrl_alignÁS?S@SAˆƒÐª*SFullBucketsIndicesÁƒ,group_first_indexÁªÉSBƒSRawIterHashIndicesÁªtag_hashÁ”&ް
SCƒTryReserveErrorÁCapacityOverflowÁœ
žlayoutÁ ƒ£¥Ö§×




0
E
E
E
G
H
J
{
Š
Ž








¯
°
±
²
²
³
´
´
µ

·
¸
¸
º
»
½
½
¿
¿
Á
Á
Ã
Ã
Ç
Ç
Ê
Ê
Ì
Ì
Î
Ð
Ð
Ð
Ô
Õ
Ö
Ö
Ù
Ù
Û
Û
Ý
Þ
ß
à
à
ç
ç
î
î
ö
÷
ø
ù
ú
û
ü
ý
þ
ÿ








˜
˜

š


œ

Ÿ
¡
¡
¤
¦
§
©
ª
«
­
®
¯
°
±
²
³
´
µ


»
»
»
»
½
¾
¾
¾
¾
À
À
À
Â
Â
Ä
Å
Æ
Ç
Ë
Ì
Ì
Ï
Ï
Ö
Ö
ß
ï
ú
þ


Œ


 
£
¤
°
º
Ã
Ä
Ó
Ö
×
Ú
Ý
à
á
å
æ
ç
ê
ó
÷
þ


Œ


¿
À
À
Á
Á
Ç
Ç
Í
Í
Û
Þ
ß
à
á
â
ã
ä
å
æ
ç
è
è
è
ê
ê
ê
ì
ô
õ
ö
÷
ø
ý
ý
ÿ
ÿ


ƒ
ƒ




Ž
Ž


š
š
Ÿ
Ÿ
¦
¦
«
«
²
²
·
·
½
½
Ã
Ã
É
Ê
Ë
Ì
Ì
Î
Î
Ð
Ö
Ö
ã
ã
ã
ê
ñ
ñ
ø
û
ü
ÿ
ÿ
ÿ


Œ

¦
¨
±
º
º
º
Ë
Í
Ö
ß
ß
ß
æ
é
ê
í
í
í
ó
ö
÷
ú
ú
ú


Ž
Ž
Ž





¬
±
±
±
»
À
Å
Ê
Ê
Ê
Ô
Ù
Ù
Ù
è
è
î
î
î
ú
ú




Ž
Ž
Ž




¯
¸
¹
¾
Á
Â
Å
Î
Ï
Ô
×
Ø
Û
Þ
Þ
Þ
é
ê
ò
û
û
û
ü



Ž



œ
¡
¤
¥
¨
±
²
·
º
»
¾
Á
Á
Á
Ã
È
É
Í
Ñ
Ò
Ö
Ú
Ú
Ú
æ
è
é
ë
û
ü
ý
ÿ

ƒ


 
¢
£
¸
Í
Ö
ß
ˆ



˜

œ

 
È
É
É
Î
Ï
Ð
Ñ
Ò
Ó
Ó
Ö
Ö
Ø
â
å
ê
ë
ì
í
ö
ö
ø
ø
ú
û
û
û
þ
ÿ
ÿ




ƒ




ˆ
ˆ
Š





©
±
¸
¸
½
¾
¾
Ã
Ä
Ä
É
Ê
Ê
Ï
Ð
Ô
Ô
Õ
Ù
Ù
Û
ß
ß
à
ä
ä
£
¥
¦
­
®
²
´
µ
·
¹
¹
¹
Â
Ã
Ë
Ò
Ò
Ò
Ô
Ø
Ù
Þ
á
â
å
è
è
è
ê
ê
ï
ò
ó
ó
÷
û

ƒ
ˆ
Œ
Œ
Œ



œ

¢
¦
ª
ª
ª
«
¯

·
»
¿
Ã
Ã
Ã
Ä
È
É
Í
Ñ
Ñ
Ñ
Ø
Ù
è
ì
ì
ì
ó
÷
÷
÷
þ



Š



Ø
Ù
Ù
Û
Û
Ý
Ý
ß
ß
á
á
á
ä
å
æ
ç
è
é
ê
ê
ì
í
í
ï
ï
ñ
ñ
ó
ó
õ
ö
÷
ø
ù
ú
û
ü
ý
þ
ÿ



ƒ
ƒ


Š
Š





µ


º
º
º
Å
È
È
È
Ñ
Ú
Ý
à
ã
ã
ã
é
ê
í
÷
ú
ú
ú






œ
¡
£
¤
©
ª
¬
¬
¬
µ

½
¾
Ã
Å
Æ
È
Ê
Ê
Ê
Ó
Ô
Û
Ü
á
ã
ä
æ
è
è
è
î
ð
ñ
ô
÷
ø
ù
û
ü
þ







˜
š
š
š
 
§
¬
®
°
°
°

¸
¹
¼
¿
À
Â
Ä
Ä
Ä
Ì
Õ
Ö
Ý
ä
ä
ä
î
ï
ó
ô
ø
û
ü
ÿ



Š
Š




¢
¢
¦
¦
¨
¨
¨
¯

»
Õ × Ø á
è
ë
ë
í
ð
ò
ò
ò
ý


Š
Š

š
¡
¤
¤
¦
¨
¨
¨
Å8Ë8¹8¹§FtÎ Š ªª«г ÿ~Ö”xüËfÛöÜØöÜöܳöÜŠ °°±°³²ˆ á-_š cÛÏÝØÏÝÇLÏÝØ··¸ß³¹ˆ
;òÏ´ˆP6ùM©ÞŠ ÛÛÜķ݈¼ ““n`ͤÛíÞØíÞŠ ââãô·äˆ ôò~ñ^¶@Û½ßØ½ßÐì½ßµß½ß½ß½ß¿c½ßF
ÑÛÑÛ MaybeUninitÁÓÛuninitÁÝÔÛ»ÝÍõƒ«%9½ßØî9uÙ(#—¿S¿c˜á³˜áŠ õö÷йøùŸ¹ æìËÿãýÛØáØØát¥ØþþɹÿÙ¹Sä¹SœA…c<,Š ƒƒý¹S˜ºSÑy`¨DÇoÒÛûâØûâÌ샃ٵ S S~¡°Fb¬âØÓãÌìÆœæS¤SžÚS f¥ð4,f™¬â —䨗äΗ䳗äŒ"—äÇL—äÌìææç+èƒ,Sé˜,Sê¤,SëþSôŠ7Ÿ×X¬â ®åØ®åùM®åòP®å؃ƒ†.ùÉSCHMr[t<¬â³³æùM³æÃM³æòP³æØźŒƒ,SçºSŽªSÉSh’I›P³¢çùM¢çÃM¢çòP¢çÌì§§ÿ/ªùS«ª0S¬ÚS|ZnBiF”]¬âÞä ¦èŒ"¦è³¦èùM¦èÃM¦èòP¦èÌìËË’2ÏùSÐæSÑÊ2SÒÚSNìK
åM68¥ »éŒ"»éùM»éÃM»éòP»éØ›»SªSÅ»S”&SŽS˜°
SQP*ñœ2Øíí—4ïŸSðº4Så#q³
–¨¬â³Åë³ØêùMÅëùMØêس³¸¼8¹æ­¼x¾spAœ§¤µß´ì´ì´ì¿c´ì³´ìÙ¢³³¸¼8¹æ­¼x¾spAœ§¤ 8¢ØòòíFöŸ˜÷Ú˜¶¨7g|°ß8õí§¿c îÌìÛGŸ˜Ú˜£1ñ)åªx8õíãIŸ˜žÂw]ûÃììòì”êùMÊïÃMÊïòPÊï¿cÊï³¼¼¨KÀŸ˜…uRdÅv£ììòì”êùM·ðÃM·ðòP·ð¿c·ðØááÁM埘ªåjND­Çž8õíãî¿c¤ñØîî§NòŸ˜$úDP¢ÐÜ©8õíãî¿cññùMéOŒ±˜Ÿ˜t.™ 8õíãîòPéOŒ±˜Ÿ˜t.™ 8õíãî…óöÜ¿c ¦§÷Q¨ˆ©ª”R«ˆÞ`ÿú¨?˜8õíãóÌì²²ÜR¸§˜¹¡S˜ºæ˜£Ü,·s6ú8õíãîÃô‹ó Õô¿cÕô¿cËˬTѧ˜ÒïT˜Óæ˜Ñ!ÊSÂò+8õíãîÃô‹ó¿cÚâã÷Qäˆåæ”Rçˆ/âÁܪŒ‹88œ¢§¤¿cïïÖV÷§˜øïT˜ùæ˜0ùòDï†Kð88÷‡÷÷“÷™÷¿cùWÝ=ˆ»’mwšÐÍß8õíãîÃô‹óÄc‘øÇL §³³¸¼8¹æ­¼x¾spAõíãîÃô‹óÇL §òøÇL´ì³ îùMòòíFöŸ˜÷Ú˜¶¨7g|°ß§õíãîÃM îòP î³üîùMÛGŸ˜Ú˜£1ñ)åªx§õíãîÃMüîòPüî¿cüî³æŸ˜¥K@¬žú‚Äììòì”êùMÊûÃMÊûòPÊû¿cÊû³¤ñùMááÁM埘ªåjND­Çž§õíãîÃM¤ñòP¤ñ³ññùMîî§NòŸ˜$úDP¢ÐÜ©§õíãîÃMññòPññ³‘QŸŸ˜ýàƒ6 Ç¼8õíãîùM‘QŸŸ˜ýàƒ6 Ç¼§õíãîÃMÿýòPÿý¿cÿýùMûûOŸ˜Æ¢j—%Ä•8õíãîþìÃM¥ÿòP¥ÿ¿c¥ÿÃL´ìììòìÐL´ìÐLòø §õí §ãîÐLòø §õíãîé!ˆ ˆ šr ¼r Œ » ÃÈÒøn‰ê¬âö!쀌"ì€Ø¿ ¿ à ØGYÜ´•¬â¤”êµßÍÍÍ¿cÍéͳ³¸¼8¹æ­¼x¾spA¬âþ”êÃLͬâÐLͬâÐL¿ ¿ à ØGYÜ´•Žêøìþì §Žê³Í–ú 8¿ ¿ à ØGYÜ´•¥Ãô‹ó 8öøüƒ½„¶ûüƒ½„ïüƒ½„•˜¥ƒ 8¥ƒÞ—¥ƒƒ…̘¥ƒƒ…œö¥ƒƒ…ÇL §¥ƒÇLÍØæ æ íFé ù¡ ^¨ªÚ¢Å¢Ÿ8õí³á…ùMæ æ íFé ù¡ ^¨ªÚ¢Å¢Ÿ§õíÃMá…òPá…¿cá…³ê ê æí ù¡ Ø–¼Zñ¸6ììÞäùMЇÃMЇòPЇ¿cЇùMî î Oò ù¡ ØÛ¯ë!8õí”êÃMó‡òPó‡¿có‡ùMó ó éOø ±¡ ù Ÿ¡ ½5¦ef¹Z8õíþìòPÖˆØú ú ÿ ù¡ 
¹
¡ @÷éš\5#„8ŽêøìþìùMú ú ÿ ù¡ 
¹
¡ @÷éš\5#„§Žêøìþì¿cµ‰òPµ‰Ø

Ï
ù¡ 
¹
¡ ànãBá¤H>8ŽêøìþìùM

Ï
ù¡ 
¹
¡ ànãBá¤H>§ŽêøìþìòPòŠ¿còŠØˆ
ˆ
‘‚
ù¡ n†÷øY­o8ŽêøìþìùMˆ
ˆ
‘‚
ù¡ n†÷øY­o§ŽêøìþìòP¯Œ¿c¯ŒØŽ
Ž
ô
ù¡ })Úx8ŽêøìþìòPÔ¿cÔùMŽ
Ž
ô
ù¡ })Úx§Žêøìþì¿cÝâã÷Qäˆåæ”Rçˆ_lÌÊ×—ä¨8Žêøìþì¿cííÜRòŸ¡ .l³FmÞ.E8Žêøìþì¿cøø¬TýŸ¡ ÈÚœ]é 8ŽêøìþìÇLËËê”Î@]=½5K}¬âÞäÇL §ËËê”Î@]=½5K}Žê”êÇL §¥‘³ãØã¿cã¿c»¿À÷QÁˆÂÔRĈ@ÎÁ–âÎ8Žê”êÌìÔÔÜRØ©µÙæµ6l À•78Žê”ê ò’¿cò’¿cðð¬Tô²µõÖµöæµI*¸íJ&8Žê”ê¿cȡ浜Šî†h8Z8Žê”ê³íFŸµÚµ”}Xçžš 8ŽêùMíFŸµÚµ”}Xçžš §ŽêÃMó”òP󔨽•¿có”³­­ÛG°Ÿµ±Úµbá*¾ ²è8ŽêùM­­ÛG°Ÿµ±Úµbá*¾ ²è§ŽêÃM´–òP´–¿c´–³ËËò¥ÎŸµÏÚµŧÝ
Ïåõî8ŽêùMËËò¥ÎŸµÏÚµŧÝ
Ïåõî§ŽêÃMê—òPê—¿cê—Øéé֧쟵íÚµÎíý³}¨Ò8Žê³¢™ùM¢™ÃM¢™òP¢™¿c¢™³Ž©ŸµÚµ⺗îˆà‰¾8ŽêùMŽ©ŸµÚµ⺗îˆà‰¾§ŽêòP¤šØïš¿c¤š³ÓªžŸµŸÚµM)½W1‰­98ŽêùMÓªžŸµŸÚµM)½W1‰­9§ŽêòPÜ›¿cܛر±þ«´ŸµµÚµ@¹708Žê³ùMòP¿c³ÅÅæÈŸµ‰ÒäÈ@´¬âÞäùM€žÃM€žòP€ž¿c€žùMååO韵A<Ìy´K±8Žê”êÃMéžòPéž¿céžùMƒƒéOˆ±µŸµöÁÿ©D Ã—8Žê™‰þìòPÌŸ ¢õíØœ¼žŸ´¼4µö[jùÐ캠µßº º º ¿cº Äcº ¾º ¬ª³°ÞÛåâúõƒ­ª´°ßÛæâûõƒ®ªµ°º·àÛçâïîüõþˆƒˆƒÈøæŠƒõíº³øòæáóîÄ ¿ £
æ ÷
ú 
«ˆ
ÄŽ
²Ë¦îé± ªªóîØƒ»§øíû䳜Á¼¯òÅßüáî¨ ³ ¿ ¦
æ º
ê ®Ë­ÔËñé ¹±ÍÅ*°à
ž
§³

œ
¿ šË 
§
.·û惡¿§áËÿíƒ¡Æ¼Ž³òÉäáî¬ Ã û©
æ ¾
ê Ô
î ê
ó ü
ú 
°ˆ
ÒŽ
¹­×Ëô飼±ÑÅï劃éâ¢êâѳ ¿ £ìâÙ³ ¿ ¥DâñîÞ³üòÛ¼êá÷ŲÔËèÚúïÛ÷¾ Ö û ¿ ·
æ Ï
ê å
î ˆú ¦
¿ˆ
ÍŽ
èÝóíþø·ËÅ»àÔ÷ðªÈ­æËþ阮±áÅÿå§I wƒƒôæ±§×Ë»²ÚÔöæ´§ÚËÀ²ÝÔÐÜ·§ÝË ˆ 惦ȧê˲׼ÂòØó á¥ î» Ò ûµ
æ Ì
ê â
î ó
ó ú ¢
»ˆ
ÉŽ
¤Æ­äËüé¬À±ÞÅü僃¥Å§çË­Ò¼¾òÔîá¡ î· Í û²
æ È
ê Þ
î ¡Ã­áËùéÚÅøåê³§À
³Ÿ ¿ È
³Ð
³Ù
³¥ ¿ ¬ ¿ ˆ ˆ š ¿ ¸ 
¾ 
Ä 
Ê 
Ð ¿ Õ ¿ Û ¿ à ¿ £©Š ÓÛ*Ø *à³ÇL
ÊùM$;Ðìûµß¿c,F³tÌì 8Î*Œ"òP!ÃMçÙ¢šÄcÃLÐLé!#ö!é–úöø¶ûޗ̘œö ¾€€€€€€€€0x8080_8080_8080_8080Á´ö
 ¤ö 
ÀíÞ%üÖ7 È %”¯ É ËË·µÌʵ¼Îݵ¼VT~n¶êZ½ßz À Ç ÉüØï  â³äþ §´¾–³ ”³Ð6Ж³*2Ж³Éƒ”³0–³s@Ж³d 
ÈÊ&18<È Group::WIDTHÁd… 
ÈÏ&18<È Group::WIDTHÁê  íÞÔ€ T =½ßüÈ] Ë ¤ ü¦ Ж³ íÞ â³EŽ=½ßd 
ÈÑ&18<È Group::WIDTHÁ„÷ â ÿüÙ/ =½ßñ %„Þ â ü¾1 >½ßØ %l‰ 4‰  $’   ”‰  š 
¡ ?üÕL  ½ß :     Ê ”¾  Ï 
Ö @ü‡O  ½ß :ù ¤ST ñ!§S 
É"ÔS Œ $ 
"T† 
@.d† F  "íS   "ìS 
ù ÆS2 
ØJ®´
»À
àW# 
Ý øS  . ÷S 
l 4       ©    ® 
µ Aü¶
 ½ß ØÔ°­½ß®ÇÀ¿Gh$
$‰
´‘
„’
d
C ¡
4 1C/by ¥
 'Á ¦
ô‰
@" 6MSϵ


  
  
 Á
 K 
 Ç

ı
 â È
 Ü
Ý
Bü—Æ üþ _  ½ß¾  üü„ÇGþýü§\top7Ák˜DCOCü³ / ¼³ 
¬³ 
À*¬Í 
œÍ 
À*ev á ¼ñ
 ¬ñ ›È17¬¦
 œ¦
ÉÈ Ä
ü” ² C ë;´â 
¤â 
À-Üâ  ü üÆ 8u ~*Ìœ 
 ¼œ 
ÐÖÊ&üƒ 3v$• #4Ä;”Í;
 „Í;
Ë‚¬â'l<4<
#$‰<
È‚14‰< Ž<ü©<ì¬<t¬<4¬<
#,³<
É‚1<³< ¹<Wd½<Ès È<4Ü<tÜ<
 ,ã<óÍ0<ã< é<ÛWd=
È ©=üé;Ì ƒ ´= º=»=üœ;ŸüÀ;û ûâ$±;èØèØ éØ²‚êØŸ²‚ªë¥CHÈ5
 ¥ÐÏÌÌòÐÍòÐ]´¼~²œÈ-È4ÁÀ  ª\ÝÀ  ¬âü€Às ¬âöÜ”šÀŠŸŸ S¡ªS¢S£ÉSÚ™
¿kýƒ> òÀ ùÀ¦üÔ¿¥ÆœæS¤SžÚS f¥ð4,f™¬âöÜ$ñ¿öÜ; PhantomDataÁFu\»Ÿ¬â[¥+Š¾Ò¼ÇÃ

¬ÇÃ
¬â(ü¥Ã:«ûâ\¹Ã(,ŒÈ \§È  ¬âüÒÇk ¬âÞä”ìÇŠ¾Ò ¼È ÃȬü›Ç¨—ä$ÃÇÞä,¶ÇÞ䯜ԣ¤CŠ¾Ò¤ºà

”ºà
#ü¨à'оÒ$³à(üšäoüÊä0üÊä)ôÊä¬Êä 
œÊä
É59F 
½ß Þäm
t4àä
„t½ßDàä çä°
·Déä
á½ßÇTéä òäó
ú$ôä
½ß
4ôä ùäü³äH
 ´³ä
žU. úä ü¼ã¦ Ÿ ¤å Öå ºå áåèåü›ã;Ò$­ã§ ïíe¼îËè¿*8 8 ½ß9 ½ß: Ù:§´C§´LŒtrueÁfalseÁdûz|œ{
lœ{
¦-üèzN ³ììòìøìöÜ µ{¼{ü¬zÔ³³¸¼8¹æ­¼x¾spAììòìøìöÜ$ÙzøìdÅzøìÆœæS¤SžÚS f¥ð4,f™öÜL¼8eÛd ¼®’,¿’ 
$„®’
¬þì:L Ä’üú‘V ³ììòìøìþì Ï’ Ö’ü±‘¥Ü´ì$ë‘øìdÍ‘þì,Þ‘øìÆœæS¤SžÚS f¥ð4,f™þìAþìA¼8z¤|»ä®r4Ãr
"¤®r
Ô¬âþ;L Érü–r? ¿ ¬âþöÜ ÔrÛrüàq{Ü ¿ ¿ à ØGYÜ´•¬âþöÜ$‡rþ4ùq³³¸¼8¹æ­¼x¾spA¬âþöÜ9þ:šaÇü°‰&4ȉ ,Љ 2
9¼°‰
ܬâþ”êUFm Õ‰ ü˜‰I ¿ ¬âþ”ê à‰ç‰üÕˆã Í$‰‰þ4ñˆ”ê,üˆ¹‚ûþù”êíš0¤2q 
 
¦¬â,ü“2 ˬâöÜ Ä Ë Ñüî] ËËê”Î@]=½5K}¬âöÜ$„ ÁÓ´Q¼º& ,Ë& 
"„º& 
¬¬âÞä8I Ð& ü¢&: ˬâÞä Û& â& üò%p Öã$“& Þä,†& —äºÞ交MÌÃ
°±%ÏÝ18?ì¡
·¸%©Þ1ÏÝ9@¼Ø ÛÜ%íÞ1ç‘ç‘è‘ uint8x8_tÁ鑈 õݖ亭sz¬u âã$½ß07>DÙœ  õíãîÃô‹ó+§8 ¦§÷Q¨ˆ©ª”R«ˆÞ`ÿú¨?˜õíãîÃô‹óš²²ÜR¸§˜¹¡S˜ºæ˜£Ü,·s6úõíãîÃô‹óöý4Ο  õíãîÃô‹ó+ª8ÒïDËˬTѧ˜ÒïT˜Óæ˜Ñ!ÊSÂò+õíãîÃô‹ó §DñÉ Ú÷‡÷÷“÷™÷1ã>Úâã÷Qäˆåæ”Rçˆ/âÁܪŒ‹÷‡÷÷“÷™÷¦²²ÜR¸§˜¹¡S˜ºæ˜£Ü,·s6ú÷÷“÷™÷
4õÌ Ú÷‡÷÷“÷™÷1æ>˜óJïïÖV÷§˜øïT˜ùæ˜0ùòDï†Kð÷‡÷÷“÷™÷¬³Dªû ÝŽêøìþì'ã4Ýâã÷Qäˆåæ”Rçˆ_lÌÊח䨎êøìþìííÜRòŸ¡ .l³FmÞ.EŽêøìþìÒÙ4—þ ÝŽêøìþì'æ4èö@øø¬TýŸ¡ ÈÚœ]é ŽêøìþìDáÌ »Žê”ê#À0»¿À÷QÁˆÂÔRĈ@ÎÁ–âÎŽê”êŠÔÔÜRØ©µÙæµ6l À•7Žê”êÒÙ4çÒ »Žê”ê#Ã0àù<ðð¬Tô²µõÖµöæµI*¸íJ&Žê”êRS‘˜ ¡ µ íÞ
»¸”é
î<³¿ žê”ËŸüÉ+üLI This crate is a Rust port of Google's high-performance [SwissTable] hashÁüMOL map, adapted to make it a drop-in replacement for Rust's standard `HashMap`ÁÄ and `HashSet` types.ÁúüºJG The original C++ version of [SwissTable] can be found [here], and thisÁü…?< [CppCon talk] gives an overview of how the algorithm works.ÁÅúüÉ=: [SwissTable]: https://abseil.io/blog/20180927-swisstablesÁü‡c` [here]: https://github.com/abseil/abseil-cpp/blob/master/absl/container/internal/raw_hash_set.hÁüë>; [CppCon talk]: https://www.youtube.com/watch?v=ncHmEUmJZf4ÁRS˜ ¡ µ íÞ »¸î³¿ žê”
ËŸux{ôà
r œ74D K   è,  ƒ ½8+   ¦8â  ¥,   ¢, ˜8û$™& 8û$ £
¤ ¨ ·, ª « ´, ¬8itÁ­& ¯8÷
µ8$¿
Ä8 Ë ç, Õ Ö à, ×8it2ÁØ& Û8÷
á*ê í 8ú  ý ÿ ü  8__itemsÁ ¢ £% ¥, ³ ´ Ò  Ï ¸ Ã, ¹ º À, »8û$ Á
 ŠÍ, Æ Ç Ë, È8º„É
Ì$ Ð
Ó á ñ ã ä æ ï, ç è í, é8£…ê
î$ ò% ƒ ½ Ð8Ç+ Ê Ë á8âÌ Ï à, Ð Ñ Ý, Ò8i_metÁ& Ø8û$ Þ
ß ã ô, å æ ñ, ç8i_itÁ& ì8÷
ò, þ ÿ É8$8+   ¬8â š «,  œ ¨, 8e_metÁ& £8û$ ©
ª ® ¿, ° ± ¼, ²8e_itÁ& ·8÷$¸
½
Ê*Ò Õ 8ú  å ç Š  õ8„† Š %   ·  ©, ž Ÿ ¦,  8–‰$ §
¨ « µ, ¬ ­ ³, ®8î‰
´$ ¸, Æ Ç è É å Ë ×, Ì Í Ô, Î8…‹$ Õ
Ö Ù ã, Ú Û á, Ü8Ý‹
â$ æ
é ÷ ÿ ù ú ü ý$ %  Ó ð Ô8„† Ý ì, Þ ß ê, à8
á& ä8û$ é
ë% î*ò õ ö% ÷ ý É  þ8„†<ÿ  , ˆ  , Š8
& Ž8û$$ 
% ˜ š º œ ©,  ž ¦, Ÿ8¸  & ¡8û$ §
¨ « ¸, ¬ ­ , ®8º„¯& ±8÷
·$ », ½ ¾ Ç, ¿8restÁ& Ä8¯Å
È*Ë Î
8ú
  
 ¢
 Ü
 ¤
8__applyÁ
8â­
 °
 Ñ
8£±
 ´
 Ð
, µ

 º
, ·
8¸ ¸
$ ¹

»
8
½
 À
 Ï
8ºÁ
 Ä
 Î
, Å
 Æ
 Ë
, Ç
8
È
$ Ì

Í
$ Ò
, Ô
 Õ
 Ù
, Ö
8º„×

Ú
8ú  Ñ  Ó  þ  Õ 8„†  Þ  ð , ß  à  æ , á 8
â $ å 
ç , é  ê  î , ë 8¸ ì $ í 
ï % ò , ô  õ  û , ö 8¶“ 
ü %
 Î
 í

 Ï
8˜”
, Ø
8¸ Ù
& Ú
8û
$ ß
, á
 â
 ë
, ã
8º„ä
& æ
8÷

ì
*ï
 ò
 Ž, ü
 ý
 + þ
 ÿ
 , 8¸ , 8º„
ˆ% ¼Â»óœ«¬ªü¡  Ú  Ý è, Þ ß æ, à8¯á& ã8¯ä
ç*ê í ƒ, ÷ ø ü, ù8¯ú
ý  À LR г4]ª
г«
Œ
De  \DIK;=»óœÚ»ÆÔïüÙ1üÕ6üÌA,’ª«§<­ 
 èØ ¤  ˜  ”¢N|¾AC13"$Ô½ÎìÖÊü½²âžâžüâ@© ©ÖÊ¥ÐÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
§ ïíe¼îËè¿*
 î
ÖÊ´¼ü«>ª ªÖʭܥРÀ
Öʵ Ç´¼ü¨ öÜüå?« «öÜ¥ÐÑŸ ñ
´¼ü©=¬ ¬öܭܥР¾
$¿µ Å´¼¼ÐöÜ´¤„<‡öÜ
üÃ\­ ­¥ÐÑŸ ïÍìÒ¤ ÚÒ¤
Ò¤¤´¼,. 18°³<5°K°³±Kß³\b·Mß³¸MÄ·,zÛN2ô·âPô·ãPÁ\FQ\<°±·¸ó´Œ
Æ4Ý´t&
Å 5°´\6
Ã!6ô”C
Ä"7d
Y[FH35!#d“
ÏÝ$%&'()ü "
.\ñ
Œ„
ÏÝÏÝ##
$$
ü¦
'
\´
ÏÝ##
%
ü 3
ÏÝÛ¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙ##
&
üö
+
t„
ÏÝ##
'$“
ü½?
´À
ô ô õ ¨÷ ˆÐ  mjçítoé##
(nonzeroÁ<×
üÝ*

ÏÝ##
)
ìÌ
ÏÝ+,-ÈLÉLÊL-

**l‡

**©Þü·!

ÏÝ©Þ**
-
ìÕ
©Þ/0úMûM0

..üŸ#

® ®©Þ²©. §
.
0
L
,¼Ä·,‰
Û2󴌫
Æ4Ý´
Å5°´
Ã6ô”Û
Ä7œ
¼1Ú„þ
zLŸ
ln[]JL:<<ã×  `8:í ë8;$ $&D ½ß=>?@ABÜÙ  <<½ßì¾  <<½ßüÕ)  ½ß<<
?H:ü‡, T ½ß<<¢¿Í9ü¶2 „Ê ½ß<<
A
8ü—*  ½ß<<
B§ò5Ì” 8¼à
½ßEÀcEüþ
8  ¯°± ¯½ß ° c cˆ¢cµ
 `£cbufÁ `àB¤GS
±Ö¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
ŸÈŸÈ ÈErrorÁ O˜éBLD  D
E$† ± Œ äó \„ FFâžüóë FâžâžGHGHHGüÄ!  ² ²ÖʽßF Ð F
GÖÊ ²Û Ä™  ³ ³ÖÊF § F
HÖÊ üß, ½àJGJü   ´ ´½à½ßI ¬ I
J ²· ´&b $M¤YD ds# üM;  óöT… 4‰ î<  oty|}~ƒŸŒÎ惧Ëíõþƒø»| STß³\1·SVMß³¸SVMÄ·,>ÛSWN2ô·EâSXPÁ\JFSYQšrTpˆ S[£,| S\Õ6\ S^¨ S_û S`Ǹ&Sa
FusedIteratorÁl×òPSbªÓScªÓScíëSdµ žSe§Sfž‰fSg èØSihandle_alloc_errorÁ”ê œSjÀ Sl гªSm
г«Sm
Œ
 Sn ´t 

ãæÐÓÁÄŒ\¹ª­¢¥˜ˆÌËfÌêYL‰9L˜-”§!\¿  éëd¯ÞàÌΣ¥üç?S ¬âç¾¥ppÍì¬â ý
o¬âtoÁ÷ „êØársüà-ŒãSØáº qq
rü¯ 5SØá¥Ðº qq
s´¼üŸ œ¥ SttÍìÖÊ t‰Á‰ÁuvuvÌÆ  Stt´ƒ T‰ Sttüº !¥xxŠ¿ ¿ ¬â
Ìâ
å
S
y§
¹â{üÙ+Sµ µ¹âz æz
{üìNœïSûⲩ
|capÁƒ table_layoutÁdüø2Uüû2'Sûâ
}ŽÃd£3bucketsÁ<¾3üð57¼ó5S
~\‹6„÷:ûâÌœ;¥;Sû⥊¿ ©;‹Õ  üÏ=H¤Ò=SûâÛ¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙ¥Ð
$ç=âÃ<í=Ü…F4—F¥Š¿ žFÓã S~¡°Fb |žHžHSƒƒ§ ïíe¼îËè¿*¬âü I!¥Š¿ ¬IÓã
ÜÆI¥Š¿ ËIÓãŠÙмöI,ùI ÓãÓ㈠ÿIˆ
Ьâ$€JŒ¸J¥ŒŒŠ¿ ½JÓãŽ&(üÞZA|èZSÈÓã
¬âbaseÁ$øZÖ,Š[ü›t9l¥tS· ·ÓãÈ ³t
ެâ$´t¸Ê$ºtüâ‰%4ð‰¸ ¸Óã ¬â ÷‰
¬â$ø‰üƒ#\†S¹ ¹ÓãÈ 
¬â$“üÒœ.4ÜœSº ºÓãÓã ãœ
¬â$䜞
4êœüü£ $‘¤» »Óã –¤
¬â$—¤ü˜©%$­©¼ ¼Óã¬â ²©
¬â$³©ü›®),°®½ ½Óã¬â ¶®
¬â$·®¹½®ü´°/4ɰ¾ ¾Óã §¬â§ Ô°
¬â§$Õ°аüî´34ƒµ¿ ¿Óã §¬â§˜˜ ޵
¬â§$µеüýµ4D¥ššŠ¿ ˜¶ÍìÞ䬛¶ÞäLž¶—ä f¥ð4,f™œžßHJC ›¶öܤ¸¶,¸¶S¾ÒDÒ¶,Ò¶SÞä´·4·SœÔ¤À¸lǸS¾ÒÚ™
¿kýƒ> ¡¢£”й\йSŸŸŒËº$˺SŸŸ­Ü”³»\³»SŸŸd޼,޼SŸŸÜŸ¼¥¥¥Š¿ ¤¼ÁÓ¦§üÔ¿!è¿ÁÓ¤¤”éü‰Â4l—ÂÁÓ¤¤
§¬âŸ D¥ÂüúÂ$¥©ª©ªŠ¿ ÿÂÆÓ ‚ÃØÓL…×䫬­®¯°±²³´µ·¸º»½¿ÁÃÇÊÌÎÐÔÕÖÙÛÝÞßàçîö÷øùúûüýþÿ®°²´ü¥Ãd«ÃS¨¨ûâü›Ç,4¯ÇÞä—䨨ïê¤ÉAüùÉŒƒÊSÞäØáÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
—亠¨¨
­¬âÞä¤,žÊâÃ<°Ê fallibilityÁ\ÈÊüÎÎA„ÜÎÞä—䨨
®¬âÞäŸ DíΤ,þÎüˆÑ$L–ÑÀ À—ä ÀÞä¨  Ñ¨
¯¬âÞä$¡ÑüìÔ+DúÔÁ Á—äȨ ƒÕ¨
°¬âÞä$„Õüáâ-|ïâÂ Â—ä¨ ÿâ¨
±¬âÞä$€ãüŽåEd£åÃÄ Ã—ä ÄÓ㨠°å¨
²¬âÞä$±å©4·åü ï=4µïÅ Å—äÓ㨠¼ï¨
³¬âÞä$½ïÖ,Ãïü¯4SÆÇ Æ—ä ÇÓ㨠Ǩ
´¬âÞä÷ü6,–„È È—äÓ㨠œ„¨
µ¬âÞä$¡„÷$§„üˇE4à‡É É—äÓã¬â¨ 燨
¬âÞä$ì‡÷$ò‡üž‹Ql³‹Ê Ê—äÓã¬â½ß¨ Á‹¨
·¬âÞä$Æ‹÷$Ì‹ü¸ŽYdÆŽË Ë—äÛ¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡z٬⨹¹ ÓŽ¨Íì¯å´íŽÌ“"¯å ̬âŒòŽÌ¯åÄæ˜"$ÿŽ
¸¬âÞä¯å$ØŽ§$ÞŽéŽqsüà‘&lî‘Í Í—ä¨ ü‘¨
º¬âÞä$ô¹“,Ç“Î Î—ä¨ Í“¨
»¬âÞä$Ò“<Е»<closure_kind>Á¼<closure_signature>Á¼<upvars>Á¼¼»¼¬âÞä  —äü˜™OL¦™Ï Ï—äæ¨æ¾¾ °™¨ÍìÑê”Ô™Ð"Ñê ЬâlÙ™ÐÑê ë˜"ã™
½¬âÞäÑê$µ™min_sizeÁD»™š4Ì™z|üͱO<Û±Ñ Ñ—äÑê¨æÀÀ 㱨þꔉ²Ò"Ñê Ò¬âl޲ÒÑêí˜"˜²
¿¬âÞäÑê$è±
additionalÁT4²|~üÜ·\ê·Ó Ó—äÑêÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
º ¨æÂ ÿ·¨þꔵ¸Ô"Ñê Ô¬âlº¸ÔÑêÕï˜"ĸ
Á¬âÞäÑê$„¸ÜìT’¸š4­¸suüï¾²tù¾SÕ Õ—äÑêØáÂî¨æÄÄ ‘¿¨þê”Ç¿Ö"Ñê Ö¬âlÌ¿ÖÑêÁñ˜"Ö¿
ìâÞäÑê$–¿ÜìT¤¿š4¿¿„Û\ã¿}tÞÄÔèÅ­èÅËèÅÅÃŬâÞäÑê ¾Ò Ñê,•ÆÃ”èÆ­èÆËèÆÆÃÆ¬âÞäÑêãÜüÁΨ4ËÎS× ×—äÑêØáÂî¨æÈÈ ÛΨþêÏØ"Ñê Ø¬âl”ÏØÑê®õ˜"žÏ
ǬâÞäÑê$àΟ DîΚ4‡Ï„Û\«Ï|~téÓÇ”èÉ­èÉËèÉÉÇɬâÞäÑê˜ó±óüØÖ]4æÖÙ Ù—ä¬âÑêÓã¨æËË íÖ¨þꔕ×Ú"Ñê Ú¬âlš×ÚÑêŽø˜"¤×
ʬâÞäÑê$òÖ§$øÖ»,ƒ×š4×{}üÒâdàâÛ Û—ä¬âÑê Û¬â¨æÍÍ öâ¨þê”¶ãÜ"Ñê ܬâl»ãÜÑêŽú˜"Åã
̬âÞäÑê$ûâ§$‰ã»,œãš4®ã{}üãíœøíÝ Ý—äÓ㙉ۼݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zٽߨÏÏ î¨Í왉 Œî–"™‰¬â´×Ëü˜"´åLäî
άâÞ䙉$”î©4šî± ­î_aü±ö¼Ì¿öÞ Þ—ä¯åæÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
Óã¨ÑæÒÑÒ âö¨¢æ´÷Íìäý”¸÷ß“"¯å ߬⌕÷߯åÿ˜"$¢÷à"äý à¬âl½÷àäýÞÿ˜"Ç÷
ЬâÞä¯åäý$çö§$õöŒ÷š4°÷ÒÔÍÏ<ñýДèÓ­èÓËèÓÓÐÓ¬âÞä¯åäý ¯å —äü®‚|Âá á—ä¬âÓ㨠܂¨
Ô¬âÞä$á‚§$ï‚Ö,‚ƒ»,˜ƒüᆌ´ö†â â—ä½ß¬âÓ㨠–‡¨
Õ¬âÞä$›‡²©‡Ö,»‡»,чü¬ŠY$ºŠã ã—ä¯åÛ¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙÓã¨×× ¿Š¨¢æ´ÙŠä“"¯å ä¬âŒÞŠä¯å´…˜"$ëŠ
Ö¬âÞä¯å$ÀЧ$ÆŠÕŠqsÖ”èØ­èØËèØØÖØ¬âÞä¯åÈÔü¢’M°’å å—ä¯åÛ¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙ å¬â¨ÚÚ ´’¨¢æ´Ê’æ“"¯å æ¬âŒÏ’æ¯åÓˆ˜"$Ü’
Ù¬âÞä¯å$µ’§$»’Æ’qsüˆ•Y<–•ç ç—ä¯åÛ¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙ ç¬â¨ÜÜ ž•¨¢æ´¸•è“"¯å è¬âŒ½•è¯åˆ‹˜"$Ê•
Û¬âÞä¯å$£•§$©•´•qsüŒ˜;Tš˜é é—äÛ¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙ é¬â¨ ¥˜¨
ݬâÞä$¦˜Ö,¬˜ü‰›Gt—›ê 
{L‰Ž
S®åªÈõìòóòóìÍìª “Ž
ÍìÈõ –Ž
“"ªÈõÓãÄáŽ
ª²ö˜"Èõ øŽ

ñ¬âªÈõ$Ž
¹ §Ž
accÁµŽ
± ÁŽ
{}ü¯¥
'¥õõŠ¿ »¥
®å  üÚ¥
'¥÷÷Š¿ æ¥
®å  ü†¦
!¥ùùŠ¿ ‹¦
®åúÙú¼ß¦
,â¦
» »®å®åø è¦
ø
ú¬â$é¦
ü¹¨
$¥üüŠ¿ ¾¨
®åýþúMûMÿMþ&(Lä¨
$é¨
ûûÓãü±©
'$´©
¼ ¼®å­„û ¹©
û
þ¬â$¾©
$½ª
üèª
-Lëª
½ ½®å²©û õª
û
¬â$öª
üš®
)¥Š¿ Ÿ®
®å  ää´
<ö´
¥Š¿ þ´
³æCHMr[t<!#ü‡µ
$’µ
ƒƒ®åd­µ
,­µ
Sƒƒ”¾µ
¥ˆˆŠ¿ õ
³æ ü×µ
"láµ
S¾ ¾³æ ïµ

¬â$ôµ
ä¶·
¥Š¿ »·
³æŒÙŒ¼Š¸
,¸
¿ ¿³æ³æŠ “¸
Š
Œ¬â$”¸
ô‰¹
¥ŽŽŠ¿ ޹
³æ´¤ß¹
<â¹
³æ
¬âüùº
¥Š¿ þº
³æúMûMÿMóN13LŸ»
$¤»
Óãüì»
'$ï»
À À³æ­„ ô»

¬â$ù»
,ܾ
üÖ¿
-LÙ¿
Á Á³æÓû ã¿

¬â$ä¿
üÆÀ
l$ÉÀ
³æ™‰ûƒ˜˜Íìûƒ ÎÀ
®ü ÑÀ
Íì³æ,†Á
“"™‰ûƒ³æúM̘Á
™‰î„˜"ûƒ °Á

¬âûƒ™‰$ÔÀ
initÁ$ÚÀ
± ãÀ
ˆŠŒŽüþÁ
(¥ššŠ¿ ƒÂ
³æ  üªÂ
$¥œœŠ¿ ¯Â
³æ  üãÌ
#¢çž´ž¤¾Í
<ÁÍ
¢ç
ž¼èÎ
¢ç ü¡Ó
/L«Ó
S ¢粩Ÿ µÓ
Ÿ
 $ºÓ
üÖä
$¢ç¢£¤úMûMÿM¤£Lå
$†å
¡¡ü‚ç
#$…ç
à â粩¡ Šç
¡
£$ç
üÝê
-Làê
Ä Ä¢çÓû¡ êê
¡
¤$ëê
ü½ë
-¢çüîë
)¢çüÖì
7\èì
¥¨©©¨Š¿ ôì
ÆÓ¬÷ì
ØÓLúì
¦è|ZnBiF”]ª«¬º8:< ÷ì
öÜ„”í
$Ӓ
S§§³æüªí
,Tªí
S§§úª´Üí
4Üí
S§§œÔü÷í
'¥®¯®¯Š¿ üí
ÆÓ ÿí
ØÓL‚î
¦è° "$üÖî
'$äî
Å Å¦è³æ­ éî
­
°¬âÞä$êî
ü£ï
W¥²³²³Š¿ ¯ï
ÆÓ ²ï
ØÓLµï
º¬$èï
̬$õï
¦è-/13üÿï
W¥µµŠ¿ ‹ð
ÆÓ Žð
ØÓL‘ð
Å­$Äð
Ö­$Ñð
¦è-/13üÂô
0»óœ«ô
¬ªô
ü¡ô
¥¸¹¸¹Š¿ Çô
ÆÓ Êô
ØÓLÍô
¦èº"º&(*,”ªõ
$­õ
Æ Æ¦è· ²õ
·
º¬âÞä$·õ
ü×÷
3¥¼½¼½Š¿ Ü÷
ÆÓ ß÷
ØÓLâ÷
¦è¾´¾&(*,¤‘ø
<”ø
¦è»»
¾¬âÞäü®ù
4¥ÀÁÁÀŠ¿ ³ù
ÆÓ ¶ù
ØÓL¹ù
¦èÂÃÄúMûMÿMÄÃ8:<>Léù
$îù
¿¿¬âü®ú
$±ú
Ç Ç¦è´å¿ ¶ú
¿
ìâÞä$»ú
ü›û
-Lžû
È È¦èÓû¿ ¨û
¿
ĬâÞä$©û
üòû
=¥ÆÇÇÆŠ¿ ÷û
ÆÓ úû
ØÓLýû
¦è!ü³ü
9¥ÉÊÉÊŠ¿ ¸ü
ÆÓ »ü
ØÓL¾ü
¦è!ü¹ý
8DËý
§Ì¥ÍÎÎÍÌÍìŽê Øý
Íì”ê¬Ûý
”êLÞý
Žê§üè€ '”ê§ËË’2ÏùSÐæSÑÊ2SÒÚSNìK
åM6§Žê”êNìK
åM6ÏÐÑÒàÔý
ÇÉÂ Ûý
öÜ„øý
$øý
SË˃ƒ†.ùÉSCHMr[t<Žê¤Ãÿ
,Ãÿ
SË˾ÒüÝÿ
"TÝÿ
SË˧ ïíe¼îËè¿*¾Òs4è€ SË˪ÓFu\»Ÿ §ÆœæS¤SžÚS f¥ð4,f™Žê”êü” (8É¥ÔÕÔÕÉ•˜ §˜ œ ¹˜ »éÖ "$üô '$‚‚ Ê Ê»é¢šÓ ‡‚ Ó
Ö8Žê”ê$ˆ‚ üÁ‚ X8Ë¥ØÙÙËØ•˜ Í‚ §˜ Ђ ¹˜LÓ‚ ÌìŽê$‡ƒ Ìì”ê$”ƒ »é?ACEüžƒ X8Ì¥ÛÜÌÛÜ•˜ ªƒ §˜ ­ƒ ¹˜L°ƒ  Žê$äƒ  ”ê$ñƒ »é=?ACüüƒ 18Í¥ÞßßÍÞ•˜ §˜ „„ ¹˜L‡„ »éà"à&(*,”å„ $è„ Î Î»éÝ í„ Ý
à8Žê”ê$ò„ üÞˆ 58Ï¥âãÏã╘ ㈠§˜ æˆ ¹˜Léˆ »éäåæúMûMÿMåæ8:<>Lš‰ $Ÿ‰ ááŽêü߉ $≠РлéÛ¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙŽêá ç‰ á
å8Žê”ê$ì‰ üýŠ -L€‹ Ñ Ñ»éÓûá Š‹ á
æ8Žê”ê$‹‹ üÔ‹ >8Ò¥èéèéÒ•˜ Ù‹ §˜ Ü‹ ¹˜Lß‹ »é!ü–Œ :8Ó¥ëìëìÓ•˜ ›Œ §˜ žŒ ¹˜L¡Œ »é!üý“ \ ¥î ›” Åëå#q³
–¨ïð!#̤” ,¤” SííØê¼Ã” <Ô SííœÔ´€™ ¥òòŠ¿ …™ Åëó üΙ FØ™ SÔ Ô—äÅëñôô ñ™ ñÆÓ Ü™ ØÓLß™ 
ó¬âÞäæ,ê™ §$‚š -/ü­› ¥ööŠ¿ ²› Åë÷Ù÷¼…œ ,ˆœ Õ ÕÅëÅëõ Žœ õ
÷¬â$œ üŠ "¥ùùŠ¿ Åëú´ú¤ä  Åëøø
ú¬âüñž #Øêü´ü¤ÌŸ <ÏŸ Øêûû
ü¼ü  ØêþüË¡ 7Õ¡ SÖ Ö¾ÒØêý à¡ ý
þæ,Ù¡ §$ð¡ ü°¥ #¥Š¿ µ¥ ÅëúMûMLÚ¥ $ߥ ÿÿÓãüö¥ '$ù¥ × ×Åë­„ÿ þ¥ ÿ
¬â$ƒ¦ üª $ØêúMûMLºª $¿ª ƒƒüÒª ($Õª Ø ØØêÛ¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙØêúMƒ Úª ƒ
$ߪ üв 3dœ² §¥ˆˆ•˜ ­² §˜ °² ¹˜L³² ɘüÞ² !Ú˜
Ò5ŠùæÑ¶'–¤Fr§Žê”êѶ'–¤FrŠ©² ˆŠŒޤIJ $Ȳ ¢š£,â²  §‹œü„³ ,8Ù¥ŽŽÙ•˜ ‰³ §˜ Œ³ ¹˜L³ Ò5ŠùæÑ¶'–¤Fr8Žê”ê[]_aüè³ c$ö³ Û Ûе…󯤌 þ³ ŒÍì…ó û³ Ú“"…ó ڎꬵ´ Ú…óð¶˜"$Æ´ 
8Žê”ê…ó$ƒ´ ± ´ mo »óœª¬©ü  
ü¡%»óœø¬÷üî 
­ üÍ'»óœ¤¬£üš 
­ äüÄ3åÌ¥Š¿ Þ
¬âaddrÁ$áÄ¥ ¤© <¿ à ³ÁÇÍò¼áîû ²ËÚïâ
À L˜š г4ª˜
г«˜
Ù48ƒ˜’2D@˘žÒ5dJ˜Ÿÿ/\X§˜ †.<eƒ˜¡ÆDn˜¢»¸”…æT™ ˜¥ø»˜¦Y4É ˜§× `˜©p,ç¿c˜ªpÂc˜ª\\€Åe˜¬Ž$še˜­Ž e˜­ºòP˜®ªÓ˜¯ªÓ˜¯íÜ똰IndexÁ,ðÙ¢˜±ToOwnedÁ<²˜²d"T+çêÙÜËνÀ¯²¡¤,}˜ru¤»hZÛMP03!$̘Ì·òLÖÍ„å¹Ìû¢ü»2GüÓB? A hash map implemented with quadratic probing and SIMD lookup.ÁúüšKH The default hashing algorithm is currently [`foldhash`], though this isÁüæLI subject to change at any point in the future. This hash function is veryÁü³OL fast for all types of keys, but this algorithm will typically *not* protectÁüƒ$! against attacks such as HashDoS.Á¨úü¬LI The hashing algorithm can be replaced on a per-`HashMap` basis using theÁüùPM [`default`], [`with_hasher`], and [`with_capacity_and_hasher`] methods. ManyÁüÊQN alternative algorithms are available on crates.io, such as the [`fnv`] crate.Áœúü SP It is required that the keys implement the [`Eq`] and [`Hash`] traits, althoughÁüôNK this can frequently be achieved by using `#[derive(PartialEq, Eq, Hash)]`.Áüà GD If you implement these yourself, it is important that the followingÁœ‹
 property holds:ÁŸ
ú
 ```textÁü¯
$! k1 == k2 -> hash(k1) == hash(k2)Á
 ```ÁÜ
úüà
FC In other words, if two keys are equal, their hashes must be equal.Á§ úü« MJ It is a logic error for a key to be modified in such a way that the key'sÁüù PM hash, as determined by the [`Hash`] trait, or its equality, as determined byÁüÊ KH the [`Eq`] trait, changes while it is in the map. This is normally onlyÁü–
NK possible through [`Cell`], [`RefCell`], global state, I/O, or unsafe code.Áå
úüé
OL It is also a logic error for the [`Hash`] implementation of a key to panic.Áü¹NK This is generally only possible if the trait is implemented manually. If aÁüˆPM panic does occur then the contents of the `HashMap` may become corrupted andÁüÙ-* some items may be dropped from the table.Áút # ExamplesÁšúâÇܦ use hashbrown::HashMap;ÁÂúüÆDA // Type inference lets us omit an explicit type signature (whichÁü‹;8 // would be `HashMap<String, String>` in this example).ÁüÇ*' let mut book_reviews = HashMap::new();ÁòúÌö // Review some books.ÁÄ book_reviews.insert(Áü©52 "Adventures of Huckleberry Finn".to_string(),Áüß(% "My favorite book.".to_string(),Á4ˆ );ÁÄçÐü¨*' "Grimms' Fairy Tales".to_string(),ÁüÓ# "Masterpiece.".to_string(),ÁùÑÄþçÐü—*' "Pride and Prejudice".to_string(),ÁüÂ&# "Very enjoyable.".to_string(),ÁùÑÄðçÐü‰85 "The Adventures of Sherlock Holmes".to_string(),ÁüÂ)& "Eye lyked it alot.".to_string(),ÁùÑóúü÷  // Check for a specific one.Áü˜FC // When collections store owned values (String), they can still beÁüß'$ // queried using references (&str).Áü‡63 if !book_reviews.contains_key("Les Misérables") {Áü¾HE println!("We've got {} reviews, but Les Misérables ain't one.",Áü‡%" book_reviews.len());Á,­³úü·IF // oops, this review has a lot of spelling mistakes, let's delete it.Áü=: book_reviews.remove("The Adventures of Sherlock Holmes");Á¿úüÃ41 // Look up the values associated with some keys.ÁüøMJ let to_find = ["Pride and Prejudice", "Alice's Adventure in Wonderland"];ÁÜÆ for &book in &to_find {Áüâ&# match book_reviews.get(book) {Áü‰=: Some(review) => println!("{}: {}", book, review),ÁüÇ74 None => println!("{} is unreviewed.", book)ÁLÿ,‰ˆØúü“HE // Look up the value for a key (will panic if the key is not found).ÁüÜIF println!("Review for Jane: {}", book_reviews["Pride and Prejudice"]);Á¦úüª // Iterate over everything.ÁüÊ)& for (book, review) in &book_reviews {Áüô-* println!("{}: \"{}\"", book, review);ÁˆØâǰúü´KH `HashMap` also implements an [`Entry API`](#method.entry), which allowsÁü€PM for more complex methods of getting, setting, updating and removing keys andÁŒÑ their values:ÁãúâÇÜïÂÎúü DA // type inference lets us omit an explicit type signature (whichÁüÔ 52 // would be `HashMap<&str, u8>` in this example).ÁüŠ!*' let mut player_stats = HashMap::new();Áµ!úü¹!! fn random_stat_buff() -> u8 {ÁüÛ!KH // could actually return some random value here - let's just returnÁü§"# // some fixed value for nowÁTË" 42Á,Ö"ˆØÜ"úüà"41 // insert a key only if it doesn't already existÁü•#0- player_stats.entry("health").or_insert(100);ÁÆ#úüÊ#IF // insert a key using a function that provides a new value only if itÁä”$ // doesn't already existÁü±$C@ player_stats.entry("defence").or_insert_with(random_stat_buff);Áõ$úüù$DA // update a key, guarding against the key possibly n
*v = "b";Áüè×@= assert_eq!(map.get_key_value_mut(&1), Some((&1, &mut "b")));Áü­Ø0- assert_eq!(map.get_key_value_mut(&2), None);Á<âØâÇŒƒÙ ´ì ˽Û¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙ ìì òìï¢ ˜Ùïä¾ •Ùö¾$×Ù‡¿lÞÙ
ììòìøìþì˽$Ù £ÙACü³á`üˆÝEB Returns `true` if the map contains a value for the specified key.ÁÒÝúüÚÝ?Å¿üžÞCÀŒæÞÜÀüÞút„ߒΗßú<ŸßâÇÜ«ßÂÎËßúüÓß!î²¼ùß×Áü•à+( assert_eq!(map.contains_key(&1), true);ÁüÅà,) assert_eq!(map.contains_key(&2), false);Á<öàâÇdºáƒ ´ì ƒ˽ï¢ Êáïä¾ Çáö¾$õᇿlüá
ƒììòìøìþì˽$Ëá ÑáACüßèiüôãFC Returns a mutable reference to the value corresponding to the key.Á¿äúüÇä?Å¿ü‹åCÀŒÓåÜÀéåútñå’΄æú<ŒæâÇܘæÂθæúüÀæ!î²¼ææ×Áü‚ç&# if let Some(x) = map.get_mut(&1) {ÁŒ­ç *x = "b";Á,ÃçˆØìÍç assert_eq!(map[&1], "b");Áïçúü÷ç&# assert_eq!(map.get_mut(&2), None);Á<¢èâÇ<æè ´ì ˽Û¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙ òìï¢ ñèïä¾ îèö¾$ªé‡¿l±é
ììòìøìþì˽$öè üèACüÚûüÆìHE Attempts to get mutable references to `N` values in the map at once.Á“íúü›í]Z Returns an array of length `N` with the results of each query. For soundness, at most oneÁüýí_\ mutable reference will be returned to any value. `None` will be used if the key is missing.Ááîúdéúîúü‚ï'$ Panics if any keys are overlapping.Á®ïút¶ï’ÎÉïú<ÑïâÇÜÝïÂÎýïúü…ð'$ let mut libraries = HashMap::new();Áü±ð;8 libraries.insert("Bodleian Library".to_string(), 1602);Áüñð41 libraries.insert("Athenæum".to_string(), 1807);ÁüªñJG libraries.insert("Herzogin-Anna-Amalia-Bibliothek".to_string(), 1691);Áüùñ>; libraries.insert("Library of Congress".to_string(), 1800);Á¼òúüÄò)& // Get Athenæum and Bodleian LibraryÁüòò96 let [Some(a), Some(b)] = libraries.get_disjoint_mut([Á¤°ó "Athenæum",ÁÜÉó "Bodleian Library",ÁÌéó ]) else { panic!() };Á‡ôúüô96 // Assert values of Athenæum and Library of CongressÁüÍô*' let got = libraries.get_disjoint_mut([Á¤üôŠãô•õ "Library of Congress",Á<¸õ ]);Á|Äõ assert_eq!(ÁdØõ got,ÁLéõä÷õ Some(&mut 1807),Áä˜ö Some(&mut 1800),ÁT¹ö ],Á4ÈöùÑÓöúüÛö" // Missing keys result in NoneÁü‚÷*Â䤱÷ŠãüÊ÷" "New York Public Library",Á<ñ÷¬å|ý÷½åd‘øÖåL¢øìåä°øÿå„Ñø
NoneÁLæø4ôøùÑ<ÿøâÇ‹ùúœ“ù ```should_panicÁÜ«ùÂÎËùúüÓù'±ßüÿù4©à¸úúäÀú // Duplicate keys panic!Áüáú*Âä¤ûŠã¤©ûŠã<Âû¬å<ÎûâÇ„áû ´ì ˽ŸÛ¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙ òìŸï¢ˆŸˆ …üïä¾ òûŸtõûö¾$Ìü‡¿lÓü
ììòìøìþì˽Ÿ$ŠüksÁüXZV ûû,ªý”茭èŒË茌Œ ììòì
,Ž„t—…Ö”è×­è×Ëè××Ö×ììòìøìþìÞ• òì ´ìÁ…Ö”èØ­èØËèØØÖØììòìøìþì“ìíüÝ…tœÚ§Û¤ÜÝÛÝÜÚ Òù â…ãù å…ôù è……ú ë…Û‘–†ì‘$›†ò쨆á€\³†–úLdž´ìY[]_acegü׆bœß§à¤áâáßâàÒù ܆ãù ߆ôù ↅú 冿cìì,“‡¿còì,¡‡–úL¯‡´ìãÀcãZ\^`bdfhüÀ‡8Ǧ§¨ ¦´ì § c cˆ¢cµ
 `£cå² `àB¤GS
¨Œ´Þ LJÞ
ãììòìøìþì$ȇ± ·ü¸ˆbœå§æ¤çèèæçåÒù ½ˆãù Àˆôù È…ú ƈ³øì<öˆ³þì<†‰–úL´ìé´éZ\^`bdfh¤žŽü¡‰b_ Creates an empty `HashMap<K, V, S, A>`, with the `Default` value for the hasher and allocator.ÁˆŠútŠ’Î£Šú<«ŠâÇÜ·ŠÂÎü׊ use std::hash::RandomState;ÁûŠúüƒ‹LI // You can specify all types of HashMap, including hasher and allocator.ÁüÔ‹52 // Created map is empty and don't allocate memoryÁüŽŒ74 let map: HashMap<u32, String> = Default::default();ÁüÊŒ"””üñŒDA let map: HashMap<u32, String, RandomState> = HashMap::default();Áüº"””âÇ<¡Ž´ìää
éììòìøìþìüƒ8©œë¢ì§í¤îïìîïí©ë ¶… ˆÎì’î Íìûí ŽÍìî Íì‡î õíÆšeõíše’î ’îõíÅeî‡îL’½íðñۢܢñÎÐÉËÄÆ¿Áº¼êêûíôü¹GD Returns a reference to the value corresponding to the supplied key.Á…‘údƒ”ž‘úü¦‘63 Panics if the key is not present in the `HashMap`.Áá‘úté‘’Îü‘ú<„’âÇÜÂΰ’úü¸’A> let map: HashMap<_, _> = [("a", "One"), ("b", "Two")].into();Áþ’úü†“! assert_eq!(map[&"a"], "One");Áü¬“! assert_eq!(map[&"b"], "Two");Á<Ò“âÇ,’”ª« ª½í «’î ªûíê ˜”ê
ñ8õí’îûíî‡î$™”ïTŸ”ÌíŸü§™C@ An iterator over the entries of a `HashMap` in arbitrary order.Áüë™2Çžšúü¢šKH This `struct` is created by the [`iter`] method on [`HashMap`]. See itsÁÜîš documentation for more.ÁŠ›úÜŽ› [`iter`]: HashMap::iterÁª›út®›’ν›ú<Á›âÇÜÉ›ÂÎå›úüé›C@ let map: HashMap<_, _> = [(1, "a"), (2, "b"), (3, "c")].into();Á­œúô±œ let mut iter = map.iter();ÁüМ>; let mut vec = vec![iter.next(), iter.next(), iter.next()];Áúü“DäÊüØ@³ËÄ™ž‚·ü²žLI assert_eq!(vec, [Some((&1, &"a")), Some((&2, &"b")), Some((&3, &"c"))]);Áÿžú܃Ÿ // It is fused iteratorÁüŸŸ" assert_eq!(iter.next(), None);ÁüŸ"–† <åŸâÇ$øŸ§óœô§õõóô¶…  Ç… „ õí§ü© #ãî§êù¶¨7g|°ßö÷ýŸOQSU´ , ˜òòƒƒ†.ùÉSCHMr[t<Û€¦4© ˜òòªÓFu\»Ÿ³€üˆ¡#8¬œù§ú¬ùú¶… ¡Ç… ¡ îûÙû!#¼ã¡,æ¡­ ­ î îø ì¡ø
û8õíãî$í¡üç¢68®œý§þ®þý¶… ì¢Ç… ö¢¿cõí,cãî,ù¢ îÿÀcÿ?ACEü¤£8§£¯°± ¯ î ° c cˆ¢cµ
 `£cå² `àB¤GS
±Œ´ü «£ü
ÿ8õíãî$¬£± ²£äâªüž¤JG A mutable iterator over the entries of a `HashMap` in arbitrary order.Áüé¤6ªÏ ¥úü¤¥OL This `struct` is created by the [`iter_mut`] method on [`HashMap`]. See itsÁÜô¥ß ¦úü”¦# [`iter_mut`]: HashMap::iter_mutÁ¸¦út¼¦’Î˦ú<ϦâÇÜצÂÎó¦úü÷¦SP let mut map: HashMap<_, _> = [(1, "One".to_owned()), (2, "Two".into())].into();Á˧úüϧ" let mut iter = map.iter_mut();Áüò§96 iter.next().map(|(_, v)| v.push_str(" Mississippi"));Áü¬¨9ä‘ æ¨úÜê¨ð… ü†©"–† ü©©"–† Ì©úüЩDA assert_eq!(map.get(&1).unwrap(), &"One Mississippi".to_owned());Áü•ªDA assert_eq!(map.get(&2).unwrap(), &"Two Mississippi".to_owned());Á<ÚªâÇ<íª§œ§ƒƒ¶… ùªÇ… üª¥ˆ üÏ«'¶ˆ 
Úú£1ñ)åªxõªACEG´…«,…«˜š‰ g4Ï«˜ªÓFu\»Ÿµ€ §ãîü³­88²œ§ˆˆ²¶… ¿­Ç… È­Ììõí$­Ììãî$Ë­üî68:<äð­8³œŠ§³Š¶… õ­Ç… ø­üîŒü‡¯+$•¯´ ´üîòòíFöŸ˜÷Ú˜¶¨7g|°ß´õíãî š¯
Œ8õíãî$›¯üÕ·0üŸ°JG An owning iterator over the entries of a `HashMap` in arbitrary order.Áüê°*' The iterator element type is `(K, V)`.Á•±úü™±GD This `struct` is created by the [`into_iter`] method on [`HashMap`]Áüá±MJ (provided by the [`IntoIterator`] trait). See its documentation for more.Áü¯²52 The map cannot be used after calling that method.Áå²úüé²%" [`into_iter`]: HashMap::into_iterÁ³út“³’΢³ú<¦³âÇÜ®³ÂÎʳúüγCˆƒ ’´úü–´# let mut iter = map.into_iter();Áüº´>‹„ ù´úüý´HE // The `IntoIter` iterator produces items in arbitrary order, so theÁüƵ@³Ëć¶‚·ü ¶FC assert_eq!(vec, [Some((1, "a")), Some((2, "b")), Some((3, "c"))]);Áç¶úÜë¶ð… ü‡·"–† üª·"–† <Í·âÇDà·œŽ§ŽÒù é·ãù ì·§˜¬ï·¹˜Lò·Êû¥K@¬žú‚Ä:<>@B ï·öÜ쌸,Œ¸˜§§ÿ/ªùS«ª0S¬ÚS|ZnBiF”]”êü®¸*œ§Òù ³¸ãù ¶¸§˜ ¹¸¹˜L¼¸Êû')+-/1üÓ¹+$á¹µ µÊûòòíFöŸ˜÷Ú˜¶¨7g|°ßµììòì æ¹
ììòì”ê$ç¹üØÁ0üêºGD An owning iterator over the keys of a `HashMap` in arbitrary order.Áü²»%ò…Ø»úüÜ»HE This `struct` is created by the [`into_keys`] method on [`HashMap`].Áü¥¼# See its documentation for more.Áüɼ5¦œ ÿ¼úüƒ½%" [`into_keys`]: HashMap::into_keysÁ©½út­½’μ½ú<À½âÇÜȽÂÎä½úüè½Cˆƒ ¬¾úü°¾# let mut keys = map.into_keys();ÁüÔ¾>; let mut vec = vec![keys.next(), keys.next(), keys.next()];Á“¿úü—¿Gˆˆüß¿?¹¶ÄŸÀ‚·ü¸À1. assert_eq!(vec, [Some(1), Some(2), Some(3)]);ÁêÀúÜîÀð… üŠÁ" assert_eq!(keys.next(), None);Áü­Á"èª <ÐÁâÇDãÁœ˜§š˜šÒù ìÁãù ïÁ§˜¬òÁ¹˜LõÁÊïžÂw]ûÃ:<>@B òÁöÜÄÂ,˜Êûü¬Â6œ§žŸŸžÒù ±Âãù ´Â§˜ ·Â¹˜LºÂÊï ´ /13579¤šÃ<ÃÊ
 ììòì”êüùÃ7œ¢§£¤¤¢£Òù þÃãù ħ˜ „Ĺ˜L‡ÄÊ復¨©úMûMÿMóN¨¦©LNPRTVL·Ä$¼Ä¡¡ììüÙÄ$ÜÄ ÊïÛ¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙìì¡ áÄ¡
¦ììòì”ê$æÄD™Å¦”è§­è§Ëè§§¦§ììòì”êììü½Å-LÀÅ· ·ÊïÓû¡ ÊÅ¡
¨ììòì”ê$ËÅü¤Æp$§ÆÊïºïÒ´ ¡ª««ª¡ÍìÒ´ ¬Æçï ¯ÆÍìÊï,èÆ“"ºïÒ´ ÊïúMÌúƺïŵ ˜"Ò´ ’Ç
©ìì
 `£cå² `àB¤GS
»Œ´ Ê
ºììòì”ê$‚ʱ ˆÊD÷ʺ”è»­è»Ëè»»º»ììòì”êŒìÞ•ü¯Ò2ü£ËIF An owning iterator over the values of a `HashMap` in arbitrary order.ÁüíË%‰‹“Ìúü—ÌJG This `struct` is created by the [`into_values`] method on [`HashMap`].ÁüâÌUR See its documentation for more. The map cannot be used after calling that method.Á¸Íúü¼Í)& [`into_values`]: HashMap::into_valuesÁæÍútêÍ’ÎùÍú<ýÍâÇÜ…ÎÂΡÎúü¥ÎCˆƒ éÎúüíÎ'$ let mut values = map.into_values();Áü•ÏDA let mut vec = vec![values.next(), values.next(), values.next()];ÁÚÏúüÞÏG ü¦ÐEòÄìЂ·ü…Ñ74 assert_eq!(vec, [Some("a"), Some("b"), Some("c")]);Á½ÑúÜÁÑð… üÝÑ$! assert_eq!(values.next(), None);Áü‚Ò$­Ã <§ÒâÇTºÒœ½§¾¿¿½¾Òù ÅÒãù ÈÒ§˜¬ËÒ¹˜LÎÒ·ð…uRdÅv£À:<>@B ËÒöÜÄèÒ,èÒ˜¼¼Êûü…Ó8œÂ§ÃÄÃÄÂÒù ŠÓãù Ó§˜ Ó¹˜L“Ó·ðÅ´Å/13579¤õÓ<øÓ·ðÁÁ
Åììòì”êüÔÔ9œÇ§ÈÉÇÈÉÒù ÙÔãù ÜÔ§˜ ßÔ¹˜LâÔ·ðÊËÍÎúMûMÿMóNËÎÍLNPRTVL”Õ$™ÕÆÆòìü¶Õ$¹Õ¼ ¼·ðƺÆ ¾ÕÆ
Ëììòì”ê$ÃÕDöÕË”èÌ­èÌËèÌÌËÌììòì”ê³³ òìüšÖ-LÖ½ ½·ðÓûÆ §ÖÆ
Íììòì”ê$¨Öü×p$„×·ðÒ´ ºïÒ´ ÆÏÐÐÏÆµ ‰×çï Œ×Íì·ð,Åד"ºïÒ´ ·ðúMÌ×׺ïºÍ ˜"Ò´ ï×
Îììòì”êÒ´ ºï$×¶„$•×± ¢×l–ØÎ”èÑ­èÑËèÑÑÎÑììòì”êÒ´ ºï«· ½· ü¸ØBœÓ§ÔÕÓÔÕÒù ½Øãù Àا˜ ÃØ¹˜LÆØ·ðÖÄMÖ/13579´Ù’Ù¾ ¾·ðÒ –ÙÒ
Öììòì”ê$—ÙüÊÙ>œØ§ÙÚØÚÙÒù ÏÙãù ÒÙ§˜ ÕÙ¹˜LØÙ·ð$&(*,.üÚBœÜ§ÝÞÞÜÝÒù ’Úãù •Ú§˜ ŸÚüï,˜Ú¹˜L¢Ú·ðßÀcß8:<>@BüÖÚ8ÙÚ¿ÀÁ ¿·ð À c cˆ¢cµ
 `£cå² `àB¤GS
ÁŒ´Û ÝÚÛ
ßììòì”ê$ÞÚ± äÚDÓÛß”èà­èàËèààßàììòì”êŒì“ìÌŸâüÿÛ@= An iterator over the keys of a `HashMap` in arbitrary order.ÁüÀÜ)é±êÜúüîÜKH This `struct` is created by the [`keys`] method on [`HashMap`]. See itsÁܺÝß ÖÝúÜÚÝ [`keys`]: HashMap::keysÁöÝútúݒΉÞú<ÞâÇÜ•ÞÂαÞúüµÞCˆƒ ùÞúôýÞ let mut keys = map.keys();Áüœß>© ÛßúüßßCëµü£à?¹¶Äãà‚·üüà41 assert_eq!(vec, [Some(&1), Some(&2), Some(&3)]);Á±áúܵáð… üÑá"èª üôá"èª <—ââÇ$ªâ§âœã§äâãä¶… ³âÇ… ¶â¥ˆ ”)¶ˆ ›)ÂüªåjND­Çžå¯â=?AC¬¿â,¿â˜ááêùüã#8œç§èÂèç¶… •ãÇ… ˜ã¤ñéÙé!#¼ëã,îãà äñ¤ñæ ôãæ
é8õíãî$õãüÎä/8Äœë§ìÄëì¶… ÓäÇ… ÝäÃŒ ,Öä¤ñíÀcí&(*,ü„å8‡åÅÆÇ Å¤ñ Æ c cˆ¢cµ
 `£cå² `àB¤GS
ÇŒ´ê ‹åê
í8õíãî$Œå± ’åÜÀìüþåB? An iterator over the values of a `HashMap` in arbitrary order.ÁüÁæ)ê¹ëæúüïæMJ This `struct` is created by the [`values`] method on [`HashMap`]. See itsÁܽçß ÙçúüÝç [`values`]: HashMap::valuesÁýçútè’Îèú<”èâÇÜœèÂθèúü¼èCˆƒ €éúü„é" let mut values = map.values();Áü§éDÈÁ ìéúüðéGþ¼ü¸êAнÄúê‚·ü“ë:7 assert_eq!(vec, [Some(&"a"), Some(&"b"), Some(&"c")]);ÁÎëúÜÒëð… üîë$­Ã ü“ì$­Ã <¸ìâÇ4Ëì§ïœð§ñïñð¶… ÖìÇ… Ù쥈 ê.¶ˆ ñ.¦ý$úDP¢ÐÜ©òÒì=?AC¬âì,âì˜îîêùü³í%8Èœô§õõôȶ… ¸íÇ… »íññöÙö!#¼î,“îÉ Éññññó ™îó
ö8õíãî$šîüõî18Êœø§ùùøÊ¶… úîÇ… ýîÔŒ ,€ïññúÀcú&(*,ü­ï8°ïËÌÍ Ëññ Ì c cˆ¢cµ
 `£cå² `àB¤GS
ÍŒ´÷ ´ï÷
ú8õíãî$µï± »ïü”÷1ü§ðDA A draining iterator over the entries of a `HashMap` in arbitraryÁüìð1. order. The iterator element type is `(K, V)`.Ážñúü¢ñLI This `struct` is created by the [`drain`] method on [`HashMap`]. See itsÁÜïñß ‹òúìò [`drain`]: HashMap::drainÁ­òút±ò’ÎÀòú<ÄòâÇÜÌòÂÎèòúüìòGD let mut map: HashMap<_, _> = [(1, "a"), (2, "b"), (3, "c")].into();Á´óúü¸ó%" let mut drain_iter = map.drain();ÁüÞóPM let mut vec = vec![drain_iter.next(), drain_iter.next(), drain_iter.next()];Á¯ôúü³ôEB // The `Drain` iterator produces items in arbitrary order, so theÁüùô@³Ëĺõ‚·üÓõFÊŸ šöúÜžöð… üºö(% assert_eq!(drain_iter.next(), None);Áüãö(Äð <Œ÷âÇ,Ÿ÷§üœý§þÿþÿýü¶… ©÷Ç… ¬÷…ú¬¯÷–úL²÷¥ˆ +-¶ˆ 3-þì§B-ûûOŸ˜Æ¢j—%Ä•§õíãîþìÆ¢j—%Ä•¥÷œž ¢¤ ¯÷öÜôÌ÷,Ì÷˜ûûËË’2ÏùSÐæSÑÊ2SÒÚSNìK
åM6§Û€þìüï÷+8Μ§ƒƒÎ¶… ô÷Ç… ÷÷…ú ú÷–úLý÷¥ÿ')+-/1ü•ù+$£ùÏ Ï¥ÿòòíFöŸ˜÷Ú˜¶¨7g|°ßÏõíãî ¨ù
8õíãîþì$©ùü½‚8ü¬úUR A draining iterator over entries of a `HashMap` which don't satisfy the predicateÁü‚ûNK `f(&k, &mut v)` in arbitrary order. The iterator element type is `(K, V)`.ÁÑûúüÕûQN This `struct` is created by the [`extract_if`] method on [`HashMap`]. See itsÁܧüß ÃüúüÇü'$ [`extract_if`]: HashMap::extract_ifÁïüútóü’΂ýú<†ýâÇÜŽýÂΪýúü®ýLI let mut map: HashMap<i32, &str> = [(1, "a"), (2, "b"), (3, "c")].into();Áûýúüÿý<9 let mut extract_if = map.extract_if(|k, _v| k % 2 != 0);Áü¼þ=: let mut vec = vec![extract_if.next(), extract_if.next()];ÁúþúüþþIF // The `ExtractIf` iterator produces items in arbitrary order, so theÁüÈÿ@³Ëĉ€‚·ü¢€52 assert_eq!(vec, [Some((1, "a")),Some((3, "c"))]);ÁØ€úÜÜ€ð… üø€(% assert_eq!(extract_if.next(), None);Áü¡(Šþ ¬Ê drop(extract_if);Áàúìä assert_eq!(map.len(), 1);Á<‚‚âÇ.üŠ‚2"Iterators are lazy unless consumedÁLÈ‚§œˆ§ŠˆŠ¶… Ö‚Ç… Ù‚ζ Ü‚Íì‹ó¬ß‚‹óLâ‚¥ˆ |'¶ˆ „'‹ó§“'éOŒ±˜Ÿ˜t.™ §õíãî…ó‹ót.™ ŒÒ‚ÇÉËÍÏÑÊ ß‚öÜ$ü‚ ü‚˜…óü†ƒ",†ƒ˜Ò5ŠùæÑ¶'–¤Fr§Û€‹óü­ƒq8Òœ§ÒÐÑ…ó Ðõí Ñãî˜"$‡„Ç… µƒζ ¸ƒÉ
»ƒÐÑ“"…ó˜…
Ìòƒ¶… ²ƒÛ
L”„¾òúMûMÿM/1vxz|~L¥„$ª„ŽŽÛ€üï„($ò„Ó Ó¾òÛ¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙ¾òúMŽ ÷„Ž
8õíãî…ó‹ó$ü„̲…”è­èËèõíãî…ó‹ó Û€ …óüõ…-Lø…Ô Ô¾òÓûŽ ‚†Ž
8õíãî…ó‹ó$ƒ†üÙ†Y8ל˜§šš×˜ÕÖ…ó Õõí Öãî˜"$®‡Ç… á†ζ ä†ÕÖ“"…ó’‹
Ì™‡¶… Þ†˜ó  GIKMôùü·‡IF A mutable iterator over the values of a `HashMap` in arbitrary order.Áüˆ-ñÀ¯ˆúü³ˆQN This `struct` is created by the [`values_mut`] method on [`HashMap`]. See itsÁÜ…‰ß ¡‰úü¥‰'$ [`values_mut`]: HashMap::values_mutÁ͉útщ’Îà‰ú<ä‰âÇÜì‰ÂΈŠúüŒŠSÌ àŠúüäŠ&# let mut values = map.values_mut();Áü‹‹63 values.next().map(|v| v.push_str(" Mississippi"));Áü‹6åŽ
ù‹úÜý‹ð… ü™Œ$­Ã ü¾Œ$­Ã ãŒúüçŒDý’ ü¬DÌ“ âÇL„ާœœ§žœž¶… ’ŽÇ… •Ž¥ˆ þ=¶ˆ >Áþýàƒ6 Ç¼ŸŽŽ=?ACÄžŽ,žŽ˜Úúü½™'ü»ŽPM A view into a single entry in a map, which may either be vacant or occupied.ÁŒúüHE This `enum` is constructed from the [`entry`] method on [`HashMap`].ÁÙúìÝ [`entry`]: HashMap::entryÁûútÿ’ÎŽú<’âÇüš=: use hashbrown::hash_map::{Entry, HashMap, OccupiedEntry};ÁØúüÜ!î²üþ2/ map.extend([("a", 10), ("b", 20), ("c", 30)]);Á챑ü³Ï‘úäÓ‘ // Existing key (insert)Áüð‘/, let entry: Entry<_, _, _> = map.entry("a");Áü 96 let _raw_o: OccupiedEntry<_, _, _> = entry.insert(1);ÁìÚ’ü³üø’ // Nonexistent key (insert)Á옓 map.entry("d").insert(4);Á¶“úüº“ // Existing key (or_insert)ÁüÚ“(% let v = map.entry("b").or_insert(2);Áüƒ”,) assert_eq!(std::mem::replace(v, 2), 20);Áü°”" // Nonexistent key (or_insert)ÁüÓ”  map.entry("e").or_insert(5);Áô”úüø”$! // Existing key (or_insert_with)Áü0- let v = map.entry("c").or_insert_with(|| 3);ÁüΕ,) assert_eq!(std::mem::replace(v, 3), 30);Áüû•'$ // Nonexistent key (or_insert_with)Áü£–(% map.entry("f").or_insert_with(|| 6);ÁÌ–úüЖ'$ println!("Our HashMap: {:?}", map);Áø–úüü–FC let mut vec: Vec<_> = map.iter().map(|(&k, &v)| (k, v)).collect();Áü×DäÊüˆ˜@³ËÄɘ‚·üâ˜RO assert_eq!(vec, [("a", 1), ("b", 2), ("c", 3), ("d", 4), ("e", 5), ("f", 6)]);Á<µ™âÇ,Æ™§¡œ¢§£¤¤¥¢¤¥£¡¶… ЙÇ… Ó™ÍìÃô Ö™É
TÙ™Û
Lò™¥ˆ üò«"¶ˆ 
Ãô§û
 ¦§÷Q¨ˆ©ª”R«ˆÞ`ÿú¨?˜§õíãîÃô‹óÞ`ÿú¨?˜¦§©ª§¨²²ÜR¸§˜¹¡S˜ºæ˜£Ü,·s6ú§õíãîÃô‹ó³ 
ª«ËˬTѧ˜ÒïT˜Óæ˜Ñ!ÊSÂò+§õíãîÃô‹ó³ 
Ì™«®±´®±´ Ù™öÜ·´ƒš An occupied entry.Ážšút¦š’ιšú<ÁšâÇüÍš.+ use hashbrown::hash_map::{Entry, HashMap};Áü€›A> let mut map: HashMap<_, _> = [("a", 100), ("b", 200)].into();ÁÆ›úÔΛ match map.entry("a") {Áüí›+( Entry::Vacant(_) => unreachable!(),Áüœ! Entry::Occupied(_) => { }Á,܈Ø<ÍœâÇ·  
§§õíãîÃô‹ó··´¡
³ 
  ë¦
ì✠ ´¡
¸œ‡ A vacant entry.ÁŸú’κúâÇüÎ.¯£
üž5±—»žúÔÞÀ¤
üâž-* Entry::Occupied(_) => unreachable!(),Áü”Ÿ Entry::Vacant(_) => { }Á,¸ŸˆØ<ŸâǸ  
ª§õíãîÃô‹ó¸¸¡¢
³ 
  ý©
ÜÕŸ  ¡¢
üöŸI8Øœ­§®¤¯°Ø¯­®°¶… ûŸÇ… … íŸ
 É
’ ÃŒ ,þŸÔŒ ,ˆ Û
L• îó±Àc±JLNPRTVXüÆ 8É ÙÚÛ Ùîó Ú c cˆ¢cµ
 `£cå² `àB¤GS
ÛŒ´¬ Í ¬
±8õíãîÃô‹ó$Π± Ô üñªQüÈ¢30 A view into an occupied entry in a [`HashMap`].Áüü¢74 It is part of the [`Entry`] and [`EntryRef`] enums.Á´£út¸£’ÎÇ£ú<Ë£âÇüÓ£=‰”
‘¤úü•¤!î²ü·¤2í”
ê¤úüî¤FC let _entry_o: OccupiedEntry<_, _, _> = map.entry("a").insert(100);Áìµ¥ü³Ó¥úü×¥'$ // Existing key (insert and update)ÁÔÿ¥À¤
üš¦+å¤
üƦ&# Entry::Occupied(mut view) => {Áüí¦)& assert_eq!(view.get(), &100);Áü—§# let v = view.get_mut();Á¬»§ *v *= 10;Áüѧ0- assert_eq!(view.insert(1111), 1000);ÁL‚¨¹Ü,Œ¨ˆØ’¨úü–¨  assert_eq!(map[&"a"], 1111);Áì·¨ü³Õ¨úÔÙ¨ // Existing key (take)ÁÔô¨ match map.entry("c") {Áü©+å¤
ü»©" Entry::Occupied(view) => {ÁüÞ©74 assert_eq!(view.remove_entry(), ("c", 30));ÁL–ª¹Ü, ªˆØü¦ª$! assert_eq!(map.get(&"c"), None);Áì˪ assert_eq!(map.len(), 2);Á<éªâÇlüª§³œ´§µ¤·µ³´·¶… Ž«Ç… ‘«íŸ
´”«É
¬¬«Û
L¯«¥ˆ ö ¶ˆ ý ¡ 
 û
 ´¡
£Ü,·s6ú¸¹ºŠ«jlnpr ”«˜á| ¬«öÜLÉ«$É«˜²²¤Ø«$Ø«˜²²ƒƒÙµ S S~¡°FbÛ€Û ,ò«˜²²Âùü™¬8Üœ¼§½¤¾¿Ü¾¼½¿ ¶… ¥¬Ç… ¨¬íŸ
«¬É
®¬ó— $嬅˜ $ò¬ÌìÃô$ÿ¬Ìì‹ó$Œ­Û
L“­Õôcegikmoqü¢­8ÝœÁ§Â¤ÃÄÂÃÝÁÄ ¶… ®­Ç… ±­íŸ
´­É
·­ õí$î­ ãî$û­ Ãô$ˆ® ‹ó$•®Û
Lœ®Õôqsuwy{}ü¬®Q8ޜƧǤÈÉÉÇÈÆÞ¶… ±®Ç… »®íŸ
Å®É
ȮÌ ,´®ÔŒ ,¾®Û
LË®ÕôÊÀcÊJLNPRTVXü„¯8‡¯ßàá ßÕô à c cˆ¢cµ
 `£cå² `àB¤GS
ጴŠ‹¯Å
Ê8õíãîÃô‹ó$Œ¯± ’¯üá¶OüÔ°.+ A view into a vacant entry in a `HashMap`.Áüƒ±%" It is part of the [`Entry`] enum.Á©±út­±’μ±ú<À±âÇüȱ;8 use hashbrown::hash_map::{Entry, HashMap, VacantEntry};Á„²úüˆ².+ let mut map = HashMap::<&str, i32>::new();Á·²úü»²>; let entry_v: VacantEntry<_, _, _> = match map.entry("a") {Áüú²$! Entry::Vacant(view) => view,ÁüŸ³-÷§
4ͳ };Á¼Ô³ entry_v.insert(10);Áüì³/, assert!(map[&"a"] == 10 && map.len() == 1);Áœ´úü ´*' // Nonexistent key (insert and update)ÁÔË´ match map.entry("b") {Áüæ´-÷§
ü”µ  Entry::Vacant(view) => {Áüµµ'$ let value = view.insert(2);Áüݵ" assert_eq!(*value, 2);ÁÄ€¶ *value = 20;ÁL™¶¹Ü,£¶ˆØü©¶/, assert!(map[&"b"] == 20 && map.len() == 2);Á<Ù¶âÇ\춧̜ͧΤÏÐÍÎÌÐ϶… ü¶Ç… ÿ¶íŸ
´‚·É
¬š·Û
L·¥ˆ üÒ·"¶ˆ 
¡ 
û
¡¢
Ñ!ÊSÂò+ÑÒÓø¶jlnpr ‚·˜á| š·öÜL··$··˜ËË4Æ·Æ·˜ËËõí¸,Ò·˜ËËÂùüù·H8âœÕ§Ö¤×ØØÖ×Õâ¶… þ·Ç… ˆ¸íŸ
‹¸É
ޏÃŒ ,¸Û
L‘¸ÍõÙÀcÙACEGIKMOüȸ8˸ãäå ãÍõ ä c cˆ¢cµ
 `£cå² `àB¤GS
åŒ´Ô ϸÔ
Ù8õíãîÃô‹ó$и± Ö¸ü¤Æ9ü̹PM A view into a single entry in a map, which may either be vacant or occupied,Áüº1. with any borrowed form of the map's key type.ÁϺúÓºúü׺LI This `enum` is constructed from the [`entry_ref`] method on [`HashMap`].Á¤»úü¨»UR [`Hash`] and [`Eq`] on the borrowed form of the map's key type *must* match thoseÁüþ»SP for the key type. It also require that key may be constructed from the borrowedÁüÒ¼'$ form through the [`ToOwned`] trait.Áú¼úüþ¼%" [`entry_ref`]: HashMap::entry_refÁ¤½út¨½’η½ú<»½âÇüý@= use hashbrown::hash_map::{EntryRef, HashMap, OccupiedEntry};Á„¾úüˆ¾!î²üª¾KH map.extend([("a".to_owned(), 10), ("b".into(), 20), ("c".into(), 30)]);Áìö¾ü³”¿ú䘿Ä•
üµ¿  let key = String::from("a");ÁüÖ¿:7 let entry: EntryRef<_, _, _, _> = map.entry_ref(&key);Áü‘À<9 let _raw_o: OccupiedEntry<_, _, _, _> = entry.insert(1);ÁìÎÀü³üìÀ÷–
üŒÁ! map.entry_ref("d").insert(4);Á®Áúü²ÁÕ—
üÒÁ,) let v = map.entry_ref("b").or_insert(2);ÁüÿÁ,²˜
ü¬Â"é˜
üÏÂ$! map.entry_ref("e").or_insert(5);ÁôÂúüøÂ$Ι
üÃ41 let v = map.entry_ref("c").or_insert_with(|| 3);ÁüÒÃ,¸š
üÿÃ'ïš
ü§Ä,) map.entry_ref("f").or_insert_with(|| 6);ÁÔÄúüØÄ'á›
€Åúü„ÅOL for (key, value) in ["a", "b", "c", "d", "e", "f"].into_iter().zip(1..=6) {ÁüÔÅ# assert_eq!(map[key], value)Á,øÅˆØìþÅ assert_eq!(map.len(), 6);Á<œÆâÇD­Æ§Ûƒ>ܜݢާߤàááÝÛßàÞÜÍì÷ ¾ÆÎì‡÷ ÁÆÍì÷ ÌÆÍì“÷ ÏÆÍì™÷TÒÆ™÷LëÆ÷§î÷§ü“÷§
™÷§‡÷ƒ>dæ×Úâã÷Qäˆåæ”Rçˆ/âÁܪŒ‹§ƒ>÷‡÷÷“÷™÷/âÁܪŒ‹âãåæãä²²ÜR¸§˜¹¡S˜ºæ˜£Ü,·s6ú§÷÷“÷™÷¿Þ
æçïïÖV÷§˜øïT˜ùæ˜0ùòDï†Kð§ƒ>÷‡÷÷“÷™÷¿Þ
¶ÆºÆ

 ÒÆöÜÒ¸´üÆØ¢
—ÇútŸÇ’βÇú<ºÇâÇüÆÇ1. use hashbrown::hash_map::{EntryRef, HashMap};ÁüüÇSP let mut map: HashMap<_, _> = [("a".to_owned(), 100), ("b".into(), 200)].into();ÁÔÈúôÜÈ match map.entry_ref("a") {ÁüÿÈ.+ EntryRef::Vacant(_) => unreachable!(),Áü²É$! EntryRef::Occupied(_) => { }Á,ÛɈØ<åÉâÇÒ¸ÚÚ
㧃>÷‡÷÷“÷™÷Ò¸Ò¸Êß
¿Þ
ÚÚ®å
ìúÉÚÚÊß
빜ŸÊê¦
·Êút¿Ê’ÎÒÊú<ÚÊâÇüæÊ1Óá
üœË74 let mut map: HashMap<String, i32> = HashMap::new();ÁØËúôàËùâ
üƒÌ0- EntryRef::Occupied(_) => unreachable!(),Áü¸Ì" EntryRef::Vacant(_) => { }Á,ß̈Ø<éÌâÇë¹ÚÚ
槃>÷‡÷÷“÷™÷ë¹ë¹·à
¿Þ
ÚÚöè
üüÌ%ÚÚ·à
ü§Í8æ8çœé¢ê§ë¤ìíçìêíæéë
ŽÝ
¬Í Ý
¯Í²Ý
²ÍÄÝ
µÍÖÝ
¸Í¿c÷,òÍ ÷‡÷LúÍ¿c‡÷,ŒÎ¿c÷,£ÎèÝ
L±Î¯öîÀcîüÂÎ8ÅÎèéê è¯ö é c cˆ¢cµ
 `£cå² `àB¤GS
ꌴè ÉÎè
î88÷‡÷÷“÷™÷$Êα ÐÎü€×PüÐÐ.ÀÀ
üÿÐ(% It is part of the [`EntryRef`] enum.Á¨Ñút¬Ñ’λÑú<¿ÑâÇüÇÑA> use hashbrown::hash_map::{EntryRef, HashMap, VacantEntryRef};Á‰ÒúüÒ0- let mut map = HashMap::<String, i32>::new();Á¾ÒúüÂÒHE let entry_v: VacantEntryRef<_, _, _, _> = match map.entry_ref("a") {Áü‹Ó'$ EntryRef::Vacant(view) => view,Áü³Ó0êæ
4äÓþÃ
¼ëÓŽÄ
üƒÔ.+ assert!(map["a"] == 10 && map.len() == 1);Á²Ôúü¶Ô*÷Ä
ôáÔ match map.entry_ref("b") {Áü€Õ0êæ
ü±Õ# EntryRef::Vacant(view) => {ÁüÕÕ'ŠÆ
üýÕ"¼Æ
Ä ÖèÆ
L¹Ö¹Ü,ÃÖˆØüÉÖ.+ assert!(map["b"] == 20 && map.len() == 2);Á<øÖâÇt‹×ìVðøVñœò¢ó§ô¤õöðöõóñôòŽÝ
¦× Ý
©×²Ý
´×ÄÝ
·×ÖÝ
¬º×èÝ
L½×‡÷øV¯ ÷ìVüø×$÷ìV“÷ìV™÷ìV+ïïÖV÷§˜øïT˜ùæ˜0ùòDï†KðìVøV÷‡÷÷“÷™÷0ùòDï†Kð÷øù$š×$ ×   º×öÜL××$×טïïå æ×˜ïï øV‡÷K,ø×˜ïï ìV³³¸¼8¹æ­¼x¾spA÷÷“÷™÷ü¡Ø8ë8ìœû¢ü§ý¤þÿûýÿìüþëŽÝ
¦Ø Ý
©Ø²Ý
¬ØÄÝ
¯ØÖÝ
²Ø§ë
Lòؼë
,„ÙèÝ
L›Ù¦÷ÀcSUWY[]_aceü¬Ù8¯Ùíîï í¦÷ î c cˆ¢cµ
 `£cå² `àB¤GS
ú ³Ùú
88÷‡÷÷“÷™÷$´Ù± ºÙüùà<ü´ÚZW The error returned by [`try_insert`](HashMap::try_insert) when the key already exists.ÁÛúü“ÛEB Contains the occupied entry, and the value that was not inserted.ÁÙÛútÝÛ’ÎìÛú<ðÛâÇüøÛ63 use hashbrown::hash_map::{HashMap, OccupiedError};Á¯Üúü³Ü?< let mut map: HashMap<_, _> = [("a", 10), ("b", 20)].into();ÁóÜúü÷ÜSP // try_insert method returns mutable reference to the value if keys are vacant,ÁüËÝPM // but if the map did have key present, nothing is updated, and the providedÁüœÞ0- // value is returned inside `Err(_)` variantÁüÍÞ$! match map.try_insert("a", 100) {ÁüòÞ41 Err(OccupiedError { mut entry, value }) => {Áü§ß*' assert_eq!(entry.key(), &"a");ÁüÒß# assert_eq!(value, 100);Áüöß-* assert_eq!(entry.insert(100), 10)ÁL¤à¹Üä®à _ => unreachable!(),Á,ËàˆØüÑà assert_eq!(map[&"a"], 100);Á<ñàâÇl„á§œƒ§¤ƒ¶… –áÇ… ™áíŸ
œáÉ
¬ŸáÛ
L¢á¥ˆ (3¶ˆ /3¡ 
63û
=3ùWÝ=ˆ»’mwšÐÍß§õíãîÃô‹ó’mwšÐÍ߈’á®°²´¸º ŸáöÜüôá(ü¼á30 The entry in the map that was already occupied.Á,øá´¡
dôâü¢âMJ The value which was not inserted, because the entry was already occupied.Á,øâãîü…ãQ8𜊧¤ŒðŒŠ¶… ŠãÇ… ”ãíŸ
žãÉ
¡ãÃŒ ,ãÔŒ ,—ãÛ
L¤ã‘øŽÀcŽJLNPRTVXüÝã8àãñòó ñ‘ø ò c cˆ¢cµ
 `£cå² `àB¤GS
óŒ´ äã
Ž8õíãîÃô‹ó$åã± ëãüêåX8ôœ§¤ô¶… ïåÇ… ùåíŸ
ƒæÉ
†æÃŒ ,òåÔŒ ,üåÛ
L‰æ‘øÅcJLNPRTVXüÉæ8Ìæõö÷ õ‘ø ö c cˆ¢cµ
 `£cå² `àB¤GS
÷Œ´ Ðæ
8õíãîÃô‹ó$Ñæ± ׿üØèH§œ§˜¤š˜š¶… áèÇ… äèíŸ
çèÉ
êèÛ
LíèìøœÈLÉLÊLÝèMOQSUWY[L§é$¬é³€lÇéDÌéêùü¾ï$üìéKH Creates an iterator over the entries of a `HashMap` in arbitrary order.Áü¼ê2ÇóêúüûêKH Return the same `Iter` struct as by the [`iter`] method on [`HashMap`].ÁËëúÜÓë‘‚ óëútûë’ÎŽìú<–ìâÇÜ¢ìÂÎüÂìGD let map_one: HashMap<_, _> = [(1, "a"), (2, "b"), (3, "c")].into();ÁüŽí%" let mut map_two = HashMap::new();Á¸íúüÀí" for (key, value) in &map_one {Áüçí30 println!("Key: {}, Value: {}", key, value);ÁüŸî%" map_two.insert(*key, *value);Á,ÉîˆØÓîúüÛî! assert_eq!(map_one, map_two);Á<ïâÇLÁïìøêù
§õíãîÃô‹ó$Ëïü‚ðL§Ÿœ §¡¤¢£¢£¡Ÿ ¶… ‹ðÇ… ŽðíŸ
‘ðÉ
”ðÛ
L—ðÂù¤¥¦ÈLÉLÊL¦‡ðMOQSUWY[LÕð$Úðžž—— lùðDþðžžÚúüûø'ü¡ñJG Creates an iterator over the entries of a `HashMap` in arbitrary orderÁüðñGD with mutable references to the values. The iterator element type isÁ̼ò `(&'a K, &'a mut V)`.ÁÚòúüâòEB Return the same `IterMut` struct as by the [`iter_mut`] method onÁ„¬ó
[`HashMap`].ÁÁóúüÉó#Í ñóútùó’ÎŒôú<”ôâÇÜ ôÂÎüÀôGD let mut map: HashMap<_, _> = [("a", 1), ("b", 2), ("c", 3)].into();ÁŒõúü”õ" for (key, value) in &mut map {Áü»õ3«• ¤óõ *value *= 2;Á,ŒöˆØ–öúüžö1. let mut vec = map.iter().collect::<Vec<_>>();ÁüÔöDäÊü÷@³ËÄâ÷‚·üÿ÷:7 assert_eq!(vec, [(&"a", &2), (&"b", &4), (&"c", &6)]);Á<¾øâÇLþøÂùÚúžž
¦§õíãîÃô‹ó$ˆùüÆù@œ¨§©¤ª«©«ª¨Òù Ëùãù Îùôù Ñù…ú Ôù–úL×ù´ì¬­®ÈLÉLÊL®FHJLNPRTLú$’ú§§l¥úDªú§§æŸ˜¥K@¬žú‚Äììòìþìü±€'üÍúHE Creates a consuming iterator, that is, one that moves each key-valueÁüšûHE pair out of the map in arbitrary order. The map cannot be used afterÁŒçû calling this.Áýûút…ü’Θüú< üâÇܬüÂÎÌüúüÔüC@ let map: HashMap<_, _> = [("a", 1), ("b", 2), ("c", 3)].into();Áœýúü¤ý  // Not possible with .iter()ÁüÉý>; let mut vec: Vec<(&str, i32)> = map.into_iter().collect();ÁüŒþDA // The `IntoIter` iterator produces items in arbitrary order, soÁüÕþDA // the items must be sorted to test them against a sorted array.ÁÄžÿ‚·ü»ÿ4ŒÌ<ôÿâÇL´€´ìå£ §§
®ììòìøìþì$¾€ü¬%8øœ°§±±°ø¶… ±Ç… ´ î²´²!#¤‰‚<Œ‚ î¯¯
²8õíãîü‰ƒ*§´œµ§µ´¶… ’ƒÇ… •ƒêù·¸¹ºúMûMÿMóN¹º¸ŽƒACEGLºƒ$¿ƒ³³³€üŒ„,$ù ùêùÛ¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙ³€³ ”„³
¸§õíãî$™„üì†-Lï†ú úêùÓû³ ù†³
¹§õíãî$ú†üö‡p$ù‡êùÒ´ ºïÒ´ ³»¼»¼³µ þ‡çï ˆÍìêù,ºˆ“"ºïÒ´ êùúMÌ̈ºïɰ ˜"Ò´ äˆ
º§õíãîÒ´ ºï$„ˆ¶„$Šˆ± —ˆD‹‰º”è½­è½Ëè½½º½õíãîÒ´ ºïÒ´ ¿¹
Ò´ ½· üð‰/8ûœ¿§À¿ûÀ¶… õ‰Ç… ø‰ îÁÄMÁ!#´×ŠÚŠü ü î¾ ÞŠ¾
Á8õíãî$ߊü’‹+8ýœÃ§ÄÃýĶ… —‹Ç… š‹ îü‹(8þœÆ§ÇþÇÆ¶… NjDž Ê‹üîÈ´È!#¤¢Œ<¥ŒüîÅÅ
È8õíãîü¢-§ÊœË§ÌÌÊ˶… «Ç… ®ÚúÍÎÏÐúMûMÿMóNÎÐϧACEGÉÉ—— ü¬Ž0$¯Žÿ ÿÚúÛ¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙ—— É ´ŽÉ
Χõíãî$¹Žü”‘-L—‘ ÚúÓûÉ ¡‘É
ϧõíãî$¢‘üž’p$¡’ÚúÒ´ ºïÒ´ ÉÑÒÒÑɵ ¦’çï ©’ÍìÚú,â’“"ºïÒ´ ÚúúMÌô’ºï²» ˜"Ò´ Œ“
ЧõíãîÒ´ ºï$¬’¶„$²’± ¿’D³“ДèÓ­èÓËèÓÓÐÓõíãîÒ´ ºï¯² ½· ü˜”28œÕ§ÖÕÖ¶… Ç…  ”üî×ÄM×!#´‚•…• üîÔ ‰•Ô
×8õíãî$Š•ü¼•.8ƒœÙ§ÚÙÚƒ¶… Á•Ç… Ä•üîüï•W8œÜ§ÝÝܶ… ô•Ç… ÷•ÃŒ T¨–ÔŒ T»–üîÞÀcÞ/135üÍ–8Ж üî  c cˆ¢cµ
 `£cå² `àB¤GS
Œ´Û Ô–Û
Þ8õíãî$Õ–± Û–üÆ—6œà§áâáàâÒù Ë—ãù Η§˜ Ñ—¹˜LÔ—Êûã´ã/13579¤´˜<·˜Êûßß
ãììòì”êü“™7œå§æçåæçÒù ˜™ãù ›™§˜ ž™¹˜L¡™ÊûèéêëúMûMÿMóNëêéLNPRTVLÑ™$Ö™ääü›š$$žšˆ ˆÊû†ää £šä
éììòì”ê$¨šü—›-Lš› ÊûÓûä ¤›ä
êììòì”ê$¥›ü¡œl$¤œÊûÒ´ ºïÒ´ äìííìäµ ©œçï ¬œÍìÊû,ᜓ"ºïÒ´ ÊûúMÌóœºïÏÈ ˜"Ò´ 
ëììòì”êÒ´ ºï$¯œ¶„$µœ± ¾œü½@œï§ðñðïñÒù Âãù ŧ˜ ȹ˜ÊûòÄMò/13579´µž¸žŠ ŠÊûî ¼žî
òììòì”ê$½žüïž<œô§õöõöôÒù ôžãù ÷ž§˜ úž¹˜LýžÊû$&(*,.ü°ŸGœø§ùúøùúÒù µŸãù ¿Ÿ§˜ ÉŸëï,¸Ÿüï,Ÿ¹˜LÌŸÊûûÀcûACEGIKüþŸ8 Œ Êû Œ c cˆ¢cµ
 `£cå² `àB¤GS
Œ´÷ … ÷
ûììòì”ê$† ± Œ ü÷ %8Žœý§þýþ޶… ü Ç… ÿ ¤ñÿ´ÿ!#¤Ô¡<ס¤ñüü
ÿ8õíãîü³¢*§ œ§ƒ ƒ  ¶… ¼¢Ç… ¿¢Âü„ … † ‡ úMûMÿMóN¸¢ACEGLä¢$颵€ü­£#$°£ ÂüÛ¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙµ€ µ£
§õíãî$º£ü³¥-L¶¥ ÂüÓû À¥
§õíãî$Á¥ü½¦p$À¦ÂüÒ´ ºïÒ´ ˆ ˆ µ Ŧçï ȦÍìÂü,§“"ºïÒ´ ÂüúMÌ“§ºïìÕ ˜"Ò´ «§
§õíãîÒ´ ºï$˦¶„$Ѧ± Þ¦lÒ§”èŠ ­èŠ ËèŠ Š Š õíãîÒ´ ºïÒ´  õí ãîÒ´ ½· üó§/8œŒ §  Œ ¶… ø§Ç… û§¤ñŽ ÄMŽ !#´Ú¨ݨ ¤ñ á¨
Ž 8õíãî$â¨ü”©+8œ § ¶… ™©Ç… œ©¤ñüÄ©'8œ§¶… ɩDž Ì©ññ´!#¤£ª<¦ªññ
8õíãîü‚«,§œ˜ §˜ ¶… ‹«Ç… Ž«¦ýš › œ úMûMÿMóNœ ‡«ACEGLµ«$º«¿€üþ«#$¬ ¦ýÛ¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙ¿€ †¬
§õíãî$‹¬ü„®-L‡® ¦ýÓû ‘®
œ §õíãî$’®üޝp$‘¯¦ýÒ´ ºïÒ´ ž Ÿ Ÿ ž µ –¯çï ™¯Íì¦ý,Ò¯“"ºïÒ´ ¦ýúMÌ䯺ïàà ˜"Ò´ ü¯
§õíãîÒ´ ºï$œ¯¶„$¢¯± ¯¯l£° ”è  ­è  Ëè       õíãîÒ´ ºïÒ× ½· üİ18œ¢ §£ £ ¢ ¶… ɰÇ… ̰ññ¤ ÄM¤ !#´­±°±˜ ˜ññ¡  ´±¡
¤ 8õíãî$µ±üç±-8œ¦ §§ § ¦ ¶… ì±Ç… ï±ññü™²*8šœ© §ª ª © š¶… ž²Ç… ¡²ÿý« ´« !#¤û²<þ²ÿý¨ ¨
« 8õíãîüÚ³/§­ œ® §¯ ® ¯ ­ ¶… ã³Ç… æ³Áþ° ± ² ³ úMûMÿMóN³ ± ² ß³ACEGL´$•´¬ ¬ œ— üÝ´'$à´ ÁþÛ¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙœ— ¬  å´¬
± §õíãî$ê´üç¶-Lê¶œ œÁþÓû¬  ô¶¬
² §õíãî$õ¶üñ·p$ô·ÁþÒ´ ºïÒ´ ¬ ´ µ ´ µ ¬ µ ù·çï ü·ÍìÁþ,µ¸“"ºïÒ´ ÁþúMÌǸºï»ë ˜"Ò´ ߸
³ §õíãîÒ´ ºï$ÿ·¶„$…¸± ’¸l†¹³ ”è­èËè³ õíãîÒ´ ºïÒ´ Ü× ãîÒ´ ½· ü§¹48œ¸ §¹ ¸ ¹ ¶… ¬¹Ç… ¯¹ÿýº ÄMº !#´“º–ºž
 `£cå² `àB¤GS
£Œ´¾  Ä»¾
Á 8õíãî$Å»± Ë»Tº¼Á ”è ­è Ëè  Á  õíãîÚ× â× üê¼88¤œÄ §Å Æ ¤Ä Å Æ ¶… ï¼Ç… ò¼…ú õ¼–úLø¼¥ÿÇ È É Ê úMûMÿMóNÊ È É LNPRTVL©½$®½à à ۀüó½$$ö½¥ ¥¥ÿÛ¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙÛ€à  û½Ã
È 8õíãîþì$€¾üï¾-Lò¾¦ ¦¥ÿÓûà  ü¾Ã
É 8õíãîþì$ý¾üù¿l$ü¿¥ÿì÷ à Ë Ì Ë Ì à Íìì÷ ÀÍìñ÷ „ÀÍì¥ÿ,¹À“"ñ÷ ì÷ ¥ÿúMÌËÀñ÷ êø ˜"ì÷ ãÀ
Ê 8õíãîþìì÷ ñ÷ $‡À¶„$À± –À˜ü•ÁA8§œÎ §Ï Ð Ï §Î Ð ¶… šÁÇ… Á…ú  Á–úL£Á¥ÿÑ ÄMÑ /13579´ŽÂ‘¨ ¨¥ÿÍ  •ÂÍ
Ñ 8õíãîþì$–ÂüÈÂ=8©œÓ §Ô Õ ©Ô Ó Õ ¶… ÍÂÇ… ÐÂ…ú Ó–úLÖÂ¥ÿ$&(*,.üŠÃm8ªœ× §Ø Ù Ø Ù × ª¶… ÃÇ… ’Ã…ú •ÃÃŒ TÇÃÔŒ TÚÖúLíÃ¥ÿÚ ÀcÚ ACEGIKüþÃ8Ä«¬­ «¥ÿ ¬ c cˆ¢cµ
 `£cå² `àB¤GS
­Œ´Ö  …ÄÖ
Ú 8õíãîþì$†Ä± ŒÄü÷Ä5§Ü œÝ §Þ ¤ß à Þ ß Ý à Ü ¶… €ÅÇ… ƒÅíŸ
†ÅÉ
‰ÅÛ
LŒÅ³ 
á â ã ä æ è é ë í üÄOQSUWY[]ü¶Èqü³Å@= Sets the value of the entry, and returns an `OccupiedEntry`.ÁøÅút€Æ’ΓÆú<›ÆâÇܧÆÂÎÇÆúüÏÆ52 let mut map: HashMap<&str, u32> = HashMap::new();Áü‰Ç30 let entry = map.entry("horseyland").insert(37);ÁÁÇúüÉÇ+( assert_eq!(entry.key(), &"horseyland");Á<ùÇâÇ4½È³ 
ãî´¡
Û Û Ùú$ŠÉÅeÃô\›É
á §õíãîÃô‹ó$ÄÈ»,ÊÈüÞÏbüŒËRO Ensures a value is in the entry by inserting the default if empty, and returnsÁüãË2ÂΚÌút¢Ì’εÌú<½ÌâÇÜÉÌÂÎéÌúüñÌ5¤‚ «Íú´³Í // nonexistent keyÁüÎÍ(% map.entry("poneyland").or_insert(3);ÁüûÍ$! assert_eq!(map["poneyland"], 3);Á¤Îúœ¬Î // existing keyÁüÄÎ/, *map.entry("poneyland").or_insert(10) *= 2;ÁüøÎ$! assert_eq!(map["poneyland"], 6);Á<¡ÏâÇLåϳ 
ã Û Û Ùú$£Ð­… \´Ð
â §õíãîÃô‹ó$ïÏ><õÏü•×|üäÑFC Ensures a value is in the entry by inserting the default if empty,Áü¯Ò%" and returns an [`OccupiedEntry`].ÁÙÒútáÒ’ÎôÒú<üÒâÇ܈ÓÂΨÓúü°Ó5¤‚ êÓú´òÓÓ† üÔ:7 let entry = map.entry("poneyland").or_insert_entry(3);ÁüÌÔ*' assert_eq!(entry.key(), &"poneyland");ÁüûÔ  assert_eq!(entry.get(), &3);Á Õúœ¨Õ⇠üÀÕ?< let mut entry = map.entry("poneyland").or_insert_entry(10);Áü„Ö*·Œ ü³Ö ìŒ <ØÖâÇ|œ×³ 
ãî´¡
Û Û Ùú$ô×­… \…Ø
ã §õíãîÃô‹ó$¬×><²×ü©Þyü°Ù]Z Ensures a value is in the entry by inserting the result of the default function if empty,Áü’Ú>; and returns a mutable reference to the value in the entry.ÁÕÚútÝÚ’ÎðÚú<øÚâÇÜ„ÛÂΤÛúü¬Û5¤‚ æÛú´îÛÓ† ü‰Ü0- map.entry("poneyland").or_insert_with(|| 3);Áü¾Ü$§‡ çÜúœïÜ⇠ü‡Ý74 *map.entry("poneyland").or_insert_with(|| 10) *= 2;ÁüÃÝ$ºˆ <ìÝâÇt°Þ³ 
ñ÷ œ— Û å å Û »ø ¿Þ–"ñ÷ lÂÞñ÷ ˜"ãî ÎÞÙú$…ß­… \–ß
ä §õíãîÃô‹óñ÷ $ÑÞ><×Þqsü˜èüÈà_\ Ensures a value is in the entry by inserting, if empty, the result of the default function.Áü¬á_\ This method allows for generating key-derived values for insertion by providing the defaultÁüâXU function a reference to the key that was moved during the `.entry(key)` method call.ÁíâúüõâTQ The reference to the moved key is provided so that cloning or copying the key isÁüÎã85 unnecessary, unlike with `.or_insert_with(|| ... )`.Á‹äút“ä’Φäú<®äâÇܺäÂÎÚäúüâä74 let mut map: HashMap<&str, usize> = HashMap::new();Ážåú´¦åÓ† üÁåIF map.entry("poneyland").or_insert_with_key(|key| key.chars().count());Áüæ$! assert_eq!(map["poneyland"], 9);Á¸æúœÀæ⇠üØæTQ *map.entry("poneyland").or_insert_with_key(|key| key.chars().count() * 10) *= 2;Áü±ç%" assert_eq!(map["poneyland"], 18);Á<ÛçâÇ”Ÿè³ 
ñ÷ œ— Û ç ç Û »ø ²è®–"ñ÷  ®õí|µè®ñ÷ ”ž ˜"ãî ÃèÙú$úè­… \‹é
æ §õíãîÃô‹óñ÷ $Æè><Ìè¼éîüŠë,) Returns a reference to this entry's key.Á»ëútÃë’ÎÖëú<ÞëâÇÜêëÂΊìúü’ì5¤‚ üÌì(ô† œùì⇠ü‘í;8 assert_eq!(map.entry("poneyland").key(), &"poneyland");Á´ÑíÓ† üìí;8 assert_eq!(map.entry("horseland").key(), &"horseland");Á<¬îâÇðî¯ ¯³ 
¯õíÛ  ôîÛ
è §õíãîÃô‹ó$õîüõMüšðDA Provides in-place mutable access to an occupied entry before anyÁüãð# potential inserts into the map.Á‹ñút“ñ’Φñú<®ñâÇܺñÂÎÚñúüâñ5¤‚ œòúÔ¤ò map.entry("poneyland")ÁüÃò# .and_modify(|e| { *e += 1 })Á´ëò .or_insert(42);Áü†ó%" assert_eq!(map["poneyland"], 42);Á°óúÔ¸óê£ ü×ó#¤ ´ÿó¼¤ üšô%" assert_eq!(map["poneyland"], 43);Á<ÄôâÇTˆõ³ 
ñ÷ ³ 
Û ê ê Û »ø “õ°–"ñ÷  °ãît¿õ°ñ÷ ݧ ˜"
é §õíãîÃô‹óñ÷ $–õ± œõtvü‹„eü¾÷FC Provides shared access to the key and owned access to the value ofÁü‰øEB an occupied entry and allows to replace or remove it based on theÁüÓø! value of the returned option.Áùøútù’Δùú<œùâÇܨùÂÎüÈù# use hashbrown::hash_map::Entry;Áðùúüøù5¤‚ ²úúœºú let entry = mapÁÜÒú .entry("poneyland")Áüòú30 .and_replace_entry_with(|_k, _v| panic!());ÁªûúŒ²û match entry {ÁìÈû Entry::Vacant(e) => {Áüêû.+ assert_eq!(e.key(), &"poneyland");ÁLü¹Üü«ü'$ Entry::Occupied(_) => panic!(),Á,×üˆØáüúüéü  map.insert("poneyland", 42);ÁŽýúœ–ýÁª Ü®ýÞª üÎý(% .and_replace_entry_with(|k, v| {Áüûý(% assert_eq!(k, &"poneyland");Áô¨þ assert_eq!(v, 42);Á¼Ëþ Some(v + 1)Á\çþ });Á÷þúŒÿþΫ ü•ÿ Entry::Occupied(e) => {Áü¹ÿ.‘¬ üìÿ%" assert_eq!(e.get(), &43);ÁL–€¹Üü¤€%" Entry::Vacant(_) => panic!(),Á,΀ˆØØ€úüà€%Å¥ Šúœ’Áª ܪÞª üÊ/, .and_replace_entry_with(|_k, _v| None);ÁþúŒ†‚Ϋ üœ‚>; Entry::Vacant(e) => assert_eq!(e.key(), &"poneyland"),Áüß‚'ج ,‹ƒˆØ•ƒúüƒ,) assert!(!map.contains_key("poneyland"));Á<΃âÇ´’„³ 
ñ÷ ³ 
Û ì ì Û »ø ©„±–"ñ÷  ±õíãîÔÕ„±ñ÷ ¹µ ˜"Û¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙãîLæ„
ë §õíãîÃô‹óñ÷ $¬„± ²„ÀÂü׆4üІHE Converts the `Entry` into a mutable reference to the underlying map.ÁDÞ†³ 
ÂùÛ Û
í §õíãîÃô‹ó$ç†üšˆ>§ï œð §ñ ¤ò ó ò ð ñ ï ó ¶… £ˆÇ… ¦ˆíŸ
²ˆÉ
µˆ³ãî<©ˆÛ
L¸ˆ³ 
ô ŸˆHJLNPRTVüÞWü߈LI Ensures a value is in the entry by inserting the default value if empty,Áü°‰> ó‰útû‰’ÎŽŠú<–ŠâÇÜ¢ŠÂΊúüÊŠ=: let mut map: HashMap<&str, Option<u32>> = HashMap::new();ÁŒ‹ú´”‹Ó† ü¯‹(% map.entry("poneyland").or_default();ÁüÜ‹'$ assert_eq!(map["poneyland"], None);ÁˆŒúüŒ%" map.insert("horseland", Some(3));ÁºŒúœÂŒ⇠üÚŒB? assert_eq!(map.entry("horseland").or_default(), &mut Some(3));Áâdz 
œ— î î Ùú$˜Ž­… \©Ž
ô §õíãîÃô‹óüâ=§ö œ÷ §ø ¤ù ú ÷ ù ú ø ö ¶… ëÇ… îíŸ
ñÉ
ôÛ
´¡
û ü ý þ ÿ €
ƒ
ˆ
çXZ\^`bdf¼—”ü¦-* Gets a reference to the key in the entry.ÁØú’ÎóúâÇü‡‘.¯£
º‘úü‘5¤‚ üü‘)& map.entry("poneyland").or_insert(12);Áª’úü²’" match map.entry("poneyland") {ÁüÙ’%ϰ üƒ“HE Entry::Occupied(entry) => assert_eq!(entry.key(), &"poneyland"),Á,ГˆØ<Ú“âÇž”² ²´¡
²õíõ  ¢”õ
û §õíãîÃô‹ó$£”üäœNüå”1. Replaces the key in the entry with a new one.Á›•úd£•ƒ”´•úü¼•JG This method panics if `key` is not equivalent to the key in the entry.Á‹–út“–’Φ–ú<®–âÇüº–.¯£
í–úüõ–5¤‚ ¯—úô·— let old_key = "poneyland";ÁüÚ—A> let new_key = Box::leak(old_key.to_owned().into_boxed_str());Áü ˜%" map.entry(old_key).or_insert(12);Áüʘ# match map.entry("poneyland") {Áüò˜%ϰ üœ™'$ Entry::Occupied(mut entry) => {ÁüÈ™63 let replaced = entry.replace_key(new_key);Áüƒš52 assert!(std::ptr::eq(replaced, old_key));Áü½š96 assert!(std::ptr::eq(*entry.key(), new_key));ÁTûš»£,Š›ˆØ”›úüœ›,) # // appease miri; no memory leaks here!Á„Í›
# drop(map);Átâ› # unsafe {Áüõ›! # Box::from_raw(new_key);Á<›œý£<§œâÇ\뜳 ³´¡
õíõíõ  ÷œõ  õíõí
ü §õíãîÃô‹ó$üœïTüí«;üÀŸFC Replaces the key in the entry with a new one, without checking theÁÜ‹  equivalence of the key.Á« úd³ éöÄ úüÌ IF This operation is safe if you replace the key with an equivalent one.Áš¡úü¢¡JG Additionally, this operation (and following operations) are guaranteedÁüñ¡! to not violate memory safety.Á—¢úüŸ¢J’Ãüî¢DçÃü·£EB correctly. If the map has keys at unexpected positions inside it,Áü¤LI future operations may panic, loop forever, or return unexpected results,ÁüÒ¤(% potentially violating memory safety.Áÿ¤út‡¥’Κ¥ú<¢¥âÇü®¥.¯£
á¥úüé¥5¤‚ £¦úô«¦ÇÆ üΦAðÆ ü”§%¼Ç ü¾§#ìÇ üæ§%ϰ ü¨'©È ü¼¨KH let replaced = unsafe { entry.replace_key_unchecked(new_key) };ÁüŒ©5œÉ üÆ©9ÜÉ T„ª»£,“ªˆØªúü¥ª,ÉÊ „ÖªÿÊ tëª™Ë üþª!²Ë <¤«ý£<°«âǬû«´ ´´¡
õíõíõ  ‘¬õ
ý §õíãîÃô‹ó$–¬ïTœ¬ü¨³#üö¬96 Take the ownership of the key and value from the map.Áü´­)Ÿöâ­útê­’Îý­ú<…®âÇÜ‘®ÂÎü±®#ë© Ù®úüá®5¤‚ ¼›¯‚Úü·¯3¤Úï¯úü÷¯)µÁ ¥°úü­°85 if let Entry::Occupied(o) = map.entry("poneyland") {Áüê°,) // We delete the entry from the map.Áü›±85 assert_eq!(o.remove_entry(), ("poneyland", 12));Á,رˆØâ±úüê±52 assert_eq!(map.contains_key("poneyland"), false);Áü¤²!„âäʲ¨Ü<ë²âÇd¯³´¡
Û€õ õ
þ §õíãîÃô‹ó$¼³¼¸ü‘´/, Gets a reference to the value in the entry.ÁÅ´útÍ´’Îà´ú<è´âÇÜô´ÂÎü”µ#ë© ¼µúüĵ5¤‚ üþµ)µÁ ¬¶úü´¶"öÁ üÛ¶%ϰ ü…·?< Entry::Occupied(entry) => assert_eq!(entry.get(), &12),Á,É·ˆØ<Ó·âÇ—¸µ µ´¡
µãîõ  ›¸õ
ÿ §õíãîÃô‹ó$œ¸üÓ¿#üÞ¸74 Gets a mutable reference to the value in the entry.Áš¹úü¢¹HE If you need a reference to the `OccupiedEntry` which may outlive theÁüï¹74 destruction of the `Entry` value, see [`into_mut`].Á«ºúü³º" [`into_mut`]: #method.into_mutÁÚºút⺒Îõºú<ýºâÇ܉»ÂÎü©»#ë© Ñ»úüÙ»5¤‚ ü“¼)µÁ Á¼úüɼ%" assert_eq!(map["poneyland"], 12);Áüó¼<9 if let Entry::Occupied(mut o) = map.entry("poneyland") {ÁÜ´½ *o.get_mut() += 10;ÁüÔ½! assert_eq!(*o.get(), 22);Áú½úü‚¾41 // We can use the same Entry multiple times.ÁÔ»¾ *o.get_mut() += 2;Á,Ú¾ˆØä¾úüì¾%" assert_eq!(map["poneyland"], 24);Á<–¿âÇ<Ú¿ ´¡
 ãîõ  â¿õ
§õíãîÃô‹ó$ç¿ü‰Ç"ü±ÀSP Converts the `OccupiedEntry` into a mutable reference to the value in the entryÁü‰Á,) with a lifetime bound to the map itself.ÁºÁúüÂÁLI If you need multiple references to the `OccupiedEntry`, see [`get_mut`].Á“Âúü›Â  [`get_mut`]: #method.get_mutÁÀÂútÈÂ’ÎÛÂú<ãÂâÇüïÂ.¯£
¢ÃúüªÃ5¤‚ üäÃ)µÁ ’ÄúüšÄ%ðâ ÄÄúÄÌÄ let value: &mut u32;ÁüéÄ"öÁ üÅ;8 Entry::Occupied(entry) => value = entry.into_mut(),ÁüÐÅ%ϰ ,úň،„Æ *value += 10;ÁšÆúü¢Æ%" assert_eq!(map["poneyland"], 22);Á<ÌÆâÇDÇ´¡
œ— õ õ
§õíãîÃô‹ó$™Çü×Ï-üæÇB? Converts the `OccupiedEntry` into a reference to the key and aÁü­ÈLI mutable reference to the value in the entry with a lifetime bound to theÁ|þÈ map itself.Á’ÉúüšÉKH If you need multiple references to the `OccupiedEntry`, see [`key`] andÁ„êÉ
[`get_mut`].ÁÿÉú´‡Ê [`key`]: Self::keyÁô¢Ê [`get_mut`]: Self::get_mutÁÅÊútÍÊ’ÎàÊú<èÊâÇüôÊ.¯£
§Ëúü¯Ë5¤‚ üéË)µÁ —ÌúüŸÌ%ðâ ÉÌúüÑÌ# let key_val: (&&str, &mut u32);ÁüùÌ"öÁ ü Í?< Entry::Occupied(entry) => key_val = entry.into_entry(),ÁüäÍ%ϰ ,ŽÎˆØ¬˜Î *key_val.1 += 10;Á²ÎúüºÎ1. assert_eq!(key_val, (&"poneyland", &mut 22));ÁüðÎ%‡ì <šÏâÇTÞÏ´¡
—— õ õ
§õíãîÃô‹ó$éÏüøÔ'üÝÐC@ Sets the value of the entry, and returns the entry's old value.Á¥Ñút­Ñ’ÎÀÑú<ÈÑâÇÜÔÑÂÎüôÑ#ë© œÒúü¤Ò5¤‚ üÞÒ)µÁ ŒÓúü”Ó< ã üÕÓ%" assert_eq!(o.insert(15), 12);Á,ÿӈ؉Ôúü‘Ô%" assert_eq!(map["poneyland"], 15);Á<»ÔâÇ4ÿÔ· ·´¡
ãîãîõ  †Õõ
ƒ
§õíãîÃô‹ó$‹Õ»,‘ÕÄÁÛüÙÕ52 Takes the value out of the entry, and returns it.Áü“Ö)ŸöÁÖútÉÖ’ÎÜÖú<äÖâÇÜðÖÂÎü×#ë© ¸×úüÀ×5¤‚ ¼úׂÚü–Ø3¤ÚÎØúüÖØ)µÁ „ÙúüŒÙ8ÚØ üÉÙ# assert_eq!(o.remove(), 12);Á,ñÙˆØûÙúüƒÚ5²Ú ü½Ú!„âäãÚ¨Ü<„ÛâÇ4ÈÛ´¡
ãîõ õ
§õíãîÃô‹ó$ÏÛüèçrü…ÜFÚ§ üÐÜ=: the entry and allows to replace or remove it based on theÁü’Ý!û¨ ¸ÝútÀÝ’ÎÓÝú<ÛÝâÇÜçÝÂÎü‡Þ#ë© ¯Þúü·Þ5¤‚ üñÞ ¥­ –ßúüžß.+ let entry = match map.entry("poneyland") {ÁüÑßد üõß)& e.replace_entry_with(|k, v| {Áü£à,) assert_eq!(k, &"poneyland");ÁüÔà" assert_eq!(v, 42);ÁÜûà Some(v + 1)Át›á })ÁL®á¹Üü¼á%ϰ 4æáþÃ
ñáúŒùáΫ üâد ü³â.‘¬ üæâ%‘° Lã¹Üüžã%ϰ ,ÈãˆØÒãúüÚã%Å¥ „äúüŒä.µþ ü¿äB? Entry::Occupied(e) => e.replace_entry_with(|_k, _v| None),Áü†å%ϰ 4°åþÃ
»åúŒÃåΫ ìÙåé« üûå.‘¬ L®æ¹Üü¼æ'ج ,èæˆØòæúüúæ,š³ <«çâÇ”ïç´¡
ñ÷ ³ 
õ 

õ »ø ‚踖"ñ÷  ¸õíãîÔ¿è¸ñ÷ ù…
˜"æµ LÐè
§õíãîÃô‹óñ÷ $…è± ‹è{}tÿé
ӏ
­è
Ëè



õíãîÃô‹óñ÷ Û€Ôõ ñ÷ Û¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙõíü“ï4ü¾îPM Converts the `OccupiedEntry` into a mutable reference to the underlying map.ÁDšï´¡
Âùõ õ
ˆ
§õíãîÃô‹ó$£ïüæï;§Š
œ
§Œ
¤
Ž
Š

Ž
Œ
¶… ïïÇ… òïíŸ
õïÉ
øïÛ
Lûï¡¢
ëïCEGIKMOQ¼§óü¨ðIF Gets a reference to the key that would be used when inserting a valueÁôöð through the `VacantEntry`.Á™ñút¡ñ’δñú<¼ñâÇÜÈñÂÎèñúüðñ5¤‚ üªò;ÙŸ <êòâÇ®ó¹ ¹¡¢
¹õí
 ²ó
§õíãîÃô‹ó$³óÔŽ÷ôÞó Take ownership of the key.Áôút‰ô’Μôú<¤ôâÇü°ô.¯£
ãôúüëô5¤‚ ¥õúü­õ"öÁ üÔõ'ج ü€öB? Entry::Vacant(v) => assert_eq!(v.into_key(), "poneyland"),Á,ÇöˆØ<ÑöâÇD•÷¡¢
õí

§õíãîÃô‹ó$ž÷üÁû]üÇ÷?< Sets the value of the entry with the [`VacantEntry`]'s key,Áü‹ø*' and returns a mutable reference to it.ÁºøútÂø’ÎÕøú<ÝøâÇÜéøÂÎü‰ù#ë© ±ùúü¹ù5¤‚ óùúüûù63 if let Entry::Vacant(o) = map.entry("poneyland") {Á¬¶ú o.insert(37);Á,ÐúˆØüÚú%" assert_eq!(map["poneyland"], 37);Á<„ûâÇ4Èû¡¢
ã 

Ùú$ü­… \’ü
§õíãîÃô‹ó$Ïû»,Õûü–‚wü—þ?Î
üÛþ%ÇŠ …ÿútÿ’Πÿú<¨ÿâÇÜ´ÿÂÎüÔÿ#ë© üÿúü„€5¤‚ ¾€úüÆ€63 if let Entry::Vacant(v) = map.entry("poneyland") {Áü# let o = v.insert_entry(37);Áü©! assert_eq!(o.get(), &37);ÁˆØâÇd¡¢
ãî´¡


Ùú$ð‚­… \ƒ
§õíãîÃô‹ó$ª‚»,°‚ü4üº…NK Converts the `VacantEntry` into a mutable reference to the underlying map.ÁD”†¡¢
Âù

§õíãîÃô‹ó$üà†N§
ƒ>
œ
¢˜
§
¤š


š
˜



ŽÝ
토Ý
ð†²Ý
û†ÄÝ
þ†ÖÝ
èÝ
L„‡¿Þ
œ
ž
 
¢
£
¥
å†é†Y[]_acegikü½Šüµ‡@ˆ ú‡út‚ˆ’Εˆú<ˆâÇÜ©ˆÂÎɈúüш74 let mut map: HashMap<String, u32> = HashMap::new();Áü74 let entry = map.entry_ref("horseyland").insert(37);Áɉúüщ*' assert_eq!(entry.key(), "horseyland");Á<€ŠâÇ4ÄŠ¿Þ
÷Êß


še÷$‘‹²‡÷”¢‹‡÷³÷Lª‹Åe“÷\Á‹
œ
§ƒ>÷‡÷÷“÷™÷$ËŠ»,ÑŠü”’ü¸Rû„ üŽ2ÂÎÆŽútÎŽ’ÎáŽú<éŽâÇÜõŽÂÎúü7óœ
Ùú´áÓ† üü,) map.entry_ref("poneyland").or_insert(3);Áü­$§‡ ÖúœÞ⇠üö30 *map.entry_ref("poneyland").or_insert(10) *= 2;Áü®‘$ºˆ <בâÇL›’¿Þ
÷ §÷

úŸ
$Ù’ 
”ê’œ 
Lò’° 
\‰“
§ƒ>÷‡÷÷“÷™÷$¥’><«’ü™˜ü¿”]§ ü¡•> ä•útì•’Îÿ•ú<‡–âÇÜ“–Âγ–úü»–7óœ
÷–ú´ÿ–Ó† üš—41 map.entry_ref("poneyland").or_insert_with(|| 3);ÁüÓ—$§‡ ü—úœ„˜⇠üœ˜;8 *map.entry_ref("poneyland").or_insert_with(|| 10) *= 2;Áüܘ$ºˆ <…™âÇtÉ™¿Þ
ü£

Ÿ
Ÿ

Í섨
Ø™"„¨
lÛ™„¨
˜"÷ ç™úŸ
$žš 
”¯šœ 
L·š° 
\Κ
ž
§ƒ>÷‡÷÷“÷™÷„¨
$ê™><ð™ü¡¢ªü†œ_ë” üêœ_Õ• üÎ74 function an access to the borrower form of the key.ÁŠžút’ž’Î¥žú<­žâÇܹžÂÎÙžúüáž96 let mut map: HashMap<String, usize> = HashMap::new();ÁŸŸú´§ŸÓ† üŸMJ map.entry_ref("poneyland").or_insert_with_key(|key| key.chars().count());Áü” $Óš ½ úœÅ ⇠üÝ XU *map.entry_ref("poneyland").or_insert_with_key(|key| key.chars().count() * 10) *= 2;Áüº¡%ü› <ä¡âÇ”¨¢¿Þ
„¨
ü£

¡
¡

­¨
»¢º–"„¨
 º‡÷|¾¢º„¨
Ô®
˜"÷ Ì¢úŸ
$ƒ£§ë
LŠ£ 
” £œ 
L¨£° 
\¿£
 
§ƒ>÷‡÷÷“÷™÷„¨
$Ï¢><Õ¢®°ü­©7üÂ¥,¥ž ó¥útû¥’Îަú<–¦âÇÜ¢¦ÂΦúüʦ7óœ
ü†§,¢¡
œ·§⇠üϧ>; assert_eq!(map.entry_ref("poneyland").key(), "poneyland");Á´’¨Ó† ü­¨>; assert_eq!(map.entry_ref("horseland").key(), "horseland");Á<ð¨âÇ´©» »¿Þ
»‡÷
 ¸©
§ë
LÚ©
¢
§ƒ>÷‡÷÷“÷™÷$¹©ü‚°Mü‘«D¢ üÚ«#Т ‚¬útЬ’Î¬ú<¥¬âÇܱ¬ÂÎѬúüÙ¬7óœ
•­úô­ map.entry_ref("poneyland")ÁüÀ­#¤ ´è­¼¤ üƒ®%ݤ ­®úôµ®ä³
üØ®#¤ ´€¯¼¤ ü›¯%Å¥ <ůâÇT‰°¿Þ
„¨
¿Þ

¤
¤

­¨
”°¼–"„¨
 ¼÷tÀ°¼„¨
ê¶
˜"
£
§ƒ>÷‡÷÷“÷™÷„¨
$—°± °~ü›³4ü˲KH Converts the `EntryRef` into a mutable reference to the underlying map.ÁD¢³¿Þ
§áø


¥
§ƒ>÷‡÷÷“÷™÷$«³üä´W§§
ƒ>¨
ϩ
¢ª
§«
¤¬
­
«
©
§
­
¬
¨
ª
ŽÝ
ñ´ Ý
ô´²Ý
ÿ´ÄÝ
‹µÖÝ
޵³÷<‚µèÝ
L‘µ¿Þ
®
¯
é´í´[]_acegikmü׺vüµL޹ ü“¶> Ö¶útÞ¶’Îñ¶ú<ù¶âÇÜ…·ÂÎ¥·úü­·?< let mut map: HashMap<String, Option<u32>> = HashMap::new();Áñ·ú´ù·Ó† ü”¸,) map.entry_ref("poneyland").or_default();ÁüŸ'Û» ñ¸úüù¸1. map.insert("horseland".to_string(), Some(3));Á¯¹úœ·¹⇠üϹFC assert_eq!(map.entry_ref("horseland").or_default(), &mut Some(3));Á<šºâÇTÞº¿Þ
ü£
¦
¦
úŸ
$‘» 
”¢»œ 
Lª»° 
\Á»
®
§ƒ>÷‡÷÷“÷™÷$éºü…Ãü‚½L޹ üÓ½%ÇŠ ý½út…¾’Θ¾ú< ¾âÇܬ¾ÂÎ̾úüÔ¾?¾»
˜¿ú´ ¿Ó† ü»¿>; let entry = map.entry_ref("poneyland").or_default_entry();Áüþ¿*·Œ ü­À# assert_eq!(entry.get(), &None);ÁÕÀúœÝÀ⇠üõÀ1ö¼
ü«Á>; let entry = map.entry_ref("horseland").or_default_entry();ÁüîÁ*' assert_eq!(entry.key(), &"horseland");ÁüÂ&# assert_eq!(entry.get(), &Some(3));Á<ÈÂâÇ„ŒÃ¿Þ
Êß
¦
¦
úŸ
$Ùà
”êÜ 
Lòð 
\‰Ä
¯
§ƒ>÷‡÷÷“÷™÷$ÃüÃÅ\ìV±
øV²
œ³
¢´
§µ
¤
·
´
²

·
µ
±
³
ŽÝ
ÔÅ Ý
×ŲÝ
âÅÄÝ
åÅÖÝ
èÅèÝ
LëŤö
¸
¹
º
»
¼
½
¾
¿
$ÈÅ$ÎÅ\^`bdfhjlnäÊÉü¦ÆI׊
üôÆ! through the `VacantEntryRef`.ÁšÇút¢Ç’εÇú<½ÇâÇÜÉÇÂÎéÇúüñÇ7óœ
ü­È  let key: &str = "poneyland";ÁüÒÈ63 assert_eq!(map.entry_ref(key).key(), "poneyland");Á<ÉâÇÑɽ ½¤ö
¸ø
°
 Õɰ
¸
ìVøV÷‡÷÷“÷™÷$ÖÉü©Î~ü…Ê@= Sets the value of the entry with the `VacantEntryRef`'s key,ÁüÊÊ*˜‘
ùÊút˒ΔËú<œËâÇܨËÂÎüÈË&# use hashbrown::hash_map::EntryRef;ÁóËúüûË7óœ
ü·Ì ‡È
ÜÌúüäÌ52 if let EntryRef::Vacant(o) = map.entry_ref(key) {Á¬žÍ‰“
,¸ÍˆØüÂÍ%·“
<ìÍâÇ4°Î¤ö
÷ ìV÷°
°
úŸ
$ëΠ
”üΜ 
L„ϰ 
\›Ï
¹
ìVøV÷‡÷÷“÷™÷$·Î»,½ÎüŸÚŠü«ÑJG Sets the key and value of the entry and returns a mutable reference toÁ¼úÑ the inserted value.Á–ÒúüžÒGD Unlike [`VacantEntryRef::insert`], this method allows the key to beÁüêÒLI explicitly specified, which is useful for key types that don't implementÁt»Ó `ToOwned`.ÁÎÓúdÖÓƒ”çÓúüïÓKH This method panics if `key` is not equivalent to the key used to createÁÌ¿Ô the `VacantEntryRef`.ÁÝÔúlåÔ
# ExampleÁ÷Ôú<ÿÔâÇü‹Õ&¡Ë
ܶÕÂÎÖÕúüÞÕ;8 let mut map = HashMap::<(String, String), char>::new();ÁüžÖ/, let k = ("c".to_string(), "C".to_string());ÁüÒÖ&# let v = match map.entry_ref(&k) {ÁüýÖLI // Insert cannot be used here because tuples do not implement ToOwned.ÁüÎ×B? // However this works because we can manually clone instead.Áü•Ø?< EntryRef::Vacant(r) => r.insert_with_key(k.clone(), 'c'),ÁüÙØ+( // In this branch we avoid the clone.Áü‰Ù,) EntryRef::Occupied(r) => r.into_mut(),Á4ºÙþÃ
ÄÅÙ assert_eq!(*v, 'c');Á<âÙâÇ|¦Ú¤ö
÷÷¡Î
°
°
úŸ
$òÚ ‡÷÷lƒÛ° 
\Û
º
ìVøV÷‡÷÷“÷™÷$¶ÚïT¼Ú»,ÄÚü¹çüõÛJ©Î
üÄÜDA the inserted value, without checking the equivalence of the key.ÁÝúü•ÝHE See [`insert_with_key`](Self::insert_with_key) for more information.ÁâÝúdêÝéöûÝúüƒÞ63 This operation is safe if the keys are equivalent.Á¾ÞúüÆÞJÏ ü•ß!åÏ »ßúüÃßJ’Ãü’àDçÃüÛàE¼Ð ü¥áLŒÑ üöá(ãÑ £âúl«âšÒ
½âú<ÅââÇüÑâ&¡Ë
ÜüâÂΜãúü¤ã;÷Ò
üäã/½Ó
ü˜ä&÷Ó
üÃäRO // SAFETY: We trust the `Clone` implementation to return an equivalent valueÁüšåTQ EntryRef::Vacant(r) => unsafe { r.insert_with_key_unchecked(k.clone(), 'c') },Áüóå+–Ö
ü£æ,ÌÖ
4ÔæþÃ
Äßæ×
<üæâÇÌÇç¤ö
÷÷¡Î
°
°
úŸ
$è° 
\®è
»
ìVøV÷‡÷÷“÷™÷$áçïTçç»,ïçüÑí˜üÄéB? Sets the value of the entry with the [`VacantEntryRef`]'s key,Áü‹ê%ÇŠ µêút½ê’ÎÐêú<ØêâÇÜäêÂÎü„ë&¡Ë
¯ëúü·ë5¤‚ ñëúüùë>; if let EntryRef::Vacant(v) = map.entry_ref(&"poneyland") {Áü¼ì#Ж
üäì!þ–
,ŠíˆØ<”íâÇdØí¤ö
÷²²ÜR¸§˜¹¡S˜ºæ˜£Ü,·s6úìV÷÷“÷™÷°
°
úŸ
$­î 
”¾îœ 
LÆî° 
\Ýî
¼
ìVøV÷‡÷÷“÷™÷$åí»,ëíüþù¤ü¡ñIF Sets the key and value of the entry and returns an [`OccupiedEntry`].Áïñúü÷ñJG Unlike [`VacantEntryRef::insert_entry`], this method allows the key toÁüÆòEB be explicitly specified, which is useful for key types that don'tÁÄó implement `ToOwned`.Á­óúdµóƒ”ÆóúüÎóK•Ñ
ÌžôêÑ
¼ôúlÄôšÒ
Öôú<ÞôâÇüêô&¡Ë
Ü•õÂεõúü½õ;÷Ò
üýõ/½Ó
ü±ö%" let r = match map.entry_ref(&k) {ÁüÛöL¨Ô
ü¬÷BÿÔ
üó÷EB EntryRef::Vacant(r) => r.insert_entry_with_key(k.clone(), 'c'),Áü½ø+–Ö
üíø! EntryRef::Occupied(r) => r,Á4“ùþÃ
ôžù assert_eq!(r.get(), &'c');Á<ÁùâǬ…ú¤ö
÷÷¼ä
°
°
úŸ
$ëú€Ù
lüú° 
\–û
½
ìVøV÷‡÷÷“÷™÷$›úïT¡ú»,©úü‰ ºüÈýIF Sets the key and value of the entry and returns an [`OccupiedEntry`],Áü–þ0- without checking the equivalence of the key.ÁËþúüÓþTQ See [`insert_entry_with_key`](Self::insert_entry_with_key) for more information.Á¬ÿúd´ÿéöÅÿúüÍÿ6ÕÚ
ˆ€ úü€ JÏ ü߀ !åÏ  úü J’ÃüÜ DçÃü¥‚ E¼Ð üï‚ LŒÑ üÀƒ (ãÑ íƒ úlõƒ šÒ
‡„ ú<âÇü›„ &¡Ë
ÜÆ„ ÂÎæ„ úüî„ ;÷Ò
ü®… /½Ó
üâ… %€é
üŒ† PM // SAFETY: We trust the `Clone` implementation to return an equivalent keyÁüᆠZW EntryRef::Vacant(r) => unsafe { r.insert_entry_with_key_unchecked(k.clone(), 'c') },ÁüÀ‡ +–Ö
üð‡ !­ê
4–ˆ þÃ
ô¡ˆ æê
<Ĉ âÇü¤ö
÷÷¼ä
°
°
úŸ
$žŠ ° 
\¯Š 
¾
ìVøV÷‡÷÷“÷™÷$¸‰ ïTƉ »,Ö‰ ü¹ 6ü㌠QN Converts the `VacantEntryRef` into a mutable reference to the underlying map.ÁDÀ ¤ö
Ûø
°
°
¿
ìVøV÷‡÷÷“÷™÷ üŽŽ œÁ
§Â
¤Ã
Ä
Ã
Á
Ä
Â

Òù “Ž ãù –Ž ôù ™Ž …ú œŽ Û‘ÙŽ ì‘$ÞŽ á€\ëŽ –ó<ùŽ §ó<‰ –úL“ ´ìÅ
ÅLÅ
egikmoqsüÕ = ¥´ìÀ
¥Æ
Æ
À
Íìêø
â ÇLêø
Üå êø
ÈL 
Å
ììòìøìþìêø
ù$ LNDÅ‘ Å
”èÇ
­èÇ
菂
Ç
Å
Ç
ììòìøìþìêø
³³  ´ìü—“ uü RO Inserts all new key-values from the iterator and replaces values with existingÁüâ’ 41 keys with new values returned from the iterator.ÁœÉ
§Ê
¤Ë
Ì
Ì
Ê
É
Ë
Òù œ“ ãù Ÿ“ ôù ¢“ …ú ¥“ Û‘Ü“ ì‘$á“ á€\î“ –úL‚” ´ìÍ
ÒLÍ
SUWY[]_aüŸ =ü“” SP Inserts all new key-values from the iterator to existing `HashMap<K, V, S, A>`.Áüë” QN Replace values with existing keys with new values returned from the iterator.ÁÁ• útÉ• ’ÎÜ• ú<ä• âÇüð• %" use hashbrown::hash_map::HashMap;Áš– úü¢– !Ȗ  map.insert(1, 100);Áä– úüì– 1. let some_iter = [(1, 1), (2, 2)].into_iter();ÁÔ¢—  map.extend(some_iter);ÁüÁ— TQ // Replace values with existing keys with new values returned from the iterator.Áüš˜ 96 // So that the map.get(&1) doesn't return Some(&100).Áüؘ &# assert_eq!(map.get(&1), Some(&1));Áƒ™ úü‹™ 0- let some_vec: Vec<_> = vec![(3, 3), (4, 4)];ÁÌÀ™  map.extend(some_vec);ÁÞ™ úüæ™ $! let some_arr = [(5, 5), (6, 6)];ÁÌš  map.extend(some_arr);Áü­š  let old_map_len = map.len();ÁÒš úüÚš /, // You can also extend from another HashMapÁüŽ› %" let mut new_map = HashMap::new();Áĸ›  new_map.extend(map);ÁüÕ› +( assert_eq!(new_map.len(), old_map_len);Á…œ úüœ 85 let mut vec: Vec<_> = new_map.into_iter().collect();ÁüÊœ HÚž ü— @³ËÄÜ ‚·üù FC assert_eq!(vec, [(1, 1), (2, 2), (3, 3), (4, 4), (5, 5), (6, 6)]);Á<Äž âÇ4„Ÿ ¾ ¾´ìêø
È
¥Î
Î
 «Ÿ È
“ù
‹Ÿ ¥ù
ÜŽŸ ¶ù
l›Ÿ 
Í
ììòìøìþìêø
$°Ÿ ù$¶Ÿ ACl¸£ Í
”èÏ
­èÏ
ËèÏ
Ï
Í
Ï
ììòìøìþìêø
ãú
ïú
üšª •ü’© R‰ú
üå© 4æú
§Ñ
œÒ
§Ó
¤Ô
Õ
Õ
Ó
Ñ
Ô
Ò

¶… £ª Ç… ¦ª íŸ
©ª É
¬ª Èúëª Ùú$𪠊 õí$÷ª Š ãî$„« ­… \‘« Û
L¥« òøÖ
ÒLÖ
Ÿª |~ˆŠüŒ· Eü¶« Süü
üެ QÚý
üä¬ 63 The keys and values must implement [`Copy`] trait.ÁŸ­ út§­ ’κ­ ú<­ âÇüέ %ìþ
ø­ úü€® !î²¼¦® ·ÿ
® úüÊ®  let arr = [(1, 1), (2, 2)];Áüî® 41 let some_iter = arr.iter().map(|(k, v)| (k, v));ÁÔ§¯ ¡€üƯ TÆ€üŸ° 9¥üݰ &鈱 úü± 0§‚üű 52 map.extend(some_vec.iter().map(|(k, v)| (k, v)));Áÿ± úü‡² $’ƒü°² 52 map.extend(some_arr.iter().map(|(k, v)| (k, v)));Áê² úüò² /œ„ü¦³ %Ö„Ìг  new_map.extend(&map);Áìî³  assert_eq!(new_map, map);Á´ úü˜´ 8ë…üÕ´ HÚž ü¢µ @³ËÄçµ ‚·ü„¶ FÚ†<϶ âÇ4· ¿ ¿òø¥Ð
¥×
×
 ¾· Ð
ÍìÇ“ –· ÇLÇ“ü™· #Ç“ÈL³€¬¦· 
Ö
§õíãîÃô‹óÇ“$÷ ù$É· []„ý· Ö
”èØ
­èØ
華
Ø
Ö
Ø
õíãîÃô‹óÇ“±ó Û€üß» ‘ü׺ R‰ú
üª» 4æú
§Ú
œÛ
§Ü
¤Ý
Þ
Û
Þ
Ú
Ü
Ý

¶… è» Ç… ë» íŸ
î» É
ñ» Èú¬¼ Ùú$±¼ þ‹$¸¼ Œ$ż ­… \Ò¼ Û
Læ¼ òøß
ÒLß
ä» lnprtvxzüØÆ Aü÷¼ Süü
üϽ QÚý
ü¥¾ 6«Œྠútè¾ ’Îû¾ ú<ƒ¿ âÇü¿ %ìþ
¹¿ úüÁ¿ !î²¼ç¿ ·ÿ
ƒÀ úü‹À èü¯À  let some_iter = arr.iter();ÁÔÓÀ ¡€üòÀ TÆ€üËÁ 9¥ü‰Â &é´Â úü¼Â 0§‚Ôñ  map.extend(&some_vec);Áà úü˜Ã $’ƒÔÁà  map.extend(&some_arr);Áàà úüèà 41 let mut vec: Vec<_> = map.into_iter().collect();Áü¡Ä HÚž üîÄ @³ËijŠ‚·üÐÅ FÚ†<›Æ âÇ4ÛÆ À ÀòøÇ“Ù
¥à
à
 †Ç Ù
ô“ âÆ †”üåÆ Ç“ÈLÕ€ŒòÆ 
ß
§õíãîÃô‹óÇ“$‹Ç ù$‘Ç SU|ÅÇ ß
”èá
­èá
Ëèá
á
ß
á
õíãîÃô‹óÇ“ Û€Û€´®Ê Œ±Ê ˜
â
üËÊ H<ÎÊ ˜³³¸¼8¹æ­¼x¾spA ˜áöܳ³¸¼8¹æ­¼x¾spA ªo˜áöܪoä
ä
ã
ªoÁ ÜÊ $ÖÊ üªË H<­Ë ˜³³¸¼8¹æ­¼x¾spAŒ ˜áöܳ³¸¼8¹æ­¼x¾spAÓ ˜áöܪoæ
æ
å
ªoÁ »Ë $µË ü‰Ì ODŒÌ ˜è
òòíFöŸ˜÷Ú˜¶¨7g|°ßè
Œ òòíFöŸ˜÷Ú˜¶¨7g|°ßè
Ó ªoé
é
•Ì 
ç
ªoÁ ŸÌ $™Ì üïÌ ODòÌ ˜ë
òòíFöŸ˜÷Ú˜¶¨7g|°ßë
Œ òòíFöŸ˜÷Ú˜¶¨7g|°ßë
Ó ªoì
ì
ûÌ 
ê
ªoÁ …Í $ÿÌ üÕÍ slØÍ ˜æŸ˜¥K@¬žú‚ÄŒ ÞäæŸ˜¥K@¬žú‚ÄÓ Þäªoî
ï
ï
î
ÆÓ ìÍ ØÓLïÍ 
í
ªoÞäÁ ƒÎ $æÍ -/üßÎ slâÎ ˜æŸ˜¥K@¬žú‚ÄŒ ÞäæŸ˜¥K@¬žú‚ÄÓ Þäªoñ
ò
ò
ñ
ÆÓ öÎ ØÓLùÎ 
ð
ªoÞäÁ Ï $ðÎ -/üéÏ ODìÏ ˜ô
ááÁM埘ªåjND­Çžô
Œ ááÁM埘ªåjND­Çžô
Ó ªoõ
õ
õÏ 
ó
ªoÁ ÿÏ $ùÏ üÏÐ ODÒÐ ˜÷
ááÁM埘ªåjND­Çž÷
Œ ááÁM埘ªåjND­Çž÷
Ó ªoø
ø
ÛÐ 
ö
ªoÁ åÐ $ßÐ üµÑ UT¸Ñ ˜ú
îî§NòŸ˜$úDP¢ÐÜ©ú
Œ îî§NòŸ˜$úDP¢ÐÜ©ú
Ó ªoû
û
ÃÑ 
ù
ªoÁ ÍÑ $ÇÑ ü¡Ò UT¤Ò ˜ý
îî§NòŸ˜$úDP¢ÐÜ©ý
Œ îî§NòŸ˜$úDP¢ÐÜ©ý
Ó ªoþ
þ
¯Ò 
ü
ªoÁ ¹Ò $³Ò üÓ q,Ó ˜ûûOŸ˜Æ¢j—%Ä•Œ Œ öÜûûOŸ˜Æ¢j—%Ä•ªoÓ Ó öܪo 
ÿ
ªo¯ ¥Ó $–Ó 
ˆ ManuallyDropÁd<ÃÛ ƒ r,Té!  DerefMutÁD[ö!  µ j  $+Œ7[ü+&MO57%'üs"T…¥ Š  Š Š¿ ƒö Á“"ª Á¬âÁªŒµ˜"ì€ÃÈÒøn‰ê Œ   iknpL¸ ˆ ˆ ª ˆ ˆ ¬âüÞ^¬âªì€¥Ž   Ž Š¿ òƒö õ“"ª ¬âªŸ·˜"
¬âª»¼r4‚gilnüã7¥    ê ìâ˜"ƒö ëÓ"ª¾¸!Š¿ èì€  
79ü¯*쀬â 
¬âª£üžA¥   Ī Ĭâ˜"ƒö ¦Ä“"ª¨º!Š¿ £ì€ ˜ ê!ë!˜ FH  ¬â¬‰Å Åì€ Å¬â  
˜ ¬âª$“ü¾D¥š   š Æª Ƭâ˜"ƒö ÆÆ“"ªÕ¼!Š¿ Ã쀜 ÷!œ ?Aü— !Ç Çì€ Ç¬â  ¤ 
œ ¬âªüÜ @¥ž Ÿ ž Ÿ Ȫ Ȭâ˜"
ƒö ä È“"ªâ¾!Š¿ á 쀠 "  ?A”±
$´
É Éì€  ¹

  ¬âª

Á
¿ æ ê î ó ú
ˆ
Ž
ÝíøæT  ¡ £ ø»|¡ ¤
UnsafeCellÁT:î0¡ ¥ ×P `¡ ¦ \\fÅe¡ ¨ Ž$sše¡ © Ž e¡ © ChainÁ,‹ð¬¡ « ºl’òP¡ ¬ BitAndÁ4²öø¡ ® BitAndAssignÁdºÞ—¡ ¯ BitOrÁ,È–ú¡ ° BitOrAssignÁ\Ï•˜¡ ± BitXorÁ4ܶû¡ ² BitXorAssignÁdä̘¡ ³ SubÁòï¡ ´ SubAssignÁL÷œö¡ µ Ø$•˜¡ · <›³¡ ¸ ÁM$¤á¡ ¹ »¸”¶î¡ º À ¡ ¼ гª¡ ½
г«¡ ½
Ò5d¡ ¾ ,nq_b´.JLJ<TY/2!$T~ýìïÛ޿ª­y|]`JM14Tˆ% ̯üdÎéëÕ×Äõ¬üäDüûB? A hash set implemented as a `HashMap` where the value is `()`.Á¾úüÂHE As with the [`HashMap`] type, a `HashSet` requires that the elementsÁü‹PM implement the [`Eq`] and [`Hash`] traits. This can frequently be achieved byÁüÜLI using `#[derive(PartialEq, Eq, Hash)]`. If you implement these yourself,Áü©63 it is important that the following property holds:Áàú Çüð$µÇ<•âÇúü¡FÿÇèúìúüðIF It is a logic error for an item to be modified in such a way that theÁüº IF item's hash, as determined by the [`Hash`] trait, or its equality, asÁü„
KH determined by the [`Eq`] trait, changes while it is in the set. This isÁüÐ
OL normally only possible through [`Cell`], [`RefCell`], global state, I/O, orÁ„  
unsafe code.Á± úüµ OÅËü… NžÌüÔ PM panic does occur then the contents of the `HashSet` may become corrupted andÁü¥
-ÐÍÓ