Files
boc/aamos-ledger-rust/target/debug/deps/libbitflags-e5412d4fc4957378.rlib
T

1922 lines
441 KiB
Plaintext
Raw Normal View History

!<arch>
/ 0 0 0 0 2984 `
fþ_ZN153_$LT$core..result..Result$LT$T$C$F$GT$$u20$as$u20$core..ops..try_trait..FromResidual$LT$core..result..Result$LT$core..convert..Infallible$C$E$GT$$GT$$GT$13from_residual17h9a8ec36806a5fcffE_ZN4core10intrinsics23is_val_statically_known17h98d1472ce7779685E_ZN4core3ptr9const_ptr33_$LT$impl$u20$$BP$const$u20$T$GT$13is_aligned_to17h171bbbf150cc71d2E_ZN4core6result19Result$LT$T$C$E$GT$7map_err17h3ead8524a35017b7E_ZN4core6result19Result$LT$T$C$E$GT$7map_err17h420c786f87dabdcbE_ZN4core6result19Result$LT$T$C$E$GT$7map_err17h456d945770337dcdE_ZN4core6result19Result$LT$T$C$E$GT$7map_err17h8391b4cb0cbba5c5E_ZN4core6result19Result$LT$T$C$E$GT$7map_err17h875e18664fd6b1fbE_ZN4core6result19Result$LT$T$C$E$GT$7map_err17h98ae03020f96832eE_ZN4core6result19Result$LT$T$C$E$GT$7map_err17h9a77b8b8f4bfdd35E_ZN4core6result19Result$LT$T$C$E$GT$7map_err17ha2bb95f4cc5855bcE_ZN4core6result19Result$LT$T$C$E$GT$7map_err17ha3539344b1c5ccc1E_ZN4core6result19Result$LT$T$C$E$GT$7map_err17hc064f3afeef52338E_ZN4core6result19Result$LT$T$C$E$GT$7map_err17hd6bc8f0a787c4811E_ZN4core6result19Result$LT$T$C$E$GT$7map_err17hdc942cc557314bc0E_ZN67_$LT$bitflags..parser..ParseError$u20$as$u20$core..fmt..Display$GT$3fmt17h746103f31086af99E_ZN79_$LT$core..result..Result$LT$T$C$E$GT$$u20$as$u20$core..ops..try_trait..Try$GT$6branch17had5b24760129e614E_ZN8bitflags6parser10ParseError10empty_flag17he4be8bd89464707aE_ZN8bitflags6parser10ParseError16invalid_hex_flag17he0abac55bbdadcd0E_ZN8bitflags6traits59_$LT$impl$u20$bitflags..parser..ParseHex$u20$for$u20$i8$GT$9parse_hex17h2b997b3ead33e3e8E_ZN8bitflags6traits59_$LT$impl$u20$bitflags..parser..ParseHex$u20$for$u20$u8$GT$9parse_hex17hed1bad5f55bf2728E_ZN8bitflags6traits60_$LT$impl$u20$bitflags..parser..ParseHex$u20$for$u20$i16$GT$9parse_hex17h7f968bfa4fc714a5E_ZN8bitflags6traits60_$LT$impl$u20$bitflags..parser..ParseHex$u20$for$u20$i32$GT$9parse_hex17h22cb8234d8831715E_ZN8bitflags6traits60_$LT$impl$u20$bitflags..parser..ParseHex$u20$for$u20$i64$GT$9parse_hex17he8bd71c6d2f8c19eE_ZN8bitflags6traits60_$LT$impl$u20$bitflags..parser..ParseHex$u20$for$u20$u16$GT$9parse_hex17h394bb83bb277c0e0E_ZN8bitflags6traits60_$LT$impl$u20$bitflags..parser..ParseHex$u20$for$u20$u32$GT$9parse_hex17h6eb18cb8a2c37663E_ZN8bitflags6traits60_$LT$impl$u20$bitflags..parser..ParseHex$u20$for$u20$u64$GT$9parse_hex17ha5f6454dc5167c36E_ZN8bitflags6traits61_$LT$impl$u20$bitflags..parser..ParseHex$u20$for$u20$i128$GT$9parse_hex17hc0a710a1f564d0ecE_ZN8bitflags6traits61_$LT$impl$u20$bitflags..parser..ParseHex$u20$for$u20$u128$GT$9parse_hex17h8aecac5aef530b0fE_ZN8bitflags6traits62_$LT$impl$u20$bitflags..parser..ParseHex$u20$for$u20$isize$GT$9parse_hex17h2c450d76402629b0E_ZN8bitflags6traits62_$LT$impl$u20$bitflags..parser..ParseHex$u20$for$u20$usize$GT$9parse_hex17h283f2d3924bcbc7cEDW.ref.rust_eh_personality// 66 `
bitflags-e5412d4fc4957378.bitflags.dc63c78221e9541b-cgu.0.rcgu.o/
lib.rmeta/ 0 0 0 644 219736 `
ELF·ØX@@GNUÀrust
5V#rustc 1.96.0 (ac68faa20 2026-05-25)ÁíàÄTËŸ ÜJîÄ)'ß\¥!-3d1337db07d0b3aeÁ¤°ð ¾ä-±($²ï=©Ã-7e98a21bfd32b0edÁ‰@ AsDisplayÁL©»serdeÁŒƒÎŸ,»ŸŒßÎ arbitraryÁLûƬŸÎbytemuckÁDü»æ¤ÙÍŸ»ŸŒÍ__impl_external_bitflags_serdeÁôûŸŒ¢ÍÆL¤'»Æ¬„'ÍæDÑ'»æ¤¶'Í"__impl_external_bitflags_arbitraryÁüà("»Æ¬»(Í!__impl_external_bitflags_bytemuckÁü¥1!»æ¤1example_generatedÁŒÏ’»ñì§’testsÁ,ô’$é’íùIterÁ  innerÁ doneÁæ __private_const_newÁó  IterNamesÁflagsÁidxÁsourceÁ remainingÁæ ""­"š&&&ó IterDefinedNamesÁ**÷*ƒ..æ 111ó IterEqualNamesÁ5¥5ù5´9¥9æ  <¥<<ó parserÁ@@@@@@@ to_writerÁGG
impl WriteÁ@þJJ J @to_writer_truncateÁNNÖ@from_str_truncateÁQ@to_writer_strictÁSSÖ@from_str_strictÁVV @WriteHexÁY write_hexÁZ¨@ParseHexÁ\ parse_hexÁ@^invalid_hex_flagÁ_impl fmt::DisplayÁ^invalid_named_flagÁaé
^
empty_flagÁ@d×traitsÁffffffffff f
f f fttæ tÐ t»tis_namedÁt
is_unnamedÁfFlagsÁ{FLAGSÁ{BitsÁ{emptyÁ{£{ all_namedÁ  {
known_bitsÁ{ unknown_bitsÁ{contains_unknown_bitsÁ{´{ from_bitsÁ{from_bits_truncateÁ{from_bits_retainÁ{ from_nameÁ{ù{
iter_namesÁ{iter_defined_namesÁ{iter_equal_namesÁ{is_emptyÁ{is_allÁ{
intersectsÁ{containsÁ{truncateÁ{insertÁ{removeÁ{toggleÁ{setÁ{clearÁ{ intersectionÁ{C{
differenceÁ{symmetric_differenceÁ{
complementÁfÖ žEMPTYÁžALLÁf PrimitiveÁf impl_bitsÁf PublicFlagsÁ£ê£InternalÁfBitFlagsÁ¦ç¦àf©©ç©àf­fImplementedByBitFlagsMacroÁf __privateÁ°°°œ´´´´bitflagsÁ__impl_bitflagsÁbitflags_matchÁ__bitflags_matchÁ__bitflags_flagÁ__bitflags_expr_safe_attrsÁ__bitflags_item_safe_attrsÁ__bitflags_flag_nameÁÐ Ã__declare_public_bitflagsÁÃ__impl_public_bitflags_forwardÁÃ__impl_public_bitflagsÁÃ__impl_public_bitflags_iterÁÃ__impl_public_bitflags_opsÁÃ__impl_public_bitflags_constsÁåÊ__declare_internal_bitflagsÁÊ__impl_internal_bitflagsÁ©ÍœÍ__impl_external_bitflagsÁÍœÍÿ͹@
ParseErrorÁÓ
Óˆ@Ö×@ParseErrorKindÁØ EmptyFlagÁÙ
ØInvalidNamedFlagÁÛgotÁØInvalidHexFlagÁÝ÷@ß×fFlagÁááÐ á»fåå×fèÓèàfëÓëàfî¾
ï fñ¾
ò fô˜
õ¨f ÷˜
ø¨f
f f üÓüàf
ÿÓÿàf¾
ƒ f¾
 fˆ˜
¨f˜
Œ¨fffÓàfÓàf¾
 f¾
š fœ˜
¨fŸ˜
 ¨fff¤Ó¤àf§Ó§àfª¾
« f­¾
® f °˜
±¨f!³˜
´¨f"f#f$¸Ó¸àf%»Ó»àf&¾¾
¿ f'Á¾
 f(Ę
Ũf)ǘ
Ȩf*f+f,ÌÓÌàf-ÏÓÏàf.Ò¾
Ó f/Õ¾
Ö f0ؘ
Ù¨f1Û˜
ܨf2f3

!
%
)
4
;
?
G
J
N
Q
S
V
Z
]
e
e
e
w
x
y
z
ƒ



Š

Œ
Ž









˜
×
×
×
à
à
à
ç
ç
ç
ï
ò
õ
ø
ƒ


Œ

š

 
«
®
±
´
¿
Â
Å
È
Ó
Ö
Ù
Ü
Y\{ž¡£¦¯ùM  ç
ù5ÞÍq2§3ùMà÷ƒš£P|¸Û"ùM**î,÷-ƒýrµeÔVaÛ"ùM55Å7ù8´ò¶6ááÉ쥿cÓÓÔÕˆ@ …¨8/ùãà¿cØÙÚÉÛßÜ÷@ÝÞ÷@f™Æ¼
eÄc¹$¿cáá«ãÐ fä»fq $Û"žž\˜&\¢&Y˜&Y¢&¡¢&¡˜&žž\ä&\î&Yä&Yî&¡î&¡ä&žž\°'\º'Y°'Yº'¡º'¡°'žž\ü'\†(Yü'Y†(¡†(¡ü'žž\È(\Ò(YÈ(YÒ(¡Ò(¡È(žž\”)\ž)Y”)Yž)¡ž)¡”)¦Û"¯Û" &1*<ÓߨåádÓèëüÿ¤§¸»ÌÏîñª­¾ÁÒÕô÷ˆœŸ°³ÄÇØÛúûŽ¢£·ÊËÞß©­ùM¥¿cÄcž \ <Y <¡ <¦<¯¬Ç
!Û"$ü­S  Û"üþˆ§" Û",è"÷8Ó,Ÿüá8ôá
$Û",€4‡L3üÇv  Û",­Ãüàã§"$¸ 
Ö%,Û"Û"è"¤÷%)š-e€.ÛåÐÖÚàäê
&$€.O ˜1  Û"/ ¼60>§";ò.6Û"5Û"4è"×ò.ÄÛ"ÅÛ"Æ÷qvš{´è"Œ¾
ûMè"0(¼¸HLÛ Û"Û" Û¼Û" ú  Û¼Û"„±
 è"´·


%Û" .
ü·
!

Û"D
+
  Û¼Û"ü³
¤ˆ  è"Û"܈ $ 
Û" 3  4 üô
0ϙ

Û" F
 $üï
6 Û¼Û"
¡    


ü…œìÞÛ¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙÛ"”› §"LÛ¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙ¸3þ è"ž)Û"«Óû·-, è"LÛ"vÛ"}®·-Ïž)>»flagÁ
=Ã2Ç4ñ4næ5þ’6Ú$­æ5ü“!œ“6<æ5üÊ!œÊ’6=ü¿· Û"|Û"ò. ù”)ü õüì!è"·-Û"üý8)Û"Àý8î÷)X¥|Û"ò.æ5c6Cæ5%6Û"üÀg Û" ð”)­$üÙÔè"ò.Û"4•Û"L ÷"š&Z
Lÿ4–å Û"â”) ¦ô$òè"îò.ìÛ"êÛ"èò.±Û"¥Û"÷š#XÛ"ˆ%üË=·-æê8 ,ü’® ò.”)Ä©´
üsÖ%”)C6l´0Û Ö%t†Û"̆D•ñ4)T•$ Û¼¸3”) æ”)) ”),”)T”)”)\$ 
wÛ"$
´›
Ø|
B  ' 

xÛ"  œô$æ5 ?  4\™Û"Ì®œ®’6 
ü™/
Û"UE
ü¥#1
Û"Ìöœö’6 üÜ4
Û"UEüë%1Û"ÌŜŒ6 ü¯0
Û"VEü¾!\ÿ$„ òC$ÿ4„ ÌŒ œŒ ’6 üþ( üù. Û¼¸3ö Û¼¸3Ô  üßõ )üÂþüé×ë7”õ¸8Û¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙŽBy”)ž)MŽBC·-8”)ÝOº3ý8·-1±·-óÛ"æO·-Û"í Û"3Û"%¸3Žº3ßÛ"Áò. «8þ´ nºAjñ4óòC>DÔDèæ5Ã’6ÜEs’6%ÕF6·ÏG˜òCm’6Mü¾#M *Û"Dä#|Û"ò. ÿ#”)$0ü˜#yº#$¯#Q|Û"ò.ü¢%T¹%
ò.DÈ%”)Ĺ%Ä%ºA
:-lÄ%'T¬%
$±%ÛŽBlà%”) ì%”)) ”),”)T”)”)|¥&Dª&
yÛ"$¥&Tª&+\Ô&$Ù&òC$Ô& 4Ù&dõ&,ú&ÔD$õ& <ú&œõ&$'æ5 :  4'üá&(œá&6 :

üÓ&7  
üÎ&= Û¼¸3¸' $®' Û¼¸3" +üï$É4üÒ%Òë7”…% º#L÷$ÝI1”)Mž)ŽBÑJõ¸3ͺ3fÛ"þý8)·-Wò.^g«8W¯ºA®÷OîòC¹ÔDæ5y’6[üÜ)"üÜ) 
¬$ d*$˜*
¬$,*4˜*üÂ)g 5¬$¯*;ü“)œø#$³) ¬$,¥)**î,÷-ƒýrµeÔV›a¬$Ö¬$}½»TyŽT±TàTÕ+œUœÕ+4à+
ÃNœU0Dà+˜'Õ+
ÊL œUF$(ø'Ç+APU
ûMáVfnr~ Ì+ Ûº3¬$º3 Ï+
ÛøW¬$ ú+
Dú+$ü+±T$

4ü+$Ò, Û¼º3Ü, E 
L†,×U¬ú+
·ß×U×U 6  
*0 
<©, Û¼º3 'È,

¥)
ü”+È?ºÁÛ¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙº3”ª+ ø#Lœ+áV]áVáV­áVuÛ¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙøW áVÍž) º3G¬$0¦ ×U×UU7¿\ÞÅù&¹œ ±
n²V{ÛVW¨W]±Tƒ Y#¬$Ϭ$Õ¬$Û4-
-
”õ 
ŒÛ".
H(ž

ÊL¸8*)"&ø(
Ÿ? NS
ûM¸8 d)mq
}
h$
 Û¸3º3
    )


º3¼Ê


ëbÖB8 („Ñ
À)Ê

ž$Ö¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
ªKŸÈŸÈ ÈErrorÁ O˜éBLÈ

(ž¢
® À

¡$™aÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
ˆê)?ÈXM´­êaQÜb/(P
,ÿ
 ´Ž L• á`% 
(|• ¸+Ž “a?( ,O)O
 ÓbÜb0(q$ „‘ L– Ç4$)\– ¼‘  æ59) 


Ÿý8ý8
ܱ

¸ßý8ý8RI)*0
"


,€
!
º3¼ï
 á` 9!/)„ö À-ï
“a=)
",
">.†
ÓbÜb1)`
%$­
&
º3´œ

á`%9&/$)
¸
“a$=#)
'#,
'
*
-

+ܽ


Zý8ç`*K+B))ŒÇ

ÓbÈÜb2)¿à1½
“a)m( )
,(,
,"!>
Ób.Üb3)`œæ
Ö¿ªKêa^ªK ú
#.-'+â%)3&.C-',û
)n.ü–åŠ''¨*¸-*-$
$Þ%5%z%GüÌ ¯üæ •u|¸¿ÆÄÊ
ž¥ ¬¼Ž  ü ú)
07
Äï 4
;B
¼œ
ë
òù
ä½
.™a´×·-ç`éè"¸8¸8¸8ë7š ¸8¥ž)zº3 •¢˜¢™¢lš¢ˆ›¢œ¢[¢ˆe0<#˜ÜbªKÛ™a ç`Fº3?ž)9Žp^™aîp«ž)"ý8L… ·-ê8 ý8ÔÉqÎý8ÖwŽp™aEîprº3kž)ðŽpˆ™aºîpçº3àž)Žpë™aMÉqç`~ž)Ȉ÷ÃwriterÁÎfirstÁÂ
ùÝùb
Ð Ø  Ž |YÜb¹ÁkªKŽ i }Üb¹È ªKšc
Ž ý­Üb¹Ñ¿ªKŽ ÑÜb¹ØãªKŽ ÍõÜb¹ßªK)Ÿý8ý8Ÿ^ Ú^W ¥_] ë7
á`c
“a6
Ób<
á`Æ“a ë7·
Ób¬Ç4-æ5½f»á`A“aÓb#á` “a|‡jÓbˆ“aÉÓbÏè"Kë7 è"Wë7 è"cç`iç`oç`u*„›(
(

~Û"1d$‡
ª},"4‡¼D>"%d­(
„ª Ö¿Û"¹$Ð%„Ó
Š}ß|"€3Ó
ÊLüÏüÏýÏSplitÁ€Ðˆ¯v ÁÀ³UEÝk"^bø3Çç{
Š
ûMžy
   "©­  ¹ 
â Ûº3·w 

"(
'„´ Ö¿Û"¹$' Å(
Æ!D
"'Äø´ø
c"ìô Ö¿Û"¹$ø%¼Ä
´}º3
º3 "”É9
Ûº3Ô…¤…
]ý8"%ü¨& LÛ"º'¹$¹$ º3ü…J< 
ç[ý8¹$¹$LÛ"º'°~½~s"ü /ø4…K 
ž$Ö¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
ý8¹$´"tx
ü…Klý8Ìßœß6&" [Ö¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
ªc¹$; p
¡$Ö¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
Û"¹$ù€Ö'"°”«
ŠÛ"
$¸"&üÉ' 
 MÛ"º'ªK¹$½~ ü«F
ÈTÛ"¹$MÛ"º'–ƒ½~j"ü¾3ø6«G 
ž$àb"$(!4!
ü«G#lÛ"#ü°Ì"[ù€
Ú"+("§d‡%\&ü‡ 4”
Û"%9&/$)"œ”(!;#ü´ X h( $Æ %s
%´JYü—¯˜üîÀüžüܦüê˜\cj®
y ½)à¬Þº3Û"´Fº3xÛ"#žy¦žyëžyÎZ¾ žyÉž)bº3º3|¹$MÛ"ÎZž)Úº3Е¢˜¢™¢lš¢ˆ›¢œ¢[¢ˆe0<#˜ù€ý8b¨³¨ é~ÿ¿~ž)¹ù€Âý8•¢˜¢™¢lš¢ˆ›¢œ¢[¢ˆe0<#˜ù€Û"àç7NŃ-¿~5ž)Nù€WÛ"ŽªK²K7Û"0Û"H inputÁñ parsed_flagsÁ
ù«8Ï «8Ì
parsed_flagÁË«8Ž´Ž ¹X
Ž ( "¹c#~•w9 ·w Dä
Üxo
˜y8
Ÿz>
·wY Dݽ|¬„}kõ}Ú~¢¢_’6¸ÚlÚ‚¼¹ƒdÿƒ$Ú+É…iÛ"R Û"X ¿~ü¬"ä¬
_º3:#ÎLƒ¹$«é~˜¹$ ©º3}¿~°«8ý¿~ÉêŽ
_ref__flagÁ¿~üÌ$ôÌ
aº3:#ðMݹ$ËŃóº3u¿~«8¿~ªìŽ ü‘$ æ5ü’#¬’
ˆÛ"C%y
ü‡7L‡
GÛ"ç`ÃC+ ¿Àü‡¹8HN1™a´Í·-ç`·-ZÛ"ý8Aç`í¡÷:üq>æ5yŠ’Yß’
Û"ßÛ"äç`é ¤Ù
JÛ"$¨8Ùÿƒ> ,>¬Ù
lÛ"
!äÙæ5C  [ù€°Ú +ÉüÃ3¬ÃŠ’s  üÀ7 Ö¿Û"¹$ øù
üÔ¥Q¾ÄÊ" ଇº3Û"·ý8·-QÛ"Y´Š¦àÙž)!ù€*Û"óŠWŽ K ¹©
¸†•*ÿƒæ5šÚŠ’LÛ"Û"$³!
”Ì!TÒ!Ÿ^,Ì!dÒ!Lõ!H:õ!Ú^$ ø:ä!Ÿ9 HM¥_ Xae
q
ô $é! Û¸3º3,"   :#4¡",²"
º3¼¡"L¨"á`9/ „¨"À;¡"“a=

 
, ><¸"Óbô Üb`lÎ",Ö"4å"´å"Lì"á`% $ö"
|ì"¸=å"“a? ,UO
>û"Óbô Übqœ‰# Ö¿ªKêaô ªK #Ó2Bž#
l|üËÓê=
S
%ü£!ûü½!áçîõÄ¡"<C J¼å" ™a´“ ·-ç`L§!è"DÁ!¸8º¸8Ó¸8Êë7ÒìoÚž)µº3`LŽpÕ™aîp4º3-ž)²ŽpF™azîpž)

÷­üq±rù¸ùtÐ ö Ž %ô Üb¹;ô ªKŽ  ô Üb¹B ô ªKÏŸ^Ú^á¥_çë7)á`ù“aÕÓbÛá`V“a0ë7MÓb<è"§ç`­ë7eè"¹ç`¿ë7wè"Ëç`Ñ%„„&
 T—&
D—&•w,dê&$ð&·w,ê&4ð&¼ê&D÷&D;T÷&%d'
„“' Ö¿Û"¹$ô "„¼',Â'Üx,¼'È'|TÂ'€?¼'˜yK ø?°'ã9
HMŸz
X  ae  q 
ô $´' Ûº3\â'$ç'·w $â'

4ç'dœ,
„™, Ö¿Û"¹$ ª,
«,|¸(D½(D
$¸(T½('Äá(´á(½|ìÝ( Ö¿Û"¹$ô "´ˆ*\*
þ|º3
$ˆ*$™*º3 Œ*;ü¸*:ä¸*êŽäÕ*º3 )ü´*? Ö¿Û"¹$ô "”š+dš+Ú‚
$§+!ü¸+'
 XÛ"º'–ƒ½~üš+FT­+
ÈTÛ"¹$XÛ"º'–ƒ½~ƒcü­+3ø@š+G ÿƒ\".
üš+GlÛ" ) dì+\€, 
üì+ 4ù+É…F<$œù+Aà+[ù€æÚ+ , 
ô " &ç!"A üÁ$ê^n!¡± #V
Rü€&«Šü×'¼üˆ+07>Ó!à¬ò$º3,â$Û"@Ⱥ3÷Û"¥žy-žymžy=ÎZEΈNž))º3Ôº3$Û'I¹$ܹ$Û"\Œ+´Šºà
‘7eÖ¬I¿~Qž)ù€!Û"·ªK[²KÛ"ŒÛ"*õ󊆋Mù'«8© «8Ù
‹¾Ž ­¹G•w·wUD4Üx¿˜yŸz·wöDz½|IÔª êŽÇÚ‚wʬ+ÿƒëÉ…PÚùÛ"ØÛ"ÞÛ"$Ú+¿~ü»+$ô»+ª6ß+Xß¹$º+Ö¬õº3q¿~«8¿~ª}ìŽ(ˆ0 
º3p¦0ñ$  ¿cQV
‡dgl\y0×™a ¹$¥  c cˆ¢cµ
 `£cbufÁ `àB¤GS
ëº3ò†·å  ñ$òĸú±&1¸†·* ·F(Á0$8Þ2
ªKD Lº3, 4º3>
J
†·Œ
ùc ¢ }
´8×1ߪKÒÚº3,4º3> J †·¨º)/}BGP º3]c
êcu{Æ0àœ¢©™aĸ¿í·Èž)к3Ø ªK+º3ëº3;†·D ó¼Pó¼çº3º3÷†·—½ =±K__self_0Á©í¼D
w—½†·[¨ºŒ—½†·Þ¨º€¼¤$¸4üÔ5& Øô ªKüÉ52 Ó €66_üé3˜ü¬4ÕüÇ4º¹$$4é
$4Ò¿,°4ñ$˜«8_flagÁ%÷Ë4ô ªKyÒ¿£$¯7üË8( Øô ªKüÀ84 Ó ù8ú8aüÞ6œü£7×ü¾7¼¹$$”7Ò¿$ø6Ò¿,§7ñ$«8€¿!÷Â7ô ªKsÒ¿Ìô9 Øüé9% Ó :”:cü½9W¹$$Ú9ñ$`( Í º3 î  º3º3&†·@  
º3
Û"& 
2 †·
ûc§¬œ¡otÈ Òçß ™aêŽBñí·ùº3º3ó†·û¿~º3Ó†·Û ·-å·-ìA±OZ¿~†·RÁņ·%²Äx¤Ø áÛ"òvü—[Ö%º3Û"Ð »C¤ áÛ" ë°v®Ö%«º3©Û"§º3}Û"qÐ È»ÌöLº3¬wüêBº3d†ŽB ,]º3[wYº3VŽBT]~\Û"¢xüç;·-ŽB ,^dÛ"u ¡wxu·-rŽBp·-²¡º3¤ÝD(¬Ü÷yü­JŽB_º38DŒ¦¬º3¼µ
¼ºDภð¾ÂyÀ½ŽB»º34º3ÑÚúº3¤¶ D(Ð zü… KŽB, º3 2DnŒº3¢
¢ DÆž É ¤z¢ŸŽBº3º3¬µÕüå)´å
ŒüŸçÐ}ùÐ=~üÈLçÐRŸùÐùÐáÐ Œü
ŸùÐùÐ
|çÐ 
áá«ãÐ fä»f‚q $çД¤
“t—Òt
ÊLÄlÄlçÇlµ ™lÈl
end_or_lenÁ™lÉl_markerÁ™lŒœjSž—Òž{øN˜c¦«
ûM”Ó½ÅÉÕç Û —Ò 
xçÐ 
ü…!´…áÐ& œÝ
çÐ
y  üÑ
™úùÐùÐ · O

,üÅ+
T¬üÍßüèÄçÐùДÓ5”Ói”ÒË”ÓPÛ¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙ‚Õž ”Óªž)&‚ÕÎùÐ$ùÐÅùÐa çÐËùЪ truncatedÁÔù
«8) &ÄŸùÐùк|çДÒäÒxŽÓT±Ô[¦ÕKáЄÖû®Ö×

|çДÒü¡#äÒ3ü¡U
£N”ÓçÐî& ‚ÕªKhô àÚÄÝüÖ l\
~çÐ"¤$›„ÖE4›ü¡¢
óN£­£­FilterÁ¦­ù§­ predicateÁä9Jÿ ÃW^—”ÓàÚùÐçÐî&ùЂÕùЪKJ¿ô ìÜü£üˆ;üýÑ´ýáÐÒ! ÓÔ üÜøçÐùÐ4”Üô”Ó#”ÒIùÐ~ÜØ·çÐÀfp|çДÒäÒjÖÚK·Ûñ„ÖÈŽÜ©áÐöçÐÕçÐÛ â
wçÐ*œâD>¤áõ¬à àÚÄ ‚Õ Þnº3Ÿ‚Õ±!ûã߯D¡¦Õ ²„²„Ö<´¬®Ö¬?"ÂŽùЫ ìܨùФ‚Õ ©ùÐÜØÃaccÁ)±,ñ¦Õò„ÖѮֲ„Ö
çÐ"”Ä„ÖEü¶ 
ùøùÐùМJ- ÛÜü‰SƒùÐÜØ,—ùÐ ùÐ¾ÜØöçÐþ,]„ÖBîã"„ÖùÂäÙçЬçв „Öîã”Ñ„Ö@œÐ
—!ùÐ?"üÂ!Âä´A" èéü“VùÐÜØùÐ$ùеùÐãÜØçÐ6g„ÖdîãD„Ö «çÂäàçоçÐÄœå
çÐ+Œü
ŸùÐùÐüå(
¸ßùÐùÐN,ü³`ÜØ ùÐÇùÐÏ€ë ùШ.O¿ŸùÐùÐÎé
®ê³ 

$„!ôë 

Äë 
ˆçÐ=8L—!„—!$¡!„Ö%4¡!$$«!Ä—!
·ßùÐùÐ^3,2LÃ!

 |¾! Û¼çÐ ü”!e$ë! Û¼çÐ$ þ!


ÿ!. ü¢ ÝJ!üÛ ¤ Û¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙçÐùÐçÐ$ùЀëÐùÐÙÜØò€ë»çÐt´Yõ×ö£ìs„Ö.˜íõçÐSçÐZ\œ#Lœ#î㔜#$¨#„Ö@4¨#Ì•#Âä$•#@#üþ"1´þ"áÐ@  ´#µ#üÄ"qˆçÐ$ï"ùÐ$Ú"ùЫùÐÙÜØ çд._îã4„ÖÂäñáÐÎçЮçд|À&DÅ&D$À&TÅ&&$å& Û¼çÐô XOŠ'
ÊL”Ò\Š'|çДÒ26øOþ& O^c±Ôow{ $'Û‚Õ\§'$¬'ãß$§' 
4¬'$¨( Û¼çв(H
 $¶' œ§'
·ßº3º3
 1  )/  dð',õ'¦Õ$ð'
<õ'œð'$ý'„Ö<4ý'üÙ'+´Ù'áÐ<
üÔ'1 Û¼çÐ
ô ûŠüØ%ÚÇΦïdô%º3$å%ˆ”Ó9”ÓBÖ×K¤ØTž)‚ÕÆO¿~»º3ÿ~wçÐåùÐÜØBÐ ù«8#Ê·|çДÒD=ãôì±ÔóãßAÿöä¦Õ¬„ÖŒáÐn¬°*|°*
çÐ$À*%Ë*üƒ*H  ç
ù5ÞÍq2§3çЄ•*ÜØ,‹* b‰û§Ô‚-¤‚-
!çÐ$—-%¢-ŒüÊ,Xà÷ƒš£‘P|¸çЬâ,ÜØ,Ø, v½ü»ì­.Ü­.
0çÐÐ.üë-e**î,÷-ƒýrµeÔV›açÐä†.L…þŠü×0Ì×0
;çÐ$ñ0&ü0Žü”0h55Å7ù8´ò¶6ááÉìçÐÔ²0ÜØ,¨0 bÿ¨\ß1$ä1„Ö$ß14ä1%Œî1
ŸùÐùÐüß1 ˜íoC!…2üº1K$Ð1ÜØ,Æ1€ë³ùл€ëùК+L±ŸùÐùЄÖù˜í¤
\ñ3Lñ3îã”ñ3$ý3„Ö@4ý3\†4$4„Ö$†44‹4üñ3 ®ÖbA"&\•4$š4„Ö$•4 4š4& üñ3/˜í|M" ¥4¦4 üÇ2ß
$Û2ÜØ,Ñ2€ëëùÐóùÐIÜØ}çÐùÐ>€ëëùÐóOî㽄քÖz®ÖY„Ö,˜íÿçÐÝçÐã\Ã5$È5„Ö$Ã54È5,Ñ5dÑ5$×5„Ö%4×5ÔÃ5Âäo>!%Œá5 
ŸùÐùÐ üÃ5/®êoC" ÷5ø5üì4Œ
$‘5ÜØ,ú4çÐ,5€ëèùÐðùÐTùÐ'ÜØ@€ëâùÐêP¹
SŸùÐùЄֳ„ÖÂäe®êçÐðçÐö \“7$˜7„Ö$“74˜7,¡7d¡7$§7„Ö%4§7Ô“7Âäo>!%,±7
d±7$·7„Ö
% 4·7$ ü“7*˜íK" Â7Ã7ü¾6… $á6ÜØ,Ê6çÐ,Ñ6€ëùÐ ùÐnùÐAÜØZ€ëìùÐôÜØ [¹
^˜„ÖÄ„ÖÂäv„Ö<˜íçÐðçÐö$Þ8\Þ8$ã8„Ö&4ã8üÅ8%ÄÅ8£ì<,½8ñ8'üù7xªK8 çÐL…8çÐùÐºÜØÓ#V„ÖߣìÀçС üŽ:0 $¥:\¥:$ª:„Ö&4ª:üŽ:#´Ž:áÐ= ,¸:
£,²:
šçÐ^?d²:,†:Å:' ½:ü·9Ž Ä:4 ªKØ9ÓLÁ9çÐ,Ì9çÐoçÐùÐIÜØcçÐ|H¹
K¨„ÖŒáÐmבÒçÐçРü”=5 $«=\«=$°=„Ö&4°=ü”=#´”=áÐ= ,Ã=
£T¸=
çÐ^?Œ¸=,Œ=Ð=' È=ü½<“ Ï=4 ªKÞ<ÓLÇ<çÐ,Ò<çÐoçÐùÐIÜØcçÐ|H¹
K¨„ÖŒáÐm•ÒçÐçРü÷>? $Ž?\Ž?$“?„Ö&4“?ü÷>#´÷>áÐ= ,°?
£¤›?
œçÐ^?Ü›?,ï>½?' µ?ü > ¼?4 ªKÁ>ÓLª>çÐ,µ>çÐoçÐùÐIÜØcçÐ|H¹
K¨„ÖŒáÐm­™ÒçÐçÐÂ,ƒA”—A4œA
çÐ$—A,£AlœA”ÈA4ÍA
çÐ$ÈA,ÔAlÍAëAü§@ĪKÒ@ÓL®@çÐ,¹@,Æ@ªK¬ªK+¹
.»3h‹œ꿜¼làB\àB·Û,ØBôB'ü—B]˜ªKªBÓL BçÐC·Û¡çЈ
$—D\—D$œD„Ö%4œD,¥Dd¥D$«D„Ö%4«DÔ—DÂäm>!ü€D2´€DáÐ>  ·D¸D+; üËCmçÐ$ñCçÐ$ÛCçÐ,áCùÐÓùÐ5ÜØNùÐÜØ,A¹
D„Ö{„ÖNÂä/áÐçÐðçÐöçÐüçÐ
$ÓE\ÓE$ØE„Ö%4ØE,áEdáE$çE„Ö%4çEÔÓE®Öm>!ü¼E2´¼EáÐ>  óEôE+; üŽEfšçÐ$­EçÐ$—EçÐ,EùÐÓùÐ5ÜØNùÐÜØ,A¹
D„Ö{„ÖN®Ö/áÐçÐðçÐöçÐüçÐ $ÊH\ÊH$ÏH„Ö%4ÏH,ÙHdÙH$ßH„Ö%4ßHlØH«ç9ÜÊHÂä:!ü³H3´³HáÐ>  ëH ìH+ ;
ü€Hl çÐ$¤HçÐ$ŽHçÐ,”HùÐÓùÐWÜØpùÐùÐ>ÜØWJ¹
Mˆ „Ö¦„Öy«çZÂä?áÐçÐçÐçÐçÐ
$ J\ J$¥J„Ö%4¥J,®Jd®J$´J„Ö%4´JÔ J
¹ûùÐùÐxI,ü‰J2´‰JáÐI  ÀJÁJ+; üÌIuœçÐ$úIçÐ$äIçÐ,êIùÐÞùÐ@ÜØYùÐÜØ7A¹
D„Ö„ÖY¦«:áÐçÐðçÐöçÐüçÐ$èK\èK$íK„Ö%4íKdçK«ç9üÎK&ÄÎK£ì9  ùKúKü¨KRçÐ$¿KçÐ$¶KùФùÐÒÜØê#T„Ö÷«ç×£ì»çÐçС˜&H ½Q ÏΘ&Ð ­Qê˜&¼Z%CÏΘ&u8::MAXÁ¢&ø ñQVH »RÏΘ&¢&ø «R í¢&ÀZ&>ÏΘ&0 ÎW QÞWñQö¨  !   ˜& Q×W
Îbϲ U&S ‚È‚ÈArgumentÁ„È´ÀbökÏ®ÝWj´ £  ˜&”)Â
ÐÕ
«c”)”) 
ù
ç¨. I
ì¨ 
îb¨\ñö¨ ù
ì¨)  ôW õWø ðV…õ¢© ™aX ¥Wϲ( ŒWã´P “W ã´ùäÈäÈ ArgumentsÁæÈtemplateÁ `çÈÀ `üöMõô]TdíͲ:ͲRг”)Zг:ݳl ÷¶xͲÊüqÌÀ¥À±0æ²œŠ´ÌÝ´ºã´}ã´0 –Y S¦YñSö¨  !   ¢& SŸY
ÎbÛ¸ U&S гc k ݳz
ˆŠ´ š
Ÿ¨ùç¨. Iì¨ Ý´éñö¨ ùì¨)  ¼Y ½Yø ¸X…ø.5 ™aX íXÛ¸( ÔXã´P ÛX‚¶޶Ù¸vÙ¸Ž÷¶ˆгhݳš ·£Ù¸¬iüqkÀÐÀÜÏò¸ÆŠ´öÝ´Oã´ã´"ä&)2øÏä&(þ7ä&ÈZLkøÏä&u16::MAXÁî&+(øÏä&î&&5î&ÍZJcøÏä&& UÞWñUö¨  !   ä& U×W
Îbó¾ U&S гc k ݳz
ˆŠ´ š
Ÿ¨ùç¨. Iì¨ Ý´
ñö¨ ùì¨) ±¯Ê®½)0 ™a«ó¾©ã´§‚¶޶ñ¾kñ¾ƒ÷¶}г]ݳ ·˜ñ¾¡üqÀÇÀÓvŠ¿¾Š´îÝ´Gã´Ãã´ÊF W¦YñWö¨  !   î& WŸY
ÎbŸÃ U&S гc k ݳz
ˆŠ´ š
Ÿ¨ùç¨. Iì¨ Ý´-ñö¨ ùì¨) EC^BŒQ)0 ™a?ŸÃ=ã´;‚¶»޶ÃkÃ÷¶}г]ݳ ·˜Ã¡¢üq¥ÀÇÀÓ
¶Ã¾Š´îÝ´Gã´Wã´^°'g p  Ñ°'f u °'ÖZŠ ©  Ñ°'u32::MAXÁº'k h  Ñ°'º'f u º'ÛZŠ £  Ñ°'f  YÞWñYö¨  !   °' Y×W
Îb³É U&S гc k ݳz
ˆŠ´ š
Ÿ¨ùç¨. Iì¨ Ý´M ñö¨ ùì¨) ñ
ï

î
ý
)0 ™aë
³Éé
ã´ç
‚¶Û ޶±Ék±Éƒ÷¶}г]ݳ ·˜±É¡N üqQ ÀÇÀÓ ÊɾдîÝ´Gã´ ã´

 [¦Yñ[ö¨  !   º' [ŸY
ÎbßÍ U&S гc k ݳz
ˆŠ´ š
Ÿ¨ùç¨. Iì¨ Ý´m ñö¨ ùì¨) 
ƒ
ž

 
)0 ™a
ßÍ}
ã´{
‚¶û ޶ÝÍkÝ̓÷¶}г]ݳ ·˜ÝÍ¡â
üqå
ÀÇÀÓJ öÍ¾Š´îÝ´Gã´ ã´ž ü'«´ÈÒü'ª¦¹ü'äZÎíÈÒü'u64::MAXÁ†(³°ÈÒü'†(®©½†(éZÒëÈÒü'® ]ÞWñ]ö¨  !   ü' ]×W
ÎbûÓ U&S гc k ݳz
ˆŠ´ š
Ÿ¨ùç¨. Iì¨ Ý´ñö¨ ùì¨) 97R6±E)0 ™a3ûÓ1ã´/‚¶#޶ùÓkùÓƒ÷¶}г]ݳ ·˜ùÓ¡üqÀÇÀÓþ’Ô¾Š´îÝ´Gã´Kã´RÎ _¦Yñ_ö¨  !   †( _ŸY
Îb§Ø U&S гc k ݳz
ˆŠ´ š
Ÿ¨ùç¨. Iì¨ Ý´µñö¨ ùì¨) ÍËæÊ´Ù)0 ™aǧØÅã´Ã‚¶C޶¥Øk¥Øƒ÷¶}г]ݳ ·˜¥Ø¡*üq-ÀÇÀÓ¾Ø¾Š´îÝ´Gã´ßã´æÈ(ûðÓÈ(úº È($òZ=ðÓÈ( u128::MAXÁÒ(  ðÓÈ(Ò(½Ò($øZ+DðÓÈ( aÞWñaö¨  !   È( a×W
ÎbÔÞ U&S гc k ݳz
ˆŠ´ š
Ÿ¨ùç¨. Iì¨ Ý´îñö¨ ùì¨) «Åž)0 ™aŒÔÞŠã´ˆ‚¶|޶ÒÞkÒÞƒ÷¶}г]ݳ ·˜ÒÞ¡ïüqòÀÇÀÓWëÞ¾Š´îÝ´G㴤㴫' c¦Yñcö¨  !   Ò( cŸY
Îb€ã U&S гc k ݳz
ˆŠ´ š
Ÿ¨ùç¨. Iì¨ Ý´ñ ö¨ ùì¨) &$?#È2)0 ™a €ãã´‚¶œ޶þâkþâƒ÷¶}г]ݳ ·˜þ⡃üqÀÇÀÓë—㾊´îÝ´Gã´8ã´?”)LU—Õ”)KÎZ”),‚[oŽ—Õ”)
usize::MAXÁž)VS—Õ”)ž)QÑ`ž),‰[uŽ—Õ”)Q eÞWñeö¨  !   ”) e×W
Îbžé U&S гc k ݳz
ˆŠ´ š
Ÿ¨ù!ç¨. I!ì¨ Ý´8ñ"ö¨ ù!ì¨) ÜÚõÙÙè)0 ™aÖžéÔã´Ò‚¶Æ޶œékœéƒ÷¶}г]ݳ ·˜œé¡9üq<ÀÇÀÓ¡µé¾Š´îÝ´Gã´îã´õq g¦Yñgö¨  !   ž) gŸY
ÎbÊí U&S гc k ݳz
ˆŠ´ š
Ÿ¨ù#ç¨. I#ì¨ Ý´Xñ$ö¨ ù#ì¨) pnmÜ|)0 ™ajÊíhã´f‚¶æ޶ÈíkÈíƒ÷¶}г]ݳ ·˜Èí¡ÍüqÐÀÇÀÓ5áí¾Š´îÝ´Gã´ã´¬0 ÓÔ%¹$0ñ$7>@f´ÃÊÍíÖ $¶@ž«$¼@á¾ ,Â@{´D±C¦ºÞDÓe»í|ï…¼ƒtÆÃ½˜„ÂÆ¾¯|âÏ¿ÅÔ«ÜÀæÔƒíÁ¤„üªÌõÄËôöÅñ´•!ÆÜìHDzÔöWÈÔì…ˆÉܮˣĜ ÌÒăÏœôŽ%Ðÿü¥."ѹü‡8!ÒüÓ§üÓ©;¤;
Generate types for C-style flags with ergonomic APIs.
# Getting started
Add `bitflags` to your `Cargo.toml`:
```toml
[dependencies.bitflags]
version = "2.13.0"
```
## Crate features
The `bitflags` library defines a few Cargo features that you can opt-in to:
- `std`: Implement the `Error` trait on error types used by `bitflags`.
- `serde`: Support deriving `serde` traits on generated flags types.
- `arbitrary`: Support deriving `arbitrary` traits on generated flags types.
- `bytemuck`: Support deriving `bytemuck` traits on generated flags types.
## Generating flags types
Use the [`bitflags`] macro to generate flags types:
```rust
use bitflags::bitflags;
bitflags! {
pub struct Flags: u32 {
const A = 0b00000001;
const B = 0b00000010;
const C = 0b00000100;
}
}
```
See the docs for the `bitflags` macro for the full syntax.
Also see the [`example_generated`](./example_generated/index.html) module for an example of what the `bitflags` macro generates for a flags type.
### Externally defined flags
If you're generating flags types for an external source, such as a C API, you can define
an extra unnamed flag as a mask of all bits the external source may ever set. Usually this would be all bits (`!0`):
```rust
# use bitflags::bitflags;
bitflags! {
pub struct Flags: u32 {
const A = 0b00000001;
const B = 0b00000010;
const C = 0b00000100;
// The source may set any bits
const _ = !0;
}
}
```
Why should you do this? Generated methods like `all` and truncating operators like `!` only consider
bits in defined flags. Adding an unnamed flag makes those methods consider additional bits,
without generating additional constants for them. It helps compatibility when the external source
may start setting additional bits at any time. The [known and unknown bits](#known-and-unknown-bits)
section has more details on this behavior.
### Custom derives
You can derive some traits on generated flags types if you enable Cargo features. The following
libraries are currently supported:
- `serde`: Support `#[derive(Serialize, Deserialize)]`, using text for human-readable formats,
and a raw number for binary formats.
- `arbitrary`: Support `#[derive(Arbitrary)]`, only generating flags values with known bits.
- `bytemuck`: Support `#[derive(Pod, Zeroable)]`, for casting between flags values and their
underlying bits values.
You can also define your own flags type outside of the [`bitflags`] macro and then use it to generate methods.
This can be useful if you need a custom `#[derive]` attribute for a library that `bitflags` doesn't
natively support:
```rust
# use std::fmt::Debug as SomeTrait;
# use bitflags::bitflags;
#[derive(SomeTrait)]
pub struct Flags(u32);
bitflags! {
impl Flags: u32 {
const A = 0b00000001;
const B = 0b00000010;
const C = 0b00000100;
}
}
```
### Adding custom methods
The [`bitflags`] macro supports attributes on generated flags types within the macro itself, while
`impl` blocks can be added outside of it:
```rust
# use bitflags::bitflags;
bitflags! {
// Attributes can be applied to flags types
#[repr(transparent)]
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct Flags: u32 {
const A = 0b00000001;
const B = 0b00000010;
const C = 0b00000100;
}
}
// Impl blocks can be added to flags types
impl Flags {
pub fn as_u64(&self) -> u64 {
self.bits() as u64
}
}
```
### Renaming flags
The [`bitflags`] macro recognizes a special `#[bitflags(flag_name = "<value>")]` attribute on flags values to rename them:
```rust
# use bitflags::bitflags;
bitflags! {
pub struct Flags: u32 {
// Add the attribute to a flag to change its name
#[bitflags(flag_name = "a")]
const A = 0b00000001;
#[bitflags(flag_name = "b")]
const B = 0b00000010;
#[bitflags(flag_name = "c")]
const C = 0b00000100;
}
}
```
When applied to a flag value, instead of using its identifier, like `A` as the name, it'll use the given string. This
doesn't affect the identifier of the constant itself, just the name recognized when parsing and formatting.
## Working with flags values
Use generated constants and standard bitwise operators to interact with flags values:
```rust
# use bitflags::bitflags;
# bitflags! {
# #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
# pub struct Flags: u32 {
# const A = 0b00000001;
# const B = 0b00000010;
# const C = 0b00000100;
# }
# }
// union
let ab = Flags::A | Flags::B;
// intersection
let a = ab & Flags::A;
// difference
let b = ab - Flags::A;
// complement
let c = !ab;
```
See the docs for the [`Flags`] trait for more details on operators and how they behave.
# Formatting and parsing
`bitflags` defines a text format that can be used to convert any flags value to and from strings.
See the [`parser`] module for more details.
# Specification
The terminology and behavior of generated flags types is
[specified in the source repository](https://github.com/bitflags/bitflags/blob/main/spec.md).
Details are repeated in these docs where appropriate, but is exhaustively listed in the spec. Some
things are worth calling out explicitly here.
## Flags types, flags values, flags
The spec and these docs use consistent terminology to refer to things in the bitflags domain:
- **Bits type**: A type that defines a fixed number of bits at specific locations.
- **Flag**: A set of bits in a bits type that may have a unique name.
- **Flags type**: A set of defined flags over a specific bits type.
- **Flags value**: An instance of a flags type using its specific bits value for storage.
```
# use bitflags::bitflags;
bitflags! {
struct FlagsType: u8 {
// -- Bits type
// --------- Flags type
const A = 1;
// ----- Flag
}
}
let flag = FlagsType::A;
// ---- Flags value
```
## Known and unknown bits
Any bits in a flag you define are called _known bits_. Any other bits are _unknown bits_.
In the following flags type:
```
# use bitflags::bitflags;
bitflags! {
struct Flags: u8 {
const A = 1;
const B = 1 << 1;
const C = 1 << 2;
}
}
```
The known bits are `0b0000_0111` and the unknown bits are `0b1111_1000`.
`bitflags` doesn't guarantee that a flags value will only ever have known bits set, but some operators
will unset any unknown bits they encounter. In a future version of `bitflags`, all operators will
unset unknown bits.
If you're using `bitflags` for flags types defined externally, such as from C, you probably want all
bits to be considered known, in case that external source changes. You can do this using an unnamed
flag, as described in [externally defined flags](#externally-defined-flags).
## Zero-bit flags
Flags with no bits set should be avoided because they interact strangely with [`Flags::contains`]
and [`Flags::intersects`]. A zero-bit flag is always contained, but is never intersected. The
names of zero-bit flags can be parsed, but are never formatted.
## Multi-bit flags
Flags that set multiple bits should be avoided unless each bit is also in a single-bit flag.
Take the following flags type as an example:
```
# use bitflags::bitflags;
bitflags! {
struct Flags: u8 {
const A = 1;
const B = 1 | 1 << 1;
}
}
```
The result of `Flags::A ^ Flags::B` is `0b0000_0010`, which doesn't correspond to either
`Flags::A` or `Flags::B` even though it's still a known bit.
Á@f´ÃÊÍíhÖ iž«há¾ g{´f¦ºÞe»íd¼ƒb½˜`¾¯^¿Å\ÀæZÁXªVÄËUÅñTÆSDzRÈÔQÉOË£NÌÒMÏœLÐÿKѹIÒâ å è 4­@ß â Ô × É Ì dË@üQL
Yield the bits of a source flags value in a set of contained flags values.
Á$Ó@ *5«$_á ¾ ,e{
,W)+Ü—ün¨£
An iterator over flags values.
This iterator will yield flags values for contained, defined flags first, with any remaining bits yielded
as a final flags value.
Á  ÍìÛ" §Û"§"5ÞÍq2§3
')œ¹  è"TÒ  ´á€· æ{Û"§"üþ$Œà àÛ"§" 
Û"÷=ÄŠ€· ·<§"üà\œí ô.Û"Û"§"
Û"÷ùš üÇ#€· Ì’¸§"úMûM Û"ü…($ˆá á§"Û¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙ§"úM 
Û"$üø
ü¥ ÒÍ
An iterator over flags values.
This iterator only yields flags values for contained, defined, named flags. Any remaining bits
won't be yielded, but can be found with the [`IterNames::remaining`] method.
Á€· ·<è"£P|¸')ÌŸþ¹¾”)LÎÛ"dÝÛ"Üî  €· ó’¸è"!ü$žâ âÛ"è" ©Ó,÷ƒì€##€· ·<ˆè"$%üÙ\œæþ¹Û"Û"è"""€.÷LUš^ìËü³JG Get a flags value of any remaining bits that haven't been yielded yet.ÁúüŠ>; Once the iterator has finished, this method can be used toÁüÍB? check whether or not there are any bits that didn't correspondÁü”2/ to a contained, defined, named flag remaining.ÁLÒã ãè" ãÛ"" Ü"Ç4üŒ(''€· ’¸,”è"()úMûM) && Û"üß(ä äè"Û¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙè"úM& ç&
)Û"ü“"'üØ ºµ
An iterator over all defined named flags.
This iterator will yield flags values for all defined named flags, regardless of
whether they are contained in a particular flags value.
Á„ž"++€· ¯"·<²"º#ýrµeÔVa,-%'ÌÁ",Á"**þ¹Tà"à"**”)üï""//€· ô"’¸,÷"º#0ܘ#¦#º#..
0Û"ü•$/22€· š$’¸,$º#34úMûM4 LË$$Ð$11ïÅüï$($ò$å åº#Û¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙº#úM1 ÷$1
4Û"$ü$ü‚(#ü¼'E@
An iterator over all defined names for a specific flags value.
Át(¥66Íì¬$ œ({¬$,Ÿ(ø#ò¶6ááÉì78+-Ô¬(,¬(55œUlÌ($Ì(55×UüÞ( ¥::ÍÍ ã(ÝÍ,æ(ø#;ü“)$¡)æ æ¬$ø#9 ¬)9
;¬$»*ü³*-¥==ÍÍ ¸*ÝÍ,»*ø#>?úMûM? Lç*$ì*<<ñÅü”+($—+ç çø#Û¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙø#úM< œ+<
?¬$$¡+tÙ@üÁ¼
Parsing flags from text.
Format and parse a flags value as text using the following grammar:
- _Flags:_ (_Whitespace_ _Flag_ _Whitespace_)`|`*
- _Flag:_ _Name_ | _Hex Number_
- _Name:_ The name of any defined flag
- _Hex Number_: `0x`([0-9a-fA-F])*
- _Whitespace_: (\s)*
As an example, this is how `Flags::A | Flags::B | 0x0c` can be represented as text:
```text
A | B | 0x0c
```
Alternatively, it could be represented without whitespace:
```text
A|B|0x0C
```
Note that identifiers are *case-sensitive*, so the following is *not equivalent*:
```text
a|b|0x0C
```
Á4á@GJNQSVY\ÓÔØ× `@BWriteÁ,üêb@CÖ $ž@E¾ ,—{@FWðEG,‰:<(*ü–tü up
Write a flags value as text.
Any bits that aren't part of a contained flag will be formatted as a hex number.
ÁLè èÛ"ç`™aHÖIIH ¸€· §Íìç`’¸Yý8Dêbç`ß’÷-7üq4ÀKMHJü´\ü¡
Parse a flags value from text.
This function will fail on any names that don't correspond to defined flags.
Unknown bits will be retained.
ÁD»é éàKK Õ€· Ä’¸\ý8D‡†•óЉC%'¨J<closure_kind>ÁL<closure_signature>ÁL<upvars>ÁLLJé~ÉJ¬ÛMÄÛMáÛMMJŃü‡yüÈ>9
Write a flags value as text, ignoring any unknown bits.
Á”Žê êÛ"ç`™aOÖPPO ²€· ¡ŽÙ’¸¦Ù´Ù
NÛ"ç`÷rIüq{I<>ACüÔeüÂŒ
Parse a flags value from text.
This function will fail on any names that don't correspond to defined flags.
Unknown bits will be ignored.
ÁŒÛë ëàRR þ€· í’¸êÛ
QÛ"óŠžK#%üË^üûOJ
Write only the contained, defined, named flags in a flags value as text.
Á„Òì ìÛ"ç`™aTÖUUT ô€· ãŽÙT„ ’¸´Ù,‰
SÛ"ç`÷7Püq4ü57:<üÁ$Fü # 
Parse a flags value from text.
This function will fail on any names that don't correspond to defined flags.
This function will fail to parse hex values.
Á|È$í íàWW é$€· Ø$’¸,Û$
VÛ"óŠ*X¸+V¬ÛXÄÛXáÛXXVÖ¬”’-ü­,d_
Encode a value as a hex string.
Implementors of this trait should not write the `0x` prefix.
ÁDœ-YYÎìçÐü’-xYéçéçZZZüË-=Ü«- Write the value as hex.ÁLÎ-î îçШ™aY¨[[ ç-YÍìóè Ø-êbóèTÛ-
ZçÐóè$è-üq4î-/1”´.üŒ.'"
Parse a value from a hex string.
ÁD¾.\\éçü´.‘\éçéç]]]üï.TìÍ. Parse the value from hex.ÁLò.ï ïÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
çй$\ ƒ/\ÍìçÐ,½/
]çÐóŠ,ü.|¦3¹$_acüé38ü¼3(% An invalid hex flag was encountered.Á„ð3Ò¿¹$^é
``^ÍìÒ¿Œ‡4ÄcÒ¿dŒ4
_Ò¿«8X_#%üÞ6:ü‡6RO A named flag that doesn't correspond to any on the flags type was encountered.Á”å6Ò¿¹$^é
bb^ÇíŒþ6Øídƒ7
aÒ¿«8G`ü½9!ü€985 A hex or named flag wasn't found between separators.ÁTÊ9¹$^^½|ü˜: ¹$eÅceü¿:8Â:ðñò ð¹$ ñ c cˆ¢cµ
 `£cŽ· `àB¤GS
ò™ad Æ:d
e$Ç:± Í:Tê@4î@¡£¦¯°á× `fhBitAndÁ4öøfjBitOrÁ,'–úfkBitXorÁ4.¶ûflNotÁ6•!fmù$QfoTdÓfq¯
Dp\fr
DzYfs$¸Ä¥§|~jl,D_aìDUWGI:<|“uu€· ˜Ö%vwxyzü—6ü©id
Define a flag.
If `name` is non-empty then the flag is named, otherwise it's unnamed.
Á¤ñÅÛ"Ö%tt
vÛ"Ð Þb»çbüê(üømh
Get the name of this flag.
If the flag is unnamed then the returned string will be empty.
Á$÷ó óÖ%ñÅt ütòCüçü²0+
Get the flags value of this flag.
Á,ôô ôÖ% ôÛ"t útÔDü­$ü¨{
Whether the flag is named.
If [`Flag::name`] returns a non-empty string then this method will return `true`.
ÁDºõ õÖ%t Ãt÷Oü… &üýƒ~
Whether the flag is unnamed.
If [`Flag::name`] returns a non-empty string then this method will return `false`.
ÁT’ ö öÖ%t t
zÛ"üï üÔ š 
A set of defined flags using a bits type as storage.
## Implementing `Flags`
This trait is implemented by the [`bitflags`](macro.bitflags.html) macro:
```
use bitflags::bitflags;
bitflags! {
struct MyFlags: u8 {
const A = 1;
const B = 1 << 1;
}
}
```
It can also be implemented manually:
```
use bitflags::{Flag, Flags};
struct MyFlags(u8);
impl Flags for MyFlags {
const FLAGS: &'static [Flag<Self>] = &[
Flag::new("A", MyFlags(1)),
Flag::new("B", MyFlags(1 << 1)),
];
type Bits = u8;
fn from_bits_retain(bits: Self::Bits) -> Self {
MyFlags(bits)
}
fn bits(&self) -> Self::Bits {
self.0
}
}
```
## Using `Flags`
The `Flags` trait can be used generically to work with any flags types. In this example,
we can count the number of defined named flags:
```
# use bitflags::{bitflags, Flags};
fn defined_flags<F: Flags>() -> usize {
F::FLAGS.iter().filter(|f| f.is_named()).count()
}
bitflags! {
struct MyFlags: u8 {
const A = 1;
const B = 1 << 1;
const C = 1 << 2;
const _ = !0;
}
}
assert_eq!(3, defined_flags::<MyFlags>());
```
Á{{›ì,€çÐ{›ì"é…›ì.é…)|}~ƒˆŠŒŽ˜šœ|}~ƒˆŠŒŽ˜šœÍìùЄƒžùЕ‡¦‡šŠƒœŒ˜ˆŽ~ü¸"ì– The set of defined flags.Á,¾{{ –Òìá The underlying bits type.Á$ˆ{{”Èü™*' Get a flags value with all bits unset.Á,ËçÐ{{·Û„Íüš.+ Get a flags value with all known bits set.ÁÐçÐ{{îã´Üü²96 Get a flags value with all bits from named flags set.Áðúüø_\ This method is equivalent to [`Flags::all`] unless [`Flags::FLAGS`] contains unnamed flags.ÁLßçÐ{{
çÐݬÛÄÛáÛàÚ¬ÛÄÛáÛìÜü‰"üÚ*' Get the known bits from a flags value.ÁTŒ÷ ÷çÐùÐ{ {
ƒçÐü“$üâ,) Get the unknown bits from a flags value.Ádø øçÐùÐ{ £{Îéü³'üï?< This method will return `true` if any unknown bits are set.Á¬¶ù ùçÐ{ Ì{
çÐìü™" Get the underlying bits value.ÁÀúüÈC@ The returned value is exactly the bits set in this flags value.Á$“ú úçÐùÐ{ ˜{„Ö$™ü¢ .ô³ Convert from a bits value.ÁÖúüÞ?< This method will return `None` if any unknown bits are set.ÁL¥ ùЦï{{
çдywüÄ"/ü…":7 Convert from a bits value, unsetting any unknown bits.Á”Ç"ùÐçÐ{{£ì´yüæ#.ü»#&# Convert from a bits value exactly.Á„é#ùÐçÐ{{áд$ú#üØ%(üš$FC Get a flags value with the bits of a flag with the given name set.Áå$úüí$@= This method will return `None` if `name` is empty or doesn'tÁü²%! correspond to any named flag.ÁLÛ%û û¦ï{ ë%{
ŠçÐÐ þ{üƒ*"ü¸(*' Yield a set of contained flags values.Áç(úüï(VS Each yielded flags value will correspond to a defined named flag. Any unknown bitsÁüÊ)41 will be yielded together as a final flags value.Á$†*ü üçÐÀû{ ‹*{
çÐ$Œ*üÊ,-üÑ*0- Yield a set of contained named flags values.Á†+úüŽ+ZW This method is like [`Flags::iter`], except only yields bits in contained named flags.Áüí+XU Any unknown bits, or bits not corresponding to a contained flag will not be yielded.ÁTÍ,ý ýçÐôü{ Ø,{
ŒçÐ$Ù,üë-7ü¨->; Yield a set of all named flags defined by [`Self::FLAGS`].Á”î-µþ{{
çÐü”08üÖ.@= Get an iterator over all defined names for this flags value.Á/úü£/MJ This iterator will yield all defined names for the flags value, includingÁÔõ/ any convenience flags.Á„—0þ þçÐÔÿ{ ¨0{
ŽçÐ$©0Ôº1ü‚130 Whether all bits in this flags value are unset.ÁD½1ÿ ÿçÐ{ Æ1{
çÐ$Ç1ÄÇ2ü‹274 Whether all known bits in this flags value are set.Á4Ê2 çÐ{ Ñ2{
çÐ$Ò2üì4Hü¬4;8 Whether any set bits in `other` are also set in `self`.ÁTï4 çÐçÐ{ ú4{›ì,®5
çÐ$û4¹
„ü¾6Füþ5;8 Whether all set bits in `other` are also set in `self`.ÁDÁ6 çÐçÐ{ Ê6{›ì,þ6
çÐ$Ë6¹
û…üù75üÉ7+( Remove any unknown bits from the flags.ÁDü7ƒ ƒçЪK{ …8{›ì,¨8
çÐ$Š8ü·9@ü÷8;8 The bitwise or (`|`) of the bits in `self` and `other`.Á4º9 çÐçЪK{ Á9{›ì,ñ9‹œ$Æ9¹

‰ü½<@üË:EB The intersection of `self` with the complement of `other` (`&!`).Á•;úü;WT This method is not equivalent to `self & !other` when `other` has unknown bits set.Áüù;?< `remove` won't truncate `other`, but the `!` operator will.Á4À< çÐçЪK{ Ç<{›ì,÷<¿œ$Ì<¹
Šü >@üÖ=EB The bitwise exclusive-or (`^`) of the bits in `self` and `other`.Á4£> çÐçЪK{ ª>{›ì,Ú>
çÐ$¯>¹
Z‰ü§@JüÃ?_\ Call [`Flags::insert`] when `value` is `true` or [`Flags::remove`] when `value` is `false`.Áª@ çÐçЪK{ ®@{›ì,ë@
çÐ$³@¹
øˆ»÷ˆü—B2üñA! Unsets all bits in the flags.Á,šBˆ ˆçЪK{  B{›ì,ÃB
˜çÐ$¥BüËC*üúB<9 The bitwise and (`&`) of the bits in `self` and `other`.Á.\»CdÎCçÐçÐçÐ{{
çÐà‡¹
݇üŽE#ü¾D;ˆ§.\þD,EçÐçÐçÐ{{בx†¹
u†ü€H(üúEE°¨ÄFúüÌFW‹©ü¨GC@ `difference` won't truncate `other`, but the `!` operator will.Á.\ðGTƒHçÐçÐçÐ{{•U…¹
R…üÌI2üòHE˜«.\¼I¤ÏIçÐçÐçÐ{{­™σ¹
̃ܨKüÇJLI The bitwise negation (`!`) of the bits in `self`, truncating the result.Á.\˜KT«KçÐçÐ{{
çÐ
ƒü¿LºüþK@;
A bits type that can be used as storage for a flags type.
Á$ÉLžž
›ì,æMØçÐ,ÓLŠ çÐ$ßLµßçÐçÐLêLöøçÐçЬúLçÐçÐøøçÐlM–úçÐçФ–MçÐçИúçÐlœM¶ûçÐçЬ±MçÐçиûçÐl¸M•!çДÍMçЖ!çÐlÑMé…<òMž›ìÿѶõá¶ëñ¶܆·Í›·»³·¬È·šà·õ·y¸o¸bé…`›ìMѶDá¶;ñ¶-†·›·³·È·ïà·àõ·θĸ·é…µŸ Ÿ Œ¥Nü€N  A value with all bits unset.Á,«NžžçÐ|àNô½N A value with all bits set.ÁæNžžçМ€PLŠP¡¡éç´€P¡éçéç´˜PL¥P ¯P ¨Z µP ÇP, ¶P ·P ÅP
, ¸P8À ¹P& ºP8´»P$ ½P, ¿P8´ ÀP& ÁP8´ÂP$ ÄP
ÆP*ÉP ÌP ¦Z, ÖP ×P ŸZ08$åP8Ö $êP8
ïP, óP8À ôP öP ÔQ8,ˆQ8Ó,ŽQ& “Q, •Q8À Q ˜Q7ˆ šQ% Q8,­Q8à³Q& ¶Q, ¸Q8À ¹Q »Q ½Q, ¾Q8À ¿Q ÀQ'ÁQ8MAXÁÃQ% ÆQ8$ãQ8Ö $èQ8
íQ, ñQ8´ òQ ôQ ØR8,†R8Ó,ŒR& R, “R8´ ”R R7ˆ ˜R% ™R8,«R8à±R& ´R, ¶R8´ ·R ¹R »R, ¼R8À ½R ¾R'¿R8ß½ÁR8ÅR, ÈR8´ ÉR% ÊR8$çR8¯
DìR8
õR, ùR8À úR üR ÉT 8 ŽS8¾
LS šS ¦S8óŠ,S&  S ¢S8É£S(¨S8Í4«S ±S8$²S$ ¶S8T¸S ÂS ÄS »T
 ÚS, ÛS8À ÜS ÝS'ÞS8from_str_radixÁtàS îS øS8óŠ,ïS$ ôS716ÁöS ùS8Ù<úS T ©T T8 ƒT „T8T†T'T8Ò
„’T ¢T ¨T8óŠ,£T8$ØT8¯
DÝT8
æT, êT8´ ëT íT ºV 8 ÿT8¾
LU ‹U —U8óŠ,ŒU& U “U8É”U(™U8Í4œU ¢U8$£U$ §U8T©U ³U µU ¬V
 ËU, ÌU8´ ÍU ÎU'ÏU8úÁtÑU ßU éU8óŠ,àU$ åU7´ÂçU êU8Ù<ëU òU šV óU8 ôU õU8T÷U'V8Ò
„ƒV “V ™V8óŠ,”V8$ÉV8
DÎV8
×V, ÛV8À ÜV ÞV X8 ðV8˜
LóV üV8¨ ýV& þV8×€W'ƒW8ÍÕ,…W ŠW W  W ŒW8$W$ W8“W8üq4—W& W8¨ ŸW(¢W8×¥W'¨W8Í4ªW ±W ôW8writeÁ,ÇW ÌW ÍW âW8üq4ÎW$ ÔW7{:x}Á4ÖW$ ÜW8$ÞW8$X8
DX8
ŸX, £X8´ ¤X ¦X ÊY8 ¸X8˜
L»X ÄX8¨ ÅX& ÆX8×ÈX'ËX8ÍÕ,ÍX ÒX ÓX èX ÔX8$ÕX$ ÙX8ÛX8üq4ßX& åX8¨ çX(êX8×íX'ðX8Í4òX ùX ¼Y8×È,Y ”Y •Y ªY8üq4Y$ œY7ŽÉ4žY$ ¤Y8$¦Y8$ÙY8êLÞY8
èY, ìY8´ íY ïY ðY8$þY8êLƒZ8
Z, Z8À Z ”Z •Z
 Z¬ô[ü“[>; A trait for referencing the `bitflags`-owned internal typeÁüÒ[! without exposing it publicly.Á\þ[££éçüô[¼£éçéç ¤¥¤¥ÍìçФԼ\¡ØÏLÌ\ÐÏèÏÍìçÐ¥t ]…Ð̼\ü\'$ The type of the underlying storage.ÁLÁ\££l ]üÜ\?< The type of the internal field on the generated flags type.ÁD¥]££ü÷]64¸]use the `Flags` trait insteadÁüÕ]üÁ]5D^ðЦ¦éçü÷]½¯çÐÔ‹^{çÐ,¨^¦éç9ËÒ-ÛÒ$éçKËÒ?ÛÒ¨§¨ÍìçЧü÷^!ùM¯Ó¬‚_¯ÓúMçÐ\‹_§Ó,ÀÓ!ÐÓÍìçШüü_6ùMþÓüŒ`%þÓúMñÅçÐÜ•`öÓ2Ô' Ôü÷^ ü´^>; An iterator over enabled flags in an instance of the type.Á$ü^ðЦ¦üü_5üž_YV An iterator over the raw names and bits for enabled flags in an instance of the type.ÁL`ðЦ¦ìË`ªª€· Ð`’¸,Ó`Û"«¬§¨Lï`$ô`©©§"taLa©©è"ü¼a/®®€· Áa’¸,ÄaÛ"ü“d$üðaeb A marker trait that signals that an implementation of `BitFlags` came from the `bitflags!` macro.ÁÖbúüÚbc` There's nothing stopping an end-user from implementing this trait, but we don't guarantee theirÁü¾cEB manual implementations won't break between non-breaking releases.Á4ŠdÔd¯¯éçü“d'¯éçéçļdLËdûÔëd¯²Š\‡e£³,ãd%'Œ†A4ý@LŽAí$ÔB¸ûg¯·²Ši£·³,Bœ˜BŒ°BBDDþB„©Cît¬ÆeüÆQïê
Generate a flags type.
# `struct` mode
A declaration that begins with `$vis struct` will generate a `struct` for a flags type, along with
methods and trait implementations for it. The body of the declaration defines flags as constants,
where each constant is a flags value of the generated flags type.
## Examples
Generate a flags type using `u8` as the bits type:
```
# use bitflags::bitflags;
bitflags! {
struct Flags: u8 {
const A = 1;
const B = 1 << 1;
const C = 0b0000_0100;
}
}
```
Flags types are private by default and accept standard visibility modifiers. Flags themselves
are always public:
```
# use bitflags::bitflags;
bitflags! {
pub struct Flags: u8 {
// Constants are always `pub`
const A = 1;
}
}
```
Flags may refer to other flags using their [`Flags::bits`] value:
```
# use bitflags::bitflags;
bitflags! {
struct Flags: u8 {
const A = 1;
const B = 1 << 1;
const AB = Flags::A.bits() | Flags::B.bits();
}
}
```
A single `bitflags` invocation may include zero or more flags type declarations:
```
# use bitflags::bitflags;
bitflags! {}
bitflags! {
struct Flags1: u8 {
const A = 1;
}
struct Flags2: u8 {
const A = 1;
}
}
```
# `impl` mode
A declaration that begins with `impl` will only generate methods and trait implementations for the
`struct` defined outside of the `bitflags` macro.
The struct itself must be a newtype using the bits type as its field.
The syntax for `impl` mode is identical to `struct` mode besides the starting token.
## Examples
Implement flags methods and traits for a custom flags type using `u8` as its underlying bits type:
```
# use bitflags::bitflags;
struct Flags(u8);
bitflags! {
impl Flags: u8 {
const A = 1;
const B = 1 << 1;
const C = 0b0000_0100;
}
}
```
# Named and unnamed flags
Constants in the body of a declaration are flags. The identifier of the constant is the name of
the flag. If the identifier is `_`, then the flag is unnamed. Unnamed flags don't appear in the
generated API, but affect how bits are truncated.
## Examples
Adding an unnamed flag that makes all bits known:
```
# use bitflags::bitflags;
bitflags! {
struct Flags: u8 {
const A = 1;
const B = 1 << 1;
const _ = !0;
}
}
```
Flags types may define multiple unnamed flags:
```
# use bitflags::bitflags;
bitflags! {
struct Flags: u8 {
const _ = 1;
const _ = 1 << 1;
}
}
```
Á(|¶eã~ Üe ýƒ  âe Îg, ìe íe üe+ îe ïe ûe, ðe8outerÁ,ñe& öe8û$÷e
ýe, ‡f8ƈf& f8ÆŒf84f, —f8´D˜f&  f8¼,¡f& ¦f, ¨f8¥ ©f& ªf8´«f ®f µg, ¼f ½f ªg, Ïf Ðf íf+ Ñf Òf ìf, Óf8ù,Ôf& Ùf8¼,Úf, àf áf êf, âf8À$ãf& çf8¯èf
ëf
îf8,€g, †g8«$‡g& g8¯Œg g, g8»,g& —g8$˜g% œg
«g, Àg Ág Çg, Âg8¿ Ãg& Äg8¯Åg
Èg*Ðg Óg Öx, Éh8,Êh'Ïh8ªÌÑh êh ìh ²i, úh ûh …i+ üh ýh „i, þh8–ð,ÿh
†i, ”i8Æ•i84™i,  i8´D¡i+ ½i ¾i Úl8«,¿i Äi Ùl"8LÒi$ Ûi8±Téi$ ói8unused_doc_commentsÁœj$ ”j8unused_attributesÁŒ¢j$ ³j8
unused_mutÁTÁj$ Ëj8žtÙj$ çj8non_upper_case_globalsÁ´õj$ k84™k'Ÿk8min_ident_charsÁ|¡k$ °k84¾k'Äk8assign_op_patternÁŒÆk$ ×k84åk'ëk8indexing_slicingÁ„ík$ ýk84l'l8same_name_methodÁ„“l$ £l84±l'·l8iter_without_into_iterÁ´¹l$ Ïl8,äl8 êl& ël íl îl ðl òl •x*, ‰n8,Šn'n8Ü‘n ¬n ®n ín, Àn8ÆÁn84Ån8InternalBitFlagsÁ„Ìn& Ün, Þn8¥ ßn, ün8,ýn'o8Ôì„o ¡o £o ïp, µo8´D¶o& ¾o, Ào8¥ Áo Ão áp, Ùo Úo Îp
, ôo õo ‰p+ öo ÷o ˆp, øo8ù,ùo, ÿo €p †p, p8À$p
‡p
Šp8,¤p, ªp8«$«p °p, ²p8»,³p% ¸p
Ïp, þp8,ÿp'„q8£Ćq žq  q þr8×ú„²q& Âq, Äq8¥ Åq$ Æq, Èq8´DÉq Òq ðr, èq éq Ýr
, ƒr „r ˜r+ …r †r —r, ‡r8ù,ˆr, Žr r •r, r8À$r
r
™r8,³r, ¹r8«$ºr ¿r, Ár8»,Âr% Çr
Þr, Ùs8,Ús'ßs8ÒÄás ùs ûs Ðu8×út& t, Ÿt8¥  t$ ¡t, £t8´D¤t ­t Âu, Ãt Ät ¯u, Þt ßt ót+ àt át òt, ât8ù,ãt, ét êt ðt, ët8À$ìt
ñt
ôt8,Žu, ”u8«$•u% ™u
°u, ßu8,àu'åu8Ëôçu …v ‡v Åv, ™v8´Dšv& ¢v, ¤v8¥ ¥v$ ¦v8×ú„¨v, Ôv8,Õv'Úv8²ÔÜv öv øv  w, Šw8´Dw, ¯w8,°w'µw8Ü·w Òw Ôw x, æw8´Dçw& ïw, ñw8¥ òw$ ów, õw8´Döw% x, ¡x8,¢x'§x8ÞD©x ±x ³x Ðx, Áx Âx Åx, Ãx8¿ Äx
Æx% ×x Ýx ¾z, çx èx ÷x+ éx êx öx, ëx8–ð,ìx& ñx8û$òx
øx8$y, ‡y8´Dˆy& y8¼,y& y, ˜y8¥ ™y& šy8´y žy ¥z, ¬y ­y šz, ¿y Ày Ýy+ Áy Ây Üy, Ãy8ù,Äy& Éy8¼,Êy, Ðy Ñy Úy, Òy8À$Óy& ×y8¯Øy
Ûy
Þy8,ðy, öy8«$÷y& ûy8¯üy ÿy, z8»,z& ‡z8$ˆz% Œz
z, °z ±z ·z, ²z8¿ ³z& ´z8¯µz
¸z*Àz Ãz ìƒ+ Íz Îz ž}8«,Ïz Ôz }8Lâz$ ëz8±Tùz$ ƒ{8 öœ‘{$ ¤{8ÅöŒ²{$ Ã{8èöTÑ{$ Û{8žté{$ ÷{8–÷´…|$ |84©|'¯|8Ð÷|±|$ À|84Î|'Ô|8ƒøŒÖ|$ ç|84õ|'û|8 ù´ý|$ “}8,¨}8 ®}& ¯} ±} ²} ´} ¶} «ƒ, Ä}8,Å}'Ê}8ÔìÌ} é} ë} ·, ý}8´Dþ}& †~, ˆ~8¥ ‰~ ~ ©, ¡~ ¢~ 
, ¼~ ½~ Ñ~+ ¾~ ¿~ Ð~, À~8ù,Á~, Ç~ È~ Î~, É~8À$Ê~
Ï~
Ò~8,ì~, ò~8«$ó~ ø~, ú~8»,û~% 
, Æ8'Ì8ñ´Î ä æ Û , ø ù ƒ€+ ú û ‚€, ü8–ð
„€, –€8´D—€& Ÿ€, ¡€8¥ ¢€$ £€, ¥€8´D¦€ ¯€ Í, Å€ Æ€ º
, à€ á€ õ€+ †〠ô€, ä€8ù,å€, ë€ ì€ ò€, í€8À$î€
ó€
ö€8,, 8«$— œ, ž8»% ¤
», ê8'ð8²Ôò Œ‚ Ž‚ ¶‚,  ‚8´D¡‚, Å‚8,Æ‚'Ë‚8ÜÍ‚ è‚ ê‚ ¡ƒ, ü‚8´Dý‚& …ƒ, ‡ƒ8¥ ˆƒ$ ‰ƒ, ‹ƒ8´DŒƒ% ¬ƒ, ·ƒ8,¸ƒ'½ƒ8ÞD¿ƒ ǃ Ƀ æƒ, ׃ ؃ Ûƒ, Ùƒ8¿ Úƒ
܃% íƒ óƒ ôƒ*öƒ ùƒ úƒ% ûƒäâ…ü€„*' Implement functions on bitflags types.Á«„úü¯„^[ We need to be careful about adding new methods and trait implementations here because theyÁüŽ…41 could conflict with items added by the end-user.Á(|Ã…4Ù…ò’ ÿ… ¡µ …† ¦‘(8paramsÁ4•‡& ›‡, 8$ž‡& ¢‡8¼,£‡$ ¨‡, ª‡8´$«‡& ¯‡8¼,°‡$ µ‡, ·‡8Ð $¸‡& ¼‡8¼,½‡$ ‡, ć8¹
,Ň& ʇ8¼,ˇ$ Ї, Ò‡8»,Ó‡& ؇8¼,Ù‡% Þ‡, è‡ é‡ ø‡+ ê‡ ë‡ ÷‡, ì‡8–ð,í‡& ò‡8û$ó‡
ù‡, ƒˆ8PublicBitFlagsÁt„ˆ& ’ˆ8¼,“ˆ& ˜ˆ, šˆ8¥ ›ˆ& œˆ8´ˆ  ˆ  ‘Œ8 ®ˆ8á ,±ˆ ¶ˆ ·ˆ, ¹ˆ8
empty_bodyÁTºˆ& Ĉ8¸,ň8 ׈8£Úˆ ݈ Þˆ, àˆ8all_bodyÁDáˆ& éˆ8¸,êˆ8 üˆ8´$ÿˆ ƒ‰ ‰‰ „‰8$…‰, ‹‰8 bits_bodyÁLŒ‰& •‰8¸,–‰8 ¨‰8Õ
L«‰ ´‰ ¹‰8´$µ‰, »‰8from_bits_bodyÁt¼‰& ʉ8¸,ˉ8 ݉8å
”à‰ ò‰ ÷‰8´$ó‰, ù‰8from_bits_truncate_bodyÁ¼ú‰& ‘Š8¸,’Š8 ¤Š8þ
„§Š ·Š ¼Š8´$¸Š, ¾Š8from_bits_retain_bodyÁ¬¿Š& ÔŠ8¸,ÕŠ8 çŠ8LêŠ óŠ øŠ8Ð $ôŠ, úŠ8from_name_bodyÁtûŠ& ‰‹8¸,Š‹8 œ‹8íDŸ‹ §‹ ­‹ ¨‹8$©‹, ¯‹8
is_empty_bodyÁl°‹& ½‹8¸,¾‹8 Ћ8ü4Ó‹ Ù‹ ß‹ Ú‹8$Û‹, á‹8 is_all_bodyÁ\â‹& í‹8¸,î‹8 €Œ8TƒŒ Œ šŒ ŽŒ8$Œ$ “Œ8¹
,•Œ, œŒ8intersects_bodyÁ|Œ& ¬Œ8¸,­Œ8 ¿Œ8šDÂŒ ÊŒ ׌ ËŒ8$ÌŒ$ ÐŒ8¹
,Ҍ, ٌ8
contains_bodyÁlÚŒ& çŒ8¸,èŒ8 úŒ8¸4ýŒ ƒ  88$‰$ 8¹
,, 8 insert_bodyÁ\—& ¢8¸8 µ8Å ¾ Ï ¿8À8$ È8¹
, Ñ8 remove_bodyÁ& Ý8¸8 ð8Ò ù ŠŽ ú8û8$ÿ$ ƒŽ8¹
,…Ž, ŒŽ8 toggle_bodyÁ\Ž& ˜Ž8¸,™Ž8 «Ž8ß®Ž ±Ž ÉŽ ²Ž8³Ž8$·Ž$ »Ž8¹
,½Ž$ ÂŽ8»,ÄŽ, ËŽ8set_bodyÁDÌŽ& ÔŽ8¸,ÕŽ8 çŽ8õdêŽ öŽ 8$÷Ž$ ûŽ8¹
,ýŽ, 8intersection_bodyÁŒ…& 8¸,—8 ©8C ± ½8$ 8¹
,¸, ¿8
union_bodyÁ& Ê8¸8 Ý8Ž ê ö8$ ï8¹
, ø8difference_bodyÁ& ˆ8¸,‰8 8Ÿ¤ž ² ¾8$ ·8¹
, À8symmetric_difference_bodyÁÌÁ& Ú8¸8 í8º ú ÿ8, 8complement_bodyÁ|‚‘& ‘‘8¸,’‘*¨‘ «‘ žµ, µ‘ ¶‘ À‘+ ·‘ ¸‘ ¿‘, ¹‘8–ð,º‘
Á‘8$Ë‘, Б8ùštÑ‘ à‘ ˜µ<âˆüî‘*+ ¥’ ¦’ ­’8Ý4§’8»’8,¿’8 Å’8á ,È’ Í’ Î’(Ð’8$Ó’, è’8•œTé’<ʉü.+ ¼“ ½“ Ä“8Ý4¾“8Ò“8,Ö“8 Ü“8£ß“ â“ ã“(å“8$è“, ý“8íœDþ“<ûü””"<úÔ<³‘üÓ”C+ £• ¤• «•8Ý4¥•8¹•8,½•8 Õ8´$Æ• Ê• Ñ• Ë•, Ì•8$Í•(Ó•, Ö•8¥ ו, é•8ÖLê•<Ñ’ô<ú¬–<…“ü¼–?+ ˆ— ‰— 8Ý4Š—8ž—8,¢—8 ¨—8Õ
L«— ´— ¾—, µ—8´$¶—& º—, ¼—8¥ ½—(À—, ×8,Ä—'É—8œLË—'Ô—8í$Ö—'Ú—8³
4Ü—'â—8¬4ä— ê—8$ë— ï—, ˜8¹žt‚˜<“”üž˜:+ å˜ æ˜ í˜8Ý4ç˜8û˜8,ÿ˜8 …™8å
”ˆ™ š™ ¤™, ›™8´$œ™&  ™, ¢™8¥ £™(¦™8$©™, ¾™8¡Ÿ¼¿™<–•üä™&+ —š ˜š Ÿš8Ý4™š8­š8,±š8 ·š8þ
„ºš Êš Ôš, Ëš8´$Ìš& К, Òš8¥ Óš(Öš8$Ùš, îš8’ ¬ïš<†–ü’›F<úå›<â–üõ›@<¬—üœ!+ ðœ ñœ øœ8Ý4òœ88 Š8L  ¢, 8Ð $˜& œ ž8ÉŸ(¤, §8'­8œ'¸8í'¾8³
'Æ8¬ Î8 Ó, å8¡<& Whether all bits in `self` are unset.Áü‚ž)+ ¸ž ¹ž Àž8Ý4ºž8Ξ8,Òž8 Øž8íDÛž ãž êž äž, åž8$æž(ìž8º$ïž, „Ÿ8ð¡l…Ÿ<ƒ¢ü Ÿ7+ äŸ åŸ ìŸ8Ý4æŸ8úŸ8,þŸ8 „ 8ü4‡    ”  Ž ,  8$ ( 8º$™ , ® 8Þ¢\¯ <š£üÈ ;+ ¡ ‘¡ ˜¡8Ý4’¡8¦¡8,ª¡8 °¡8T³¡ ½¡ Ò¡ ¾¡, ¿¡8$À¡$ Ä¡, Æ¡8¹
,Ç¡& Ì¡8$Ρ(Ô¡8º$ס, ì¡8Þ£|í¡<ǤüŠ¢;+ Ò¢ Ó¢ Ú¢8Ý4Ô¢8è¢8,ì¢8 ò¢8šDõ¢ ý¢ ’£ þ¢, ÿ¢8$€£$ „£, †£8¹
,‡£& Œ£8$Ž£(”£8º$—£, ¬£8â¤l­£<ˆ§üÈ£;+ ¤ ‘¤ ˜¤8Ý4’¤8¦¤8 ª¤8¸4­¤ ³¤ ̤  ´¤8µ¤, ¹¤8$º¤$ ¾¤, À¤8¹
,Á¤& Ƥ8$Ȥ, Þ¤8ï¥\ߤ<°¨üø¤E<úÊ¥<‹©üÚ¥W<ì©ü¾¦?+ Ч ‹§ ’§8Ý4Œ§8 §8 ¤§8Å4§§ ­§ Ƨ  ®§8¯§, ³§8$´§$ ¸§, º§8¹
,»§& À§8$§, ا8ú¦\Ù§<˜«üò§E+ Ĩ Ũ ̨8Ý4ƨ8Ú¨8 Þ¨8Ò4á¨ ç¨ €©  è¨8é¨, í¨8$î¨$ ò¨, ô¨8¹
,õ¨& ú¨8$ü¨, ’©8…¨\“©<J Call `insert` when `value` is `true` or `remove` when `value` is `false`.Áü¬©M+ †ª ‡ª Žª8Ý4ˆª8œª8  ª8ߣª ¦ª ͪ §ª8¨ª, ¬ª8$­ª$ ±ª, ³ª8¹
,´ª& ¹ª8$»ª$ ¿ª, Áª8»,ª& Ǫ8º$ɪ, ߪ8¤©Dàª<´¯üöª<+ ¿« À« Ç«8Ý4Á«+ Õ« Ö« ß«8Ç D׫8í«8,ñ«8 ÷«8õdú« †¬ š¬, ‡¬8$ˆ¬$ Œ¬, ެ8¹
,¬& ”¬8$–¬(œ¬8$Ÿ¬, ´¬8™ªŒµ¬<ˆ§üÔ¬;+ œ­ ­ ¤­8Ý4ž­+ ²­ ³­ ¼­8Ç D´­8Ê­8,έ8 Ô­8C,×­ Ü­ ð­, Ý­8$Þ­$ â­, ä­8¹
,å­& ê­8$ì­(ò­8$õ­, Š®8–«T‹®<°¨ü£®E<úõ®<‹©ü…¯W<Ô±üé¯C+ ¹° º° Á°8Ý4»°+ ϰ а Ù°8Ç DѰ8ç°8,ë°8 ñ°8ŽTô° þ° ’±, ÿ°8$€±$ „±, †±8¹
,‡±& Œ±8$ޱ(”±8$—±, ¬±8¬|­±<˜«üʱE+ œ² ² ¤²8Ý4ž²+ ²² ³² ¼²8Ç D´²8ʲ8,β8 Ô²8Ÿ¤×² ë² ÿ², ì²8$í²$ ñ², ó²8¹
,ô²& ù²8$û²(³8$„³, ™³8‰­Ìš³<̳üÁ³L+ š´ ›´ ¢´8Ý4œ´+ °´ ±´ º´8Ç D²´8È´8,Ì´8 Ò´8ºTÕ´ ß´ å´, à´8$á´(ç´8$ê´, ÿ´8û­|€µ% ŸµܹÃü¤µKH A macro that matches flags values, similar to Rust's `match` statement.Áðµúüôµc` In a regular `match` statement, the syntax `Flag::A | Flag::B` is interpreted as an or-pattern,Áüضol instead of the bitwise-or of `Flag::A` and `Flag::B`. This can be surprising when combined with flags typesÁüÈ·li because `Flag::A | Flag::B` won't match the pattern `Flag::A | Flag::B`. This macro is an alternative toÁüµ¸:7 `match` for flags values that doesn't have this issue.Áð¸údô¸ # SyntaxÁ¹úl…¹
```ignoreÁü“¹! bitflags_match!(expression, {Áäµ¹ pattern1 => result1,ÁäÒ¹ pattern2 => result2,ÁTï¹ ..Áäú¹ _ => default_result,Á4—º })Á<žº ```Á¦ºúüªº^[ The final `_ => default_result` arm is required, otherwise the macro will fail to compile.Á‰»út» # ExamplesÁœ»ú\ » ```rustÁü¬»-* use bitflags::{bitflags, bitflags_match};ÁÚ»ú|Þ» bitflags! {Áäî» #[derive(PartialEq)]ÁÔ‹¼ struct Flags: u8 {Á즼 const A = 1 << 0;Áìļ const B = 1 << 1;Áìâ¼ const C = 1 << 2;ÁL€½,н½úü”½$! let flags = Flags::A | Flags::B;Á¹½úü½½$! // Prints `the value is A and B`Áäâ½ bitflags_match!(flags, {Áüÿ½@= Flags::A | Flags::B => println!("the value is A and B"),ÁüÀ¾2/ _ => println!("the value is not A and B"),Á<ó¾ });Áû¾úüÿ¾" // Prints `the value is not A`Á䢿¦ßü¿¿/, Flags::A => println!("the value is A"),Áüï¿,) _ => println!("the value is not A"),Á<œÀÔà<¤À¡Ú¬Àú”°À # How it worksÁÃÀúüÇÀhe The macro expands to a series of `if` statements, **checking equality** between the input expressionÁü°Áeb and each pattern. This allows for correct matching of bitflag combinations, which is not possibleÁü–ÂLI with a regular match expression due to the way bitflags are implemented.ÁãÂúüçÂA> Patterns are evaluated in the order they appear in the macro.Á(|©Ã¹ Õà íÅ Ûà †Ä, ÜÃ8 operationÁLÝÃ& æÃ8$çÃ$ ëà íà …Ä, ÷à øÃ þÃ, ùÃ8¿ úÃ& ûÃ8¯üÃ
ÿÃ*ˆÄ ‹Ä êÅ •Å âÅ–Å ™Å áÅ, §Å8,¨Å'­Å8˜„¯Å ¿Å ÀÅ ×Å, ÁÅ8ªæLÂÅ$ ËÅ ÍÅ ÖÅ, ÏÅ ÐÅ ÓÅ, ÑÅ8¿ ÒÅ
ÔÅ ãÅ äÅ% ëÅìµÆüðÅ%" Expand the `bitflags_match` macroÁ(|–Æ4¬Æ¹ ÓÆ žÎ Ç ÓÇ, ‘Ç8ªæL’Ç& ›Ç8$œÇ$  Ç ¢Ç ÒÇ
, ¤Ç8patternÁ<¥Ç& ¬Ç8$­Ç*²Ç µÇ ÄÇ, ·Ç ¸Ç ÁÇ, ¹Ç8bodyÁ$ºÇ& ¾Ç8¯¿Ç
ÂÇ$ ÆÇ, ÈÇ ÉÇ ÏÇ, ÊÇ8¿ ËÇ& ÌÇ8¯ÍÇ ÐÇ*ÕÇ ØÇ ²È, âÇ8,ãÇ'èÇ8˜„êÇ úÇ ûÇ ¬È, üÇ8ªæLýÇ$ †È ˆÈ «È, ŠÈ8âê<‹È*“È –È ¢È, ˜È ™È ŸÈ, šÈ8¿ë$›È
 È, ¤È ¥È ¨È, ¦È8¿ §È ©È% ³È çÈ ¨É, èÈ8ªæLéÈ& òÈ8$óÈ$ ÷È ùÈ §É , ûÈ8âê<üÈ& ƒÉ8$„É*‰É ŒÉ ›É, ŽÉ É ˜É, É8¿ë$‘É& •É8¯–É
™É, É žÉ ¤É, ŸÉ8¿  É& ¡É8¯¢É ¥É*ªÉ ­É †Ë ·É €Ë
8ÅÉ, ÈÉ8ªæLÉÉÓÉ, ÖÉ8âê<×É ßÉ ·Ê84ñÉ øÉ ¨Ê, ŽÊ Ê •Ê, Ê8¿ë$‘Ê
–Ê% ©Ê, ÆÊ8,ÇÊ'ÌÊ8˜„ÎÊ ÞÊ ßÊ öÊ, àÊ8ªæLáÊ$ êÊ ìÊ õÊ, îÊ ïÊ òÊ, ðÊ8¿ ñÊ óÊ% ‡Ë ½Ë úË, ¾Ë8ªæL¿Ë& ÈË8$ÉË$ ÍË ÏË ùË
, ÑË8âê<ÒË& ÙË8$ÚË*ßË, âË8¿ë$ãË& çË8$èË$ íË, ïË ðË öË, ñË8¿ òË& óË8¯ôË ÷Ë*üË ÿË ¬Í ‰Ì ¦Í
8—Ì, šÌ8ªæL›Ì¥Ì, ¨Ì8âê<©Ì ±Ì ÝÌ84ÃÌ, ÊÌ8¿ë$ËÌ% ÏÌ, ìÌ8,íÌ'òÌ8˜„ôÌ „Í …Í œÍ, †Í8ªæL‡Í$ Í ’Í ›Í, ”Í •Í ˜Í, –Í8¿ —Í ™Í% ­Í ÒÍ €Î, ÓÍ8ªæLÔÍ& ÝÍ8$ÞÍ$ âÍ äÍ ÿÍ 8 æÍ*èÍ, ëÍ8><ìÍ& óÍ8$ôÍ, ùÍ úÍ üÍ$ ûÍ- ýÍ*‚Î …Î œÎ, Î8><ÎäÕÏü¡Î2/ Implement a flag, which may be a wildcard `_`.ÁÔÎúüØÎ]Z Named flags will emit the `named` block, and unnamed flags will emit the `unnamed` block.Á(|¶Ï4ÌÏ òÏ ÈÒ øÏ ÷Ð ‚Ð ñÐ 8Ð $Ð& ”Ð8 –Ð$ —Ð8namedÁ,¥Ð& ªÐ ¬Ð ¼Ð, ®Ð ¯Ð ¹Ð, °Ð8¢ü,±Ð& ¶Ð8¯·Ð
ºÐ$ ½Ð8unnamedÁ<ËÐ& ÒÐ ÔÐ æÐ, ÖÐ ×Ð ãÐ, ØÐ8šý<ÙÐ& àÐ8¯áÐ
äÐ$ çÐ*ùÐ üÐ —Ñ, †Ñ ‡Ñ Ñ, ˆÑ8šý<‰Ñ
‘Ñ% ˜Ñ žÑ §Ò ¨Ñ ¡Ò8Ð $¶Ñ& ºÑ, ¼Ñ8«$½Ñ& ÁÑ8¼,ÂÑ$ ÇÑ8¢ü,ÕÑ& ÚÑ ÜÑ ìÑ, ÞÑ ßÑ éÑ, àÑ8¢ü,áÑ& æÑ8¯çÑ
êÑ$ íÑ8šý<ûÑ& ‚Ò „Ò –Ò, †Ò ‡Ò “Ò, ˆÒ8šý<‰Ò& Ò8¯‘Ò
”Ò$ —Ò*©Ò ¬Ò ÅÒ, ¶Ò ·Ò ¾Ò, ¸Ò8¢ü,¹Ò
¿Ò% ÆÒüžÜ'üØRO A macro that processes the input to `bitflags!` and shuffles attributes aroundÁüðØ63 based on whether or not they're "expression-safe".Á§Ùúü«Ù>; This macro is a token-tree muncher that works on 2 levels:ÁêÙúüîÙVS For each attribute, we explicitly match on its identifier, like `cfg` to determineÁüÅÚ;8 whether or not it should be considered expression-safe.ÁÛúü…ÛTQ If you find yourself with an attribute that should be considered expression-safeÁüÚÛ$! and isn't, it can be added here.Á(|ÿÛ4•Ü ÆÜ §ê ÌÜ Ý, ÖÜ ×Ü ôÜ+ ØÜ ÙÜ óÜ, ÚÜ8ù,ÛÜ& àÜ8¼,áÜ, çÜ èÜ ñÜ, éÜ8À$êÜ& îÜ8¯ïÜ
òÜ
õÜ ÿÜ ‰Ý, Ý8° ‚Ý& ƒÝ8$„Ý*‘Ý ”Ý ×ß, žÝ8,ŸÝ'¤Ý8ÅÔ¦Ý ÀÝ ÂÝ Ñß8$ÐÝ& ÔÝ ÖÝ ÛÝ, ØÝ8° ÙÝ$ ÜÝ8attrsÁ,êÝ& ïÝ ñÝ Æß8 unprocessedÁ\°Þ& »Þ ½Þ ÕÞ,
attrs_restÁTöà& €á8¯á
„á$ “á8Û‹L¡á& ªá ¬á ¹á, ­á ®á ·á, ¯á8$°á& ´á8¯µá
¸á$ ºá$ Åá*Íá Ðá •ä, Úá8,Ûá'àá8ÅÔâá üá þá ä8$Œâ& â ’â —â, ”â8° •â$ ˜â8€Š,¦â& «â ­â „ä8¨Š\¿â& Êâ Ìâ ‚ã, ââ ãâ ïâ, äâ8ÒŽTåâ
ðâ$ ƒã8Û‹L•ã& žã  ã õã, ¶ã ·ã ½ã, ¸ã8$¹ã
¾ã+ Ôã Õã ãã8âÖã, Úã Ûã áã, Üã8À$Ýã
âã$ öã$ …ä% –ä ²ä æ8$¼ä& Àä Âä Ìä, Ää8° Åä& Æä8$Çä$ Íä8€Š,×ä& Üä Þä ‰æ8¨Š\ìä& ÷ä ùä ×å+ ‹å Œå ¦å, å8¹
,Žå& “å8¼,”å, šå ›å ¤å, œå8À$å& ¡å8¯¢å
¥å, ¸å ¹å Èå, ºå8ÒŽT»å& Åå8¯Æå
Éå$ Øå8Û‹Læå& ïå ñå þå, òå óå üå, ôå8$õå& ùå8¯úå
ýå$ ÿå$ Šæ*’æ •æ ¹è, Ÿæ8, æ'¥æ8ÅÔ§æ Áæ Ãæ ³è8$Ñæ& Õæ ׿ Üæ, Ùæ8° Úæ$ Ýæ8€Š,ïæ& ôæ öæ ¨è8¨Š\ˆç& “ç •ç Ëç, «ç ¬ç ¸ç, ­ç8ÒŽT®ç
¹ç$ Ìç8Û‹LÞç& çç éç ™è, ÿç €è †è, è8$‚è
‡è$ šè$ ©è% ºè Ðè èé8$Úè& Þè àè êè, âè8° ãè& äè8$åè$ ëè8€Š,õè& úè üè áé8¨Š\Šé& •é —é ˜é$ ™é8Û‹L§é& °é ²é Öé, ³é ´é Ôé+ µé ¶é Óé, ·é8$¸é& ¼é8¼,½é, Ãé Äé Ñé, Åé8exprargsÁDÆé& Îé8¯Ïé
Òé
Õé$ ×é$ âé*êé íé ¥ê, ÷é øé ê+ ùé úé Žê, ûé8$üé, ê ‚ê Œê, ƒê8±D„ê
ê
ê šê Ÿê, œê8° êüöì'üªêR“‚üýê0- based on whether or not they're "item-safe".Á®ëúü²ëVS This macro follows the same pattern as expr-safe above, but assumes all attributesÁü‰ìMJ are safe on items. It only filters out any `bitflags`-defined attributes.Á(|×ì4íì ží ©û ¤í çí, ®í ¯í Ìí+ °í ±í Ëí, ²í8ù,³í& ¸í8¼,¹í, ¿í Àí Éí, Áí8À$Âí& Æí8¯Çí
Êí
Íí ×í áí, Ùí8´ Úí& Ûí8÷$Üí*éí ìí ©ð, öí8,÷í'üí8æÔþí ˜î šî £ð8÷$¨î& ¬î ®î ³î, °î8´ ±î$ ´î8€Š,Âî& Çî Éî ˜ð8¨Š\ˆï& “ï •ï ­ï, –ï —ï «ï+ ˜ï ™ï ªï, šï8ù,›ï, ¡ï ¢ï ¨ï, £ï8À$¤ï
©ï
¬ï$ ®ï8Û‹Lýï& †ð ˆð ‰ð$ Šð$ ™ð% ªð Ëð ¥ò8÷$Õð& Ùð Ûð åð, Ýð8´ Þð& ßð8÷$àð$ æð8€Š,ðð& õð ÷ð žò8¨Š\…ñ& ñ ’ñ ìñ+ ¤ñ ¥ñ »ñ8ÞD¦ñ, ¯ñ °ñ ¹ñ, ±ñ8À$²ñ& ¶ñ8¯·ñ
ºñ, Íñ Îñ Ýñ, Ïñ8ÒŽTÐñ& Úñ8¯Ûñ
Þñ$ íñ8Û‹Lûñ& „ò †ò “ò, ‡ò ˆò ‘ò, ‰ò8÷$Šò& Žò8¯ò
’ò$ ”ò$ Ÿò*§ò ªò Êô, ´ò8,µò'ºò8æÔ¼ò Öò Øò Äô8÷$æò& êò ìò ñò, îò8´ ïò$ òò8€Š,€ó& …ó ‡ó ¹ô8¨Š\™ó& ¤ó ¦ó Üó, ¼ó ½ó Éó, ¾ó8ÒŽT¿ó
Êó$ Ýó8Û‹Lïó& øó úó ªô, ô ‘ô —ô, ’ô8÷$“ô
˜ô$ «ô$ ºô% Ëô éô îö8÷$óô& ÷ô ùô ƒõ, ûô8´ üô& ýô8÷$þô$ „õ8€Š,Žõ& “õ •õ çö8¨Š\£õ& ®õ °õ µö+ éõ êõ „ö, ëõ8¹
,ìõ& ñõ8¼,òõ, øõ ùõ ‚ö, úõ8À$ûõ& ÿõ8¯€ö
ƒö, –ö —ö ¦ö, ˜ö8ÒŽT™ö& £ö8¯¤ö
§ö$ ¶ö8Û‹LÄö& Íö Ïö Üö, Ðö Ñö Úö, Òö8÷$Óö& ×ö8¯Øö
Ûö$ Ýö$ èö*ðö óö ¿ù, ýö8,þö'ƒ÷8æÔ…÷ Ÿ÷ ¡÷ ¹ù8÷$¯÷& ³÷ µ÷ º÷, ·÷8´ ¸÷$ »÷8€Š,Í÷& Ò÷ Ô÷ ®ù8¨Š\æ÷& ñ÷ ó÷ ©ø, ‰ø Šø –ø, ‹ø8ÒŽTŒø
—ø$ ªø8Û‹L¼ø& Åø Çø Ÿù, Ýø Þø äø, ßø8÷$àø
åø+ ûø üø ù, ýø8¹
,þø, „ù …ù ‹ù, †ù8À$‡ù
Œù$  ù$ ¯ù% Àù Öù îú8÷$àù& äù æù ðù, èù8´ éù& êù8÷$ëù$ ñù8€Š,ûù& €ú ‚ú çú8¨Š\ú& ›ú ú žú$ Ÿú8Û‹L­ú& ¶ú ¸ú Üú, ¹ú ºú Úú+ »ú ¼ú Ùú, ½ú8÷$¾ú& Âú8¼,Ãú, Éú Êú ×ú, Ëú8itemargsÁDÌú& Ôú8¯Õú
Øú
Ûú$ Ýú$ èú*ðú óú §û, ýú þú •û+ ÿú €û ”û, û8÷$‚û, ‡û ˆû ’û, ‰û8”¸DŠû
“û
–û,  û8´ ¡ûü÷û!ü¬û+( Determine the name to assign to a flag.Á(|Øû4îû ™ü Α ®ü þü, ¸ü ¹ü Öü+ ºü »ü Õü, ¼ü8ù,½ü& Âü8¼,Ãü, Éü Êü Óü, Ëü8À$Ìü& Ðü8¯Ñü
Ôü
×ü áü øü, ãü8Æäü& çü8Æèü8,ìü8 òü ôü8 öü*€ý ƒý Šý% ‹ý ‘ý ÷ý, ›ý œý ¹ý+ ý žý ¸ý, Ÿý8ù, ý& ¥ý8¼,¦ý, ¬ý ­ý ¶ý, ®ý8À$¯ý& ³ý8¯´ý
·ý
ºý Äý ñý, Æý8ÆÇý& Êý8ÆËý8,Ïý, Õý8bindingÁ<Öý& Ýý8¼,Þý äý, æý8Ð $çý& ëý8$ìý*ùý üý ù€, †þ8,‡þ'Œþ8¤Žþ ¢þ ¤þ ó€8÷$²þ& ¶þ ¸þ ûþ, ºþ8Æ»þ8,¿þ, Åþ8¦¿<Æþ Îþ, Ðþ8,Ñþ'Öþ8œLØþ'áþ8í$ãþ'çþ8ÔLéþ òþ óþ ùþ, ôþ8Ð $õþ$ üþ8€Š,Šÿ& ÿ ‘ÿ è€8¨Š\Ðÿ& Ûÿ Ýÿ õÿ, Þÿ ßÿ óÿ+ àÿ áÿ òÿ, âÿ8ù,ãÿ, éÿ êÿ ðÿ, ëÿ8À$ìÿ
ñÿ
ôÿ$ öÿ8Û‹LÍ€& Ö€ Ø€ Ù€$ Ú€$ é€% ú€ « ¸ƒ8÷& ¹ » è, ½8ƾ& Á8ÆÂ8, Ì8¦¿& Ô8¼ Û, Ý8Ð & â8$ é8€Š& ø ú ±ƒ8¨Š\ˆ‚& “‚ •‚ ÿ‚+ §‚ ¨‚ ΂8ÞD©‚ ±‚ Í‚8 flag_nameÁL²‚ ¼‚, ¾‚8üÆL¿‚& È‚8$É‚, à‚ á‚ ð‚, â‚8ÒŽTã‚& í‚8¯î‚
ñ‚$ €ƒ8Û‹LŽƒ& —ƒ ™ƒ ¦ƒ, šƒ ›ƒ ¤ƒ, œƒ8÷$ƒ& ¡ƒ8¯¢ƒ
¥ƒ$ §ƒ$ ²ƒ*ºƒ ½ƒ õ…, ǃ8,ȃ'̓8¤Ïƒ ãƒ åƒ ï…8÷$óƒ& ÷ƒ ùƒ œ„, ûƒ8Æüƒ8,€„, †„8¦¿<‡„ , ‘„8üÆL’„$ 8€Š,«„& °„ ²„ ä…8¨Š\Ä„& Ï„ Ñ„ ‡…, ç„ è„ ô„, é„8ÒŽTê„
õ„$ ˆ…8Û‹Lš…& £… ¥… Õ…, »… ¼… Â…, ½…8÷$¾…
Ã…$ Ö…$ å…% ö… ”† Œˆ8÷$ž†& ¢† ¤† ц, ¦†8Ƨ†& ª†8Æ«†8,¯†, µ†8¦¿<¶†& ½†8¼,¾† Ć, Ɔ8Ð $dž& ˆ8$̆$ Ò†8€Š,܆& ᆠㆠ…ˆ8¨Š\ñ†& ü† þ† Ó‡+  ‘‡ ¢‡8â’‡, –‡ —‡  ‡, ˜‡8À$™‡& 8¯ž‡
¡‡, ´‡ µ‡ ć, ¶‡8ÒŽT·‡& Á‡8¯‡
Ň$ Ô‡8Û‹Lâ‡& ë‡ í‡ ú‡, î‡ ï‡ ø‡, ð‡8÷$ñ‡& õ‡8¯ö‡
ù‡$ û‡$ †ˆ*Žˆ ‘ˆ éŠ, ›ˆ8,œˆ'¡ˆ8¤£ˆ ·ˆ ¹ˆ ãŠ8÷$Lj& ˈ ͈ ëˆ, ψ8ÆЈ8,Ôˆ, Úˆ8¦¿<Ûˆ ãˆ, åˆ8Ð $æˆ$ ìˆ8€Š,úˆ& ÿˆ  ØŠ8¨Š\“‰& ž‰  ‰ Ö‰, ¶‰ ·‰ É, ¸‰8ÒŽT¹‰
ĉ$ ׉8Û‹Lé‰& ò‰ ô‰ ÉŠ, ŠŠ ‹Š ‘Š, ŒŠ8÷$Š
’Š+ ¨Š ©Š ·Š8⪊, ®Š ¯Š µŠ
,…Œ& ŠŒ8¼,‹Œ, ‘Œ ’Œ ›Œ, “Œ8À$”Œ& ˜Œ8¯™Œ
œŒ, ¯Œ °Œ ¿Œ, ±Œ8ÒŽT²Œ& ¼Œ8¯½Œ
ÀŒ$ ÏŒ8Û‹LÝŒ& æŒ èŒ õŒ, éŒ êŒ óŒ, ëŒ8÷$ìŒ& ðŒ8¯ñŒ
ôŒ$ öŒ$ * Œ , 8,—'œ8¤ž ² ´ 8÷& Æ È æ, Ê8ÆË8, Õ8¦¿ Þ, à8Ð $ ç8€Š& ú ü ˆ8¨Š\ŽŽ& ™Ž ›Ž ÑŽ, ±Ž ²Ž ¾Ž, ³Ž8ÒŽT´Ž
¿Ž$ ÒŽ8Û‹LäŽ& íŽ ïŽ ùŽ, ðŽ ñŽ ÷Ž, òŽ8÷$óŽ
øŽ$ úŽ$ % š ° ë8÷& ¾ À í, Â8ÆÃ& Æ8ÆÇ8, Ñ8¦¿& Ù8¼ à, â8Ð & ç8$ î8€Š& ý ÿ ä8¨Š\& ˜ š $ œ8Û‹& ³ µ Ù,  · ×+ ¸ ¹ Ö, º8÷& ¿8¼, Æ Ç Ô, È8”¸& Ñ8¯Ò
Õ
Ø$ Ú$ å*í ð Ì‘, ú û ’‘+ ü ý ‘‘, þ8÷$ÿ, „‘ …‘ , †‘8”¸D‡‘

“‘, 8Æž‘8,¢‘, ¨‘8¦¿<©‘& °‘ ²‘:7<³‘8É»‘ ¿‘, Á‘8Ð $‘% Æ‘TÞ‘4â‘üè&ü¹,) Declare the user-facing bitflags struct.Áæúüê^[ This type is guaranteed to be a newtype with a `bitflags`-facing type as its single field.Á(|É  ì  ä , Ÿ   ¯+ ¡ ¢ ®, £8–ð& ©8û
°, º8Æ»& ¾8Æ¿8, Ê8ùš& Ù8¼*æ é é
, ó ô þ+ õ ö ý, ÷8–ð
ÿ, 8ÆŠ8, 8ùšt– ¤ â
 ¥, ¦8ùš8, ¹8'¿8œ'Ê8Š ×'Ø8¥% ã% êüé+üïB? Implement functions on the public (user-facing) bitflags type.Á²úü¶^§–ü•4(|Ê    ú, ¥ ¦ µ+ § ¨ ´, ©8–ð& ¯8û
, À8ùš& Ï8¼& Õ, ×8¥ Ø& Ù8´Ú$ Ü, Þ8×ú„ß& ï8¼*ü ÿ ˆ, 8'8í|   ¢ 8‰˜& 8$¸$ ¼8´$ Â8Ð $ È8¹
$ Ï8»% Ö, ä å ï+ æ ç î, è8–ð
ð, þ8ùštÿ& , 8¥   øP8 ¤ 8á  ¬  ­  ¯  ö 8 É  ä , Ê 8×ú„Ë 'Û 8á  â  ã 8 
8£Œ



 ×
8
 ¬
 Å
, ­
8×ú„®
'¾
8£À
 Ã
 Ä
8 ê
8´
 ñ
 ÷
 ò
8
 ù
 ­ 8$  7ˆ  8´$–  š  8 À 8Õ
 Ì  Ñ 8´  Ó  ¼8 , ï 8×ú„ð ' 8Õ
L‚   8´   ª6, ¬ 8,­ '² 8œL´ '½ 8í$¿ 'à 8³
'Ë 8¬ 'Ó 8Û  Ù  Þ 8´ *à , ã 8 'é 8œ 'ô 8í 'ú 8³
'
8¬4„
'Š
8Û


8$

 š
8´$
$ œ
,
8
'¼
8œ
'Ç
8í
'Í
8³
'Õ
8¬4×
'Ý
8©
*ä
, ç
8
'í
8œ
'ø
8í
'þ
8³
4€'8¬4ˆ'Ž8©$$ 8 Ï8å
”Ò ä é8´ ë Ã8$  ±, 8×ú„‡'8å
”™ « °8´8 Ö8þ
„Ù é î8´ ð Æ8$† Š ´, 8×ú„Œ'œ8þ
„ž ® ³8´8 Ù8 å ê8Ð  ì Õ8,‚, ˆ8×ú„‰'8L ¤ ©8Ð  « Ã6, Å8'Ë8œ'Ö8í'Ü8³
'ä8¬'ì8Û ò ÷8´*ù, ü8'8œL„'8í$'8³
4•'8¬4'£8Û © ´8 ® ³8´$ µ, Ï8'Õ8œL×'à8í'æ8³
'î8¬'ö8©*ý, 8,'8œLˆ'8í$“'8³
4™'Ÿ8¬'§8©$ ­8 è8í ó ù ô8 û ³8$‘ 7ˆ  8í   ¡8 Æ8ü Ï Õ Ð8 × 8 ñ7ˆ ò ó8ü ú û8  8 ­ º ®8$ ³8¹
 ¼ ý8 Ö7ˆ × Ø8 ã ë8¹
 é7ˆ ê8 8šD“  ¨ œ8$$ ¡8¹
 ª é8 Ä7ˆ Å Æ8š Ï ×8¹
 Õ7ˆ Ö8 ü8¸4ÿ   88$$ 8¹
,‘ ˜ Õ8 ²7ˆ ³ ´8¸ » Ã8¹
 Á7ˆ Â8 è8Å ñ  ò8ó8$ û8¹
  Á8 ž7ˆ Ÿ  8Å § ¯8¹
 ­7ˆ ®8 Ô8Ò Ý î Þ8ß8$ ç8¹
 ð ­8$† Š7ˆ  Œ8Ò4  8¹
,” 7ˆ š8 À8ßÃ Æ Þ Ç8È8$ Ð8¹
$ ×8» à ¡8 ú7ˆ û ü8ßý  8¹
, 7ˆ $ ˆ8»8 ´8õ Ã Ï8$ È8¹
 Ñ š8 ë ˆ8 ð7ˆ ñ ò8õ ÿ 8¹
,€ 7ˆ 8 ­8C µ Á8$ º8¹
 Ã 8 Ý ó8 â7ˆ ã ä8C ê ò8¹
 ð7ˆ ñ8 ˜8ŽT› ¥ ±8$ ª8¹
 ³ ú8 Í è8 Ò7ˆ Ó Ô8Ž ß ç8¹
 å7ˆ æ8 8Ÿ¤ ¤ °8$ ©8¹
 ² ƒ8 Ì ñ8 Ñ7ˆ Ò Ó8Ÿ¤Ô è ð8¹
 î7ˆ ï8 8ºT™ £ ¨8 ª ê8 Ä Ø8 É7ˆ Ê Ë8º Ö ×% üˆ!#üŽB“éÑúüÕ^§–ü´ 4(|é 4ÿ Œ¹ ¬! úG ²! ’#, ¼! ½! Ì!+ ¾! ¿! Ë!, À!8–ð,Á!& Æ!8û$Ç!
Í!, ×!8´DØ!& à!8¼,á!& æ!, è!8¥ é!& ê!8´ë!$ í!, ï!8ùštð!& þ!8¼,ÿ! …" Œ#, “" ”" #, ¦" §" Ä"+ ¨" ©" Ã", ª"8ù,«"& °"8¼,±", ·" ¸" Á", ¹"8À$º"& ¾"8¯¿"
Â"
Å"8,×", Ý"8«$Þ"& â"8¯ã" æ", è"8»,é"& î"8$ï"% ó"
#*”# —# ÷G, ¡#8,¢#'§#8í|©# ¸# º# ñG8‰˜4È#& Î#8$Ð#$ Ô#8´$Ö#$ Ú#8Ð $Ü#$ à#8¹
,â#$ ç#8»,é#% î#, ü# ý# ‡$+ þ# ÿ# †$, €$8–ð,$
ˆ$, $8´D—$& Ÿ$, ¡$8¥ ¢$ ¤$ çGP8 ¶$8á ,¹$ ¾$ ¿$ Á$ ‰%8$×$ Û$ ÷$  Ü$, Ý$8¥ Þ$8à$, ã$8,ä$'é$8Ö $ë$ ï$'ð$8Ó,ò$8 œ%8£Ÿ% ¢% £% ¥% «* 8»%8¿%8õ×LÃ% Í% Ï%, Ð%8¥ Ñ%8Ó%, Ö%8,×%'Ü%8Ö $Þ% â%'ã%8Ó,å%% ê%8€&8„&8´ ˆ& Š&7ˆ Œ&% &, ¤& ¥& Ô), ¿&8,À&'Å&8ÅÔÇ& á& â& ½), €' ' •'+ ' ƒ' ”', „'8ù,…', ' Œ' ', '8À$Ž'
“'
' ´' £) µ' ¢) 8×'8«8$Û' à' â', ã'8ùštä'8ó', ö'8,÷''ü'8¾ ,þ' ƒ('„(8Ê ,†( ( (8´ Œ( Ž(8»,( ”( •( (8´$—( ( œ(% (8õ×LÀ( Ê(8õ×LÌ( Ö(8«8$Ø(% Ü(8´ þ(€)7 ƒ)% „)% ¾)
Õ)8ì)8 ð) ò)8´ ô)% õ)8$* * ™*8õ×L*8 ¾*8´$Á* Å* Ë* Æ*8$Ç* Í* ú*8$ã* ç*7ˆ è*8 +8Õ
L+ ™+ ž+8´$š+  + ï-8¶+8õ×Lº+ Ä+8$Æ+'Ê+8å
”Ì+ Þ+ ã+8´$ß+ ä+7ˆ å+% æ+8ý+8õ×L€,Š,8´$, , ú,
, ¬,8,­,'²,8œL´,'½,8í$¿,'Ã,8³
4Å,'Ë,8¬4Í,'Ó,8Û$Õ, Ù, ä,8$Ú, Þ, ã,8´$ß,8$ü, - Ý- , -8,œ-'¡-8œL£-'¬-8í$®-'²-8³
4´-'º-8¬4¼-'Â-8©$Ä-8 .8å
”…. —. œ.8´$˜. ž. ß.8$´. ¸. Í.8´$¹. ¾.8$À.'Ä.8£Æ. É. Ê. Ë.7ˆ Ì.8 ò.8þ
„õ. …/ Š/8´$†/ Œ/ ½/8$¢/ ¦/ «/8´$§/8 Ð/8LÓ/ Ü/ á/8Ð $Ý/ ã/ Û98ù/8__bitflags_flag_namesÁ¬ý/ “0 Û28#­08,±0'¶0
¸0% ¹0, Ô0 Õ0 Ä2, ó08,ô0'ù08¤û0 1 1 ©2, ²1 ³1 Ç1+ ´1 µ1 Æ1, ¶18ù,·1, ½1 ¾1 Ä1, ¿18À$À1
Å1
È1 ê1 ‹28ì1 ï1 õ18,ð18,÷1, ý18«$þ1 ƒ2, …28«$†2% ª2
Å2, ò2 ó2 ã8, 38,Ž3'“38¯|•3 ¤3 ¥3 Ì8 ¦3 Ë8
8Ð $Ä3& È3, Ê38«$Ë3$ Ï38¢ü,í3& ò3 ô3 ‡8 õ3 †8, —48,˜4'48ÅÔŸ4 ¹4 º4 ç7, à4 á4 õ4+ â4 ã4 ô4, ä48ù,å4, ë4 ì4 ò4, í48À$î4
ó4
ö4 œ5 Å78Æ58Ð $É5Î58ò¥¬Ñ5'æ5, è58«$é5 î5 Ÿ784œ6, £68,¤6'©68œL«6'´68í$¶6'º68³
4¼6'Â68¬4Ä6'Ê68Û$Ì6 Ð6 ô68$Ñ6 Õ6 ó6, Ö68ùšt×6'å6, ç68«$è6 ì68´$í6 ñ6 ò6% õ6% è7$ ˆ88šý<¦8& ­8 ¯8 °8$ ±8% Í8
ä88û88 ÿ8 98Ð $ƒ9% ‡9, 98,ž9'£98œL¥9'®98í$°9'´98³
4¶9'¼98¬4¾9'Ä98©$Æ98 î98íDñ9 ù9 ÿ9 ú98$û9 : Í:8$—: :7ˆ œ:ž: ¡:, ¢:8¥ £:8¥:, ¨:8,©:'®:8Ö $°: ´:'µ:8Ó,·:8 à:8ü4ã: é: ï: ê:8$ë: ñ: ×<8$¦<'ª<8£¬< ¯< °< ±<7ˆ ²< ´<8$¶< º<7ˆ »<½<8$À< Ä<7ˆ Å<8 ê<8Tí< ÷< „= ø<8$ù<$ ý<8¹
,ÿ< †= Ü=8$œ=  =7ˆ ¡= £=8¹
,¥= ª=7ˆ «=­= °=, ±=8¥ ²=8´=, ·=8,¸='½=8Ö $¿= Ã='Ä=8Ó,Æ=8 ï=8šDò= ú= ‡> û=8$ü=$ €>8¹
,> ‰> Ë> 8$Ÿ> £>7ˆ ¤> ¦>8¹
,¨> ­>7ˆ ®>°>8¹
,³> ¸>7ˆ ¹>8 Þ>8¸4á> ç> ø> è>8é>8$í>$ ñ>8¹
,ó> ú> Ã?
?8$? ?8$˜? œ? £?8$? ¡?7ˆ ¢? ¤?8C,¥? ª? °?8¹
,«?% ±?8 Ö?8Å4Ù? ß? ð? à?8á?8$å?$ é?8¹
,ë? ò? À@
ˆ@8$‰@ Ž@8$@ ”@ @8$•@ ™@7ˆ š@ œ@8ŽT@ §@ ­@8¹
,¨@% ®@8 Ó@8Ò4Ö@ Ü@ í@ Ý@8Þ@8$â@$ æ@8¹
,è@ ï@ ÇA
…A8$†A A8$A A ˜A8$A A7ˆ —A ™A8Ÿ¤šA ®A ´A8¹
,¯A% µA8 ÚA8ßÝA àA øA áA8âA8$æA$ êA8¹
,ìA$ ñA8»,óA úA ¶C8B8»,“B ™B ÛB8$³B ·B8¸4¸B ¾B ÄB8¹
,¿B% ÅB8$ÝB âB ¤C8$üB €C8Å4C ‡C C8¹
,ˆC% ŽC8 ÉC8õdÌC ØC äC8$ÙC$ ÝC8¹
,ßC æC £D8$üC €D D8$D …D7ˆ †D ˆD8¹
,ŠD D7ˆ D8 ¶D8C,¹D ¾D ÊD8$¿D$ ÃD8¹
,ÅD ÌD ‰E8$âD æD ÷D8$çD ëD7ˆ ìD îD8¹
,ðD õD7ˆ öD8 œE8ŽTŸE ©E µE8$ªE$ ®E8¹
,°E ·E õE8$ÍE ÑE ãE8$ÒE ÖE7ˆ ×E ÙE ÛE8¹
,ÜE áE7ˆ âE8 ˆF8Ÿ¤‹F ŸF «F8$ F$ ¤F8¹
,¦F ­F êF8$ÃF ÇF ØF8$ÈF ÌF7ˆ ÍF ÏF8¹
,ÑF ÖF7ˆ ×F8 ýF8ºT€G ŠG G8$G G ÙG8$§G'«G8å
”­G ¿G ÇG ÀG8$ÁG ÅG7ˆ ÆG% øGüßH(üýGB? Implement iterators on the public (user-facing) bitflags type.Á(|ÀH4ÖHœ¹ ˆI ‡W ŽI åI, ˜I ™I ¨I+ šI I §I, œI8–ð,I& ¢I8û$£I
©I, ³I8´D´I& ¼I8¼,½I& ÂI, ÄI8¥ ÅI& ÆI8´ÇI$ ÉI, ËI8ùštÌI& ÚI8¼,ÛI*çI êI „W, ôI õI ÿI+ öI ÷I þI, øI8–ð,ùI
€J8$ŠJ, J8´DJ ™J ÇT.<­˜ü§J*<úÞJ<í˜üîJV<Í™üÑK4+ L “L šL8Ý4”L8¨L8,¬L8 ²L8ù$µL ¹L ¿L ºL8$»L(ÁL, ÄL8,ÅL'ÊL8ù$ÌL'ÐL8ç$ÒL ÖL, ×L8ùštØL æL èL ˆO , úL8,ûL'€M8ù$M'†M8ç$ˆM'ŒM8­œŽM ¡M úN ·M, ¸M8ùšt¹M8ÈM, ËM8,ÌM'ÑM8¾ ,ÓM ØM'ÙM8Ê ,ÛM$ àM, öM8ùšt÷M'…N8þ
„‡N —N £N8$˜N œN8´$N ¡N ¢N$ ¤N, ºN8ùšt»N'ÉN8þ
„ËN ÛN çN8$ÜN àN8´$áN åN æN$ èN<ãšü—O0<úÔO<^ This method is like [`iter`](#method.iter), except only yields bits in contained named flags.ÁüäOa<œüÒPX+ ·Q ¸Q ¿Q8Ý4¹Q8ÍQ8,ÑQ8 ×Q8¬TÚQ äQ êQ åQ8$æQ(ìQ, ïQ8,ðQ'õQ8ù$÷Q'ûQ8àLýQ †R, ‡R8ùštˆR R ˜R ½T , ªR8,«R'°R8ù$²R'¶R8àL¸R'ÁR8­œÃR ÖR ¯T ìR, íR8ùštîR8ýR, €S8,S'†S8¾ ,ˆS S'ŽS8Ê ,S$ •S, «S8ùšt¬S'ºS8þ
„¼S ÌS ØS8$ÍS ÑS8´$ÒS ÖS ×S$ ÙS, ïS8ùštðS'þS8þ
„€T T œT8$T •T8´$T šT T$ T, ÒT ÓT âT+ ÔT ÕT áT, ÖT8–ð,×T& ÜT8û$ÝT
ãT8$íT, òT8,óT'øT8œLúT'ƒU8í$…U'‰U8ù$U'U8˜dU8
žU, ¢U8´D£U ¬U þV8!$ºU8$¿U ÄU, ÆU8ùštÇU% ÕU8!$ãU8IntoIterÁDèU ñU, óU8,ôU'ùU8ù$ûU'ÿU8ç$V …V, †V8ùšt‡V •V% V8 ¥V8êL¨V ±V ¶V8$²V(¸V8$»V'¿V8ÏÔDÁV ÊV ôV8$ÜV àV8ù$áV åV æV% …WüéW'üŠW?< Implement traits on the public (user-facing) bitflags type.Á(|ÊW4àW¬¹ ‘X “‡ —X ÖX, ¡X ¢X ±X+ £X ¤X °X, ¥X8–ð,¦X& «X8û$¬X
²X, ¼X8ùšt½X& ËX8¼,ÌX*ØX ÛX , æX çX ñX+ èX éX ðX, êX8–ð,ëX
òX8$üX, Y8,Y'‡Y8œL‰Y'Y8í$”Y'˜Y8ךY'Y8BinaryÁ4ŸY8
¦Y, ªY8ùšt«Y ºY ß[8 ÈY8×ËY ÎY ´Z àY8$áY$ åY8± ÷Y& øY úY8ûY, ÿY8,€Z'…Z8œL‡Z'Z8í$Z'Z8טZ'Z8ˆLZ$ ¦Z(¶Z, ¹Z8,ºZ'¿Z8œLÁZ'ÊZ8í$ÌZ'ÐZ8×ÒZ'ÕZ8Í4×Z ÞZ Õ[8ðZ8ù,ôZ úZ8$üZ €[7ˆ [% [, ”[8,•['š[8œLœ['¥[8í$§['«[8×­['°[8ˆÚ4²['¸[8׺[ ½[ Ç[ ¾[8ù,¿[$ Ä[8± Æ[, ê[ ë[ õ[+ ì[ í[ ô[, î[8–ð,ï[
ö[8$€\, …\8,†\'\8œL\'\8í$˜\'œ\8מ\'¡\8OctalÁ,£\8
©\, ­\8ùšt®\ ½\ á^8 Ë\8×Î\ Ñ\ ·] ã\8$ä\$ è\8± ú\& û\ ý\8þ\, ]8,ƒ]'ˆ]8œLŠ]'“]8í$•]'™]8×]'ž]8ˆL ]$ ©](¹], ¼]8,½]'Â]8œLÄ]'Í]8í$Ï]'Ó]8×Õ]'Ø]8Í4Ú] á] ×^
°e'³e8Óñ,µe8
»e, ¿e8ùštÀe Ïe Åg8!$Ýe8°4âe ée8$ëe% ïe<ˆ§üþe;+ Æf Çf Îf8Ý4Èf8 Üf8±,ßf äf g8$åf$ éf8¹
,ëf& ðf, òf8ùštóf(ƒg8$†g g »g8$g ¡g8C,¢g §g ­g8¹
,¨g, Ðg Ñg Ûg+ Òg Óg Úg, Ôg8–ð,Õg
Üg8$æg, ëg8,ìg'ñg8œLóg'üg8í$þg'h8­
„h'‡h8 BitOrAssignÁ\‰h8
•h, ™h8ùštšh ©h ùi<ˆ§ü·h;+ ÿh €i ‡i8Ý4i8 •i8²d˜i ¤i »i ¥i8¦i8$ªi$ ®i8¹
,°i& µi8$·i ½i ïi8$Ïi Ói8¸4Ôi Úi ài8¹
,Ûi% ái, „j …j j+ †j ‡j Žj, ˆj8–ð,‰j
j8$šj, Ÿj8, j'¥j8œL§j'°j8í$²j'¶j8­
¸j'»j8ëñ4½j8
Äj, Èj8ùštÉj Øj Ýl8!$æj8°4ëj òj8$ôj% øj<˜«ü‡kE+ Ùk Úk ák8Ý4Ûk8 ïk8µ4òk øk Šl8$ùk$ ýk8¹
,ÿk& „l8$†l(Œl8$l ”l Ól8$¦l ªl8Ÿ¤«l ¿l Ål8¹
,Àl, èl él ól+ êl ël òl, ìl8–ð,íl
ôl8$þl, ƒm8,„m'‰m8œLm'”m8í$m'šm8­
œm'Ÿm8 BitXorAssignÁd¡m8
®m, ²m8ùšt³m Âm o<˜«üÐmE+ ¢n £n ªn8Ý4¤n8 ¸n8l»n Èn ßn Én8Ên8$În$ Òn8¹
,Ôn& Ùn8$Ûn án “o8$ón ÷n8Ò4øn þn „o8¹
,ÿn% …o, ¨o ©o ³o+ ªo «o ²o, ¬o8–ð,­o
´o8$¾o, Ão8,Äo'Éo8œLËo'Ôo8í$Öo'Úo8­
Üo'ßo8ºñ4áo8
èo, ìo8ùštío üo ðq8!$Šp8°4p p8$˜p% œp<´¯ü«p<+ ôp õp üp8Ý4öp8 Šq8¯4q “q ¥q8$”q$ ˜q8¹
,šq& Ÿq8$¡q(§q8$ªq ¯q æq8$Áq Åq8õdÆq Òq Øq8¹
,Óq, ûq üq †r+ ýq þq …r, ÿq8–ð,€r
‡r8$r, r8,—r'œr8œLžr'§r8í$©r'­r8­
¯r'²r8 BitAndAssignÁd´r8
Ár, År8ùštÆr Õr Ôt<´¯üãr<+ ¬s ­s ´s8Ý4®s8 Âs8°lÅs Òs és Ós8Ôs8$Øs$ Üs8¹
,Þs& ãs8$ås ës Êt
ýs8$þs ƒt8$…t'‰t8þ
„‹t t §t8$œt  t8´$¡t ¥t ¦t ¨t8õd©t µt »t8¹
,¶t% ¼t, ßt àt êt+ át ât ét, ãt8–ð,ät
ët8$õt, út8,ût'€u8œLu'u8í$u'u8­
“u'u8SubÁ˜u8
œu,  u8ùšt¡u °u ìx8!$¾u8°4Ãu Êu8$Ìu% Ðu<°¨üßuE<ú±v<‹©üÁvW<Ô±ü¥wC+ õw öw ýw8Ý4÷w8 x8ÚŽx x £x8$x$ x8¹
,˜x& x8$Ÿx(¥x8$¨x ­x âx8$¿x Ãx8ŽTÄx Îx Ôx8¹
,Ïx, ÷x øx y+ ùx úx y, ûx8–ð,üx
ƒy8$y, y8,“y'˜y8œLšy'£y8í$¥y'©y8­
«y'®y8 SubAssignÁL°y8
ºy, ¾y8ùšt¿y Îy ê|
<°¨üÜyE<ú®z<‹©ü¾zW<Ô±ü¢{C+ ò{ ó{ ú{8Ý4ô{8 ˆ|8ÛT| •| ¬| |8—|8$|$ Ÿ|8¹
,¡|& ¦|8$¨| ®| à|8$À| Ä|8Å4Å| Ë| Ñ|8¹
,Ì|% Ò|, õ| ö| €}+ ÷| ø| ÿ|, ù|8–ð,ú|
}8$}, }8,}'}8œL˜}'¡}8í$£}'§}8­
©}'¬}8„ò®}8
²}, ¶}8ùšt·} Æ} ³8!$Ô}8°4Ù} à}8$â}% æ}<̳üõ}L+ Î~ Ï~ Ö~8Ý4Ð~8 ä~8
ç~ ê~ ï~8$ë~(ñ~8$ô~ ù~ ©8$ 8ºT š , ¾ ¿ É+ À Á È, Â8–ð
Ê8, Ù8'ß8œ'ê8í'ð8ù'ö8ExtendÁ þ, ÿ8ùšt€€ Ž€8
, ”€8ùšt•€ ¤€ ý‚<6 The bitwise or (`|`) of the bits in each flags value.Áü²€98 ø€8extendÁ4û€ 8¥ & ƒ, 8,†'8œL'8í$˜'œ8ù'¢8˜ °8 8¼ ¾ „‚ Ð8Ñ8$ Ù8û& ó8¥ õ$ ö †‚ ó‚8
˜‚8÷$œ‚8¡‚8ûD¤‚ ­‚ å‚8$ ǂ8¸4È‚ ΂ Ó‚8÷$Ï‚, ˆƒ ‰ƒ “ƒ+ Šƒ ‹ƒ ’ƒ, Œƒ8–ð,ƒ
”ƒ8$žƒ, £ƒ8,¤ƒ'©ƒ8œL«ƒ'´ƒ8í$¶ƒ'ºƒ8ù$¼ƒ'Àƒ8dƒ ΃, σ8ùštЃ Þƒ8
àƒ, äƒ8ùštåƒ ôƒ Ї<Ÿ’ü‚„98 È„8ùLË„ Ô„8¥ Õ„& Ö„, Ø„8,Ù„'Þ„8œLà„'é„8í$ë„'ï„8ù$ñ„'õ„8˜d÷„ ƒ…8$„… ‰…8$‹… ‘… ¼…8ûD£…& «…8¥ ­…$ ®…(¾…8$Á… Æ… €‡8#Ø…, Ü…8,Ý…'â…8œLä…'í…8í$ï…'ó…8ù$õ…'ù…8º‘4û…% 8”†8˜†8 4œ† £†8$¥†'©†8á ,«† °† ±†% ²†8 4Ć ʆ8ì’4ˆ ц Ú†8ûDÒ†% Û†8 4í†% ‘‡üø‡*ü–‡B? Implement constants on the public (user-facing) bitflags type.Á(|Ù‡4¹ £ˆ «£ ©ˆ ø‰
, ³ˆ ´ˆ È+ µˆ ¶ˆ ˆ, ·ˆ8–ð,¸ˆ& ½ˆ8û$¾ˆ
Ĉ, Έ8ùštψ& ݈8¼,Þˆ& ãˆ, åˆ8¥ æˆ& çˆ8´èˆ ëˆ ò‰, ùˆ úˆ ç‰, Œ‰  ª‰+ މ  ©‰, 8ù,‘‰& –‰8¼,—‰,  ž‰ §‰, Ÿ‰8À$ ‰& ¤‰8¯¥‰
¨‰
«‰8,½‰, É8«$ĉ& ȉ8¯ɉ ̉, Ή8»,ω& Ô‰8$Õ‰% Ù‰
è‰*ú‰ ý‰ ¨£, ‡Š ˆŠ ’Š+ ‰Š ŠŠ ‘Š, ‹Š8–ð,ŒŠ
“Š8$Š, ¢Š8ùšt£Š ²Š ¯Ž, ÀŠ ÁŠ ¤Ž, ÓŠ8,ÔŠ'ÙŠ8¯|ÛŠ êŠ ëŠ •Ž ìŠ ”Ž
8Ð $‚‹& †‹, ˆ‹8«$‰‹$ 8¢ü,£‹& ¨‹ ª‹ à, Ä‹8,Å‹'Ê‹8æÔÌ‹ æ‹ ç‹ É, …Œ †Œ šŒ+ ‡Œ ˆŒ ™Œ, ‰Œ8ù,ŠŒ, Œ ‘Œ —Œ, ’Œ8À$“Œ
˜Œ
›Œ ¹Œ ¯ 8ÛŒ8,ߌ, åŒ8«$æŒ& êŒ8$ìŒ ñŒ8$óŒ'÷Œ8þ
„ùŒ  , Š8»,‹% % Ê$ á8šý& þ €Ž Ž$ ‚Ž% –Ž
¥Ž, ºŽ »Ž ÅŽ+ ¼Ž ½Ž ÄŽ, ¾Ž8–ð,¿Ž
ÆŽ8$ÐŽ, ÕŽ8,ÖŽ'ÛŽ8¾ ,ÝŽ8
ãŽ, çŽ8ùštèŽ ÷Ž ¢£$8,…8Ê ,&  :7<“  ¹, œ8,'¢8« ¨, ©8ùš ¸ » ½ “š8Ï8ò¥¬Ó é ø‘8#ÿ8'ˆ
Š% , ¢ £ å‘, ½8'Ã8¤Å Ù Ú Α, ø ù + ú û Œ‘, ü8ù, ƒ‘ „‘ Š‘, …‘8À$†‘
‹‘
Ž‘ ¬‘ Í‘8®‘ ±‘ ·‘8,²‘8,¹‘, ¿‘8«$À‘ Å‘, Ç‘8«$È‘% Ï‘
æ‘ ‹’ Œ’ …š, ¢’ £’ ò™, ½’8,¾’'Ã’8¯|Å’ Ô’ Õ’ Û™ Ö’ Ú™
8Ð $ô’& ø’, ú’8«$û’$ ÿ’8¢ü,& ¢“ ¤“ ¡–, Æ
8ò¥¬‡•'œ•, ž•8«$Ÿ•$ £•, ¥•8ùšt¦•'´•, ¶•8«$·•$ ¢–8šý<À–& Ç– É– ¿™, ë–8,ì–'ñ–8ÅÔó–  Ž— ¡™, ´— µ— É—+ ¶— ·— È—, ¸—8ù,¹—, ¿— À— Æ—, Á—8À$—
Ç—
Ê— ð— ÿ˜, š˜8,›˜' ˜8«$¢˜'¦˜8æ ¨˜ «˜ Ù˜7ú¬˜$ ®˜, °˜8ùšt±˜'¿˜8þ
„Á˜ ј ؘ, Ò˜8»,Ó˜$ À™$ Ü™
ó™% ”š8!$£š8Ö $¨š ­š, ¯š8¥ °š% ±š8 Àš8´$Ú Çš Íš Èš8$Éš(Ïš, Òš8¥ Óš Õš , çš8ùštèš'öš8´$øš üš 8$ýš8 ž›8þ
„¡› ±› º›8´$²›& ¶›, ¸›8¥ ¹›(¼›, ¿›8ùštÀ› Ï› •œ, á›8ùštâ›'ð›8þ
„ò› ‚œ ‡œ8´$ƒœ8 ¤œ8ô L§œ °œ ±œ(³œ, ¶œ8ùšt·œ Æœ ˜£
8,Øœ8 ALL_NAMEDÁLÞœ& çœ, éœ8¥ êœ ìœ îœ Ë¢88ˆ8õ×  ˜, 8¥ š8œ, Ÿ8, '¥8Ö  «'¬8Ó% ³8É8Í8´ Ñ Ó7ˆ Õ% Ö, í î ú¡, ˆž8,‰ž'Žž8ÅÔž ªž «ž ã¡, Éž Êž Þž+ Ëž Ìž Ýž, Íž8ù,Ξ, Ôž Õž Ûž, Öž8À$מ
Üž
ßž ýž É¡ þž È¡8 Ÿ8«8$¤Ÿ ©Ÿ «Ÿ ¬Ÿ, ­Ÿ8ùšt®Ÿ8½Ÿ, ÀŸ8,ÁŸ'ÆŸ8¾ ,ÈŸ ÍŸ'Ο8Ê ,П ÕŸ ן8´ ÖŸ% ØŸ8ûŸ8«8$þŸ ‚ 8ž Dƒ  ‹  Œ  Ž  ¡ 8õ×L´  ¾ 8õ×LÀ  Ê 8«8$Ì  Р8»,Ñ  Ö  ×  Ø 8´$Ù  Ý  Þ % ß 8´ ¤¡¦¡7 ©¡% ª¡% ä¡
û¡8’¢8 –¢ ˜¢8´ š¢% ›¢8õ×L±¢% Ì¢, ߢ8ùštà¢'î¢8þ
„𢠀£ Š£8ë¹L£% ©£d÷‘Dû‘ü¡(üó2/ Declare the `bitflags`-facing bitflags struct.Á¦úüªWT This type is part of the `bitflags` crate's public API, but not part of the user's.Á(|4˜͹ Ê ï Ð , Ú8ÆÛ& Þ8Æß8, ê8×ú„ë& û8¼& , ƒ8¥ & 8´*  ì + ã ä ž8º ë 
8d$ ñ8n$ ÷8²$ 8}$ 8³$ 8­$ 8Ž$™+ ¨ © »8  ® º8ž, Å8ÆÆ8, Ñ8×ú„Ò â å, ã8¥ ä% æ% íü %üòGD Implement functions on the private (bitflags-facing) bitflags type.Áºúü¾ZW Methods and trait implementations can be freely added here without breaking end-users.Áü™VS If we want to expose new functionality to `#[derive]`, this is the place to do it.Á(|ð4† ݹ µ  ©% »  ˆ , Å 8×ú„Æ & Ö 8¼,× & Ü , Þ 8¥ ß & à 8´á $ ã , å 8ùš& ô 8¼ û  ,
 Š
 ÷
, œ

 º
+ ž
 Ÿ
 ¹
,  
8ù
& ¦
8¼
, ­
 ®
 ·
, ¯
8À
& ´
8¯µ

¸

»
8
, Ó
8«
& Ø
8¯Ù
 Ü
, Þ
8»
& ä
8
% é

ø
*Š   ¦%ƒ8 , ñ 8 '÷ 8œ '
8Š\„
8

,
8ùšt•
 ¤
 þ
 8!
8ê
 Á
, Ã
8¥ Ä
% Å
8!
8¥
 á
, ã
8×ú„ä
% ô
8$‰, Ž8,'8œL'Ÿ8í'¥8>'®8q8
¸, ¼8×ú„½ Î Ê+ Ü Ý ä8Ý8 ò8> ü ý(ÿ8$‚  À, 8×ú„š'ª8á  ± ²8, Ú8'à8œ'ë8í'ñ8×ó'ö8p8
þ, 8×ú„ƒ  Í8 ¢8×¥ ¨ ã ©8$ ®8± °& ± ³8´, ¸8'¾8œ'É8í'Ï8×Ñ'Ô8ˆ ß:8à â(å, è8'î8œ'ù8í'ÿ8×'8Í4†  Ã8Ÿ8 ¦8í ¯ ° ² Ô
, û8'8œ'Œ8í'8×È,”  š Â8± $ œ7{:#x}Á$ ¥ §, ¨8¥ ©8«, ®8'´8Ö  º'»8Ó8 Û µ
, ñ8'÷8œ'8í$„'ˆ8׊'8t<'8ט  £8$  8± ¢8, Ý8'ã8œ'î8í'ô8×ö'ù8t8
ƒ, 8×ú„ˆ  ð8 §8ת ­ è ®8$ ³8± µ&  ¸8¹, ½8'Ã8œ'Î8í'Ô8×Ö'Ù8ˆ ä:8å ç(ê, í8'ó8œ'þ8í$€'8×'8Í4  æ, ¤8'ª8š'²8¿L´ ½ Ø ¾, ¿8ùš Î Ô
Ï8$ Õ8± ×8, 8,'8œLˆ'8í$“'8É'œ8FromStrÁ8
¦, ª8×ú„« ¼ » 8!8Ï Ó, Õ8'Û8š'ã8% ï8 þ8þD  8¾ Š&  8ÉŽ(, 8,—'œ8œ'§8í'­8 'µ8Í ½8$ Â8'È8Ê Í Ï ±, á8'ç8š'ï8þ'ù û, ü8ùš  Œ Ž8¾  8Ø  £ 8÷,• š8÷ ¡7ˆ ¢8, Ë8'Ñ8œ'Ü8í'â8å'ë8O ò, ó8¥ ô õ8
÷, û8×ú„ü  ã8 8É ¤ ª ¥8(¬ ¯, °8¥ ± ³ Ù Å8 Ê7ˆ Ë8, ó8'ù8œ'8í$†'Š8å'8Š$• , š8¥  œ8
ž, ¢8×ú„£ ´ ¡8 Â8÷ É Ò8´& Î, Ð8¥ Ñ(Ô8 Ü 8'ò8þ
„ô  8´$…, ÷8'ý8ñ´ÿ   à! , ¥ 8×ú„¦ & , ¸ 8¥ ¹ $ º , ¼ 8ùš Ì  Ö!, Þ  ß  Ç!
, õ  ö  Š!+ ÷  ø  ‰!, ù 8ù, €! ! ‡!, !8À$ƒ!
ˆ!
!8,¡!, §!8«$¨! ­!, ¯!8»,°!% µ!
È!, ë!8,ì!'ñ!8²Ôó! " " ·", "8×ú„ž", Â"8,Ã"'È"8ÜÊ" å" ç" ¤#, õ"8×ú„ö"& †#, ˆ#8¥ ‰#$ Š#, Œ#8ùšt#8$¯#, ´#8×ú„µ# Æ#  %
<L Returns a mutable reference to the raw value of the flags currently stored.ÁüÔ#O+ °$ ±$ ¸$8Ý4²$8Æ$8 Ê$8bits_mutÁDÍ$ Õ$ ß$ Ö$8×$8$Û$(á$ ä$8å$, é$8¥ ê$ ì$ % þ$8ÿ$8$ƒ% ‡%7ˆ ˆ%% §%d’’D–’Îĺüö%ü‰MJ Implements traits from external libraries for the internal bitflags type.Á(|×í¹ œ  ¢ á, ¬8×ú„­& ½8¼& Ã, Å8¥ Æ& Ç8´È$ Ê, Ì8ùš& Û8¼ â Û, ð ñ Ð , ƒ  ¡+    , 8ù,ˆ& 8¼,   ž, 8À$—& 8¯œ
Ÿ
¢8, º8«& ¿8¯À% Â
Ñ*ã æ , ¦8'¬8œô® Ì Î Ž , Ü8×ú„Ý& í, ï8¥ ð$ ñ, ó8ùš ƒ ,   õ, ¬ ­ Á+ ® ¯ À, °8ù, · ¸ ¾, ¹8À
¿
Â8, Þ8«% ã
ö, 8'Ÿ8ÿü¡" à Š , Ó8×ú„Ô& ä, æ8¥ ç$ è, ê8ùš ú û, Œ  ì, £ ¤ ¸+ ¥ ¦ ·, §8ù, ® ¯ µ, °8À

¹8, Õ8«% Ú
í, 8,'8¹ü˜! ¹ » û , É8×ú„Ê& Ú, Ü8¥ Ý$ Þ, à8ùš ð ñ,  ƒ â,  š ®+  œ ­, 8ù, ¤ ¥ «, ¦8À
¬
¯8, Ë8«% Ð
ã% ü%+»ŸŒì$œë$ôâ$(|Ã$4Ù$ý¹ ­% û& ³% ò&, ½%8×ú„¾%& Î%8¼,Ï%& Ô%, Ö%8¥ ×%& Ø%8´Ù%$ Û%, Ý%8ùštÞ%& ì%8¼,í% ó% ì&, & & á& , ”& •& ²&+ & —& ±&, ˜&8ù,™&& ž&8¼,Ÿ&, ¥& ¦& ¯&, §&8À$¨&& ¬&8¯­&
°&
³&8,Å&, Ë&8«$Ì&& Ð&8¯Ñ&% Ó&
â&*ô& ÷& ø&% ù&ü˜./»Æ¬ÿ-¼þ-üõ-"(|Ö-4ì-
º È. 0 Î. 0, Ø.8×ú„Ù.& é.8¼,ê.& ï., ñ.8¥ ò.& ó.8´ô.$ ö., ø.8ùštù.& ‡/8¼,ˆ/ Ž/ ‡0, œ/ / ü/ , ¯/ °/ Í/+ ±/ ²/ Ì/, ³/8ù,´/& ¹/8¼,º/, À/ Á/ Ê/, Â/8À$Ã/& Ç/8¯È/
Ë/
Î/8,à/, æ/8«$ç/& ë/8¯ì/% î/
ý/*0 0 “0% ”0üú7.»æ¤â7´á7üØ7!(|¹74Ï7º ©8 ÷9 ¯8 î9, ¹88×ú„º8& Ê88¼,Ë8& Ð8, Ò88¥ Ó8& Ô88´Õ8$ ×8, Ù88ùštÚ8& è88¼,é8 ï8 è9, ý8 þ8 Ý9 , 9 9 ®9+ 9 “9 ­9, ”98ù,•9& š98¼,9, ¡9 ¢9 «9, £98À$¤9& ¨98¯©9
¬9
¯98,Á9, Ç98«$È9& Ì98¯Í9% Ï9
Þ9*ð9 ó9 ô9% õ99¸üÇ/74 An error encountered while parsing flags from text.ÁT0¹$…¨8/ùãàÔÕñ$¹$4@ñ$¹$ÓÓ
Ôt¦0@ÓÓñ$ÄZÄZ ¹$×Àc×ÄZÄZŠ ¹$ Š c cˆ¢cµ
 `£cŽ· `àB¤GS
™aÖˆ0Ö
×ÄZ±ÄZœî0tó0@ñ$f™Æ¼
eÙÚÛÝÚÜÞLˆ1@ØØñ$@ØØñ$„—1@ØØñ$<×1»À|¼1Œ»1ä²1×1@ØØªKt 2@ØØñ$<Þ2»À|Ã2ŒÂ2ä¹2Þ2@ØØªK\\
ñ$àÀcà\\ŒŽ Œñ$  c cˆ¢cµ
 `£cŽ· `àB¤GS
Ž™aßÁ0ß
à\±\”Õü‰:5
A defined flags value that may be named or unnamed.
Áâ‷ åÖ%‚q $ãä!”îfááñÅD†,†fááÛ"aaææ€·¿cÛ" åÖ%çÀc禨aa Ö%  c cˆ¢cµ
 `£cŽ· `àB¤GS
™aå Íå
çÛ"a±a€ åP˜&é꟠  ˆQ( ŽQèè˜&Ñ— ³Qèè˜&€ ãQ¢&ìퟠ  †R( ŒRëë¢& ±Rëë¢&  çR˜]ïø ŽS5H S Ö¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
˜&¹$î ¢Sî
ïóŠ( ›S ‚Tï¬ÛðÄÛðáÛððïðº'ޓޓ
ParseIntErrorÁíÙ_iQÏ/ô¹$½~  ØT¢&ò]òø ÿT5H U Ö¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
¢&¹$ñ “Uñ
òóŠ( ŒU óUò¬ÛóÄÛóáÛóóòóº'Ž• ½~  ÉV˜Zõø ðV@H óV ˜&ã´™aô¨öö ŒWôÍìã´ ýVêbã´P €W
õã´ Wüq0 —W02  X¢&øZøø ¸X@H »X ¢&ã´™a÷¨ùù ÔX÷ô˜  ÅX†™ P ÈX
øã´ ÕXüq0 ßX(*¨ ÙY¢&¨ þY˜&Éä&ýþŸ ÇÅüüä&Ñ—Ãüüä&Áî&€Ÿ ¿½ÿÿî&»ÿÿî&¹ä&ƒ]ƒ·´ Ö¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
ä&¹$²
ƒóа®ƒ¬ÛÄÛáÛƒº'Ž• ½~hî&†]fc Ö¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
î&¹$a
óŠ_]¬ÛÄÛáÛº'Ž• ½~[ä&‰ZYV˜ ˜ä&ã´™aˆ¨ŠŠTˆô˜ I†™ ?
ã´=üq;il;î&ŒZŒ96 î&ã´™a¨4ô˜ 2†™ 0
Œã´.üq,RU,î&*ä&ñ°'‘Ÿ ïí°'Ñ—ë°'éº'”Ÿ çåº'ãº'á°'—]ßÜš šÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
°'¹$Ú
óŠØÖ¬Û˜ÄÛ˜áÛ˜˜˜º'Ž• ½~º'š]šŽ Ö¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
º'¹$
šóŠš¬ÛÄÛáÛšº'Ž• ½~ƒ°'Z~œ œ°'ã´™aœ¨žž|œô˜ q†™ g
ã´eüqccº' Z a^ º'ã´™aŸ¨¡¡\Ÿô˜ Z†™ X
 ã´VüqTz}Tº'R°'
ü'¥¦Ÿ 

¤¤ü'Ñ—
¤¤ü'
†(¨©Ÿ 

§§†(
§§†(
ü'«]«

ž žÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
ü'¹$ª
ª
«óŠ
þ «¬Û¬ÄÛ¬áÛ¬¬«¬º'Ž• ½~¸ †(®]® ³ Ÿ ŸÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
†(¹$­± ­
®óН ­ ®¬Û¯
Flag::nameÁ¾ {macro.bitflags.htmlÁ
Flags::allÁ Flags::FLAGSÁÞ Flags::iterÁ Self::FLAGSÁ
Flags::insertÁ
Flags::removeÁ«áÎË ¾ æË þË ‘Ì Þ«Ì »Ì ËÌ ÝÌ ÎË «¾ æË þË ‘Ì |«Ì Þ»Ì ËÌ ÝÌ ž{¦ÃLðìŠ  غãàéæ³Œ""“""Û Þ ã ŒMÃMÐLÇLùMÌìÍì“íµßíß{ÃLðìŠ  غãàéæ³Œ""“""Û Þ ã ŒMÃMÐLÇLùMÌìÍì“íµßíßöø–ú¶û•!\Y{ž¡£¦¯ÃLðìŠ  غãàéæ³Œ""“""Û Þ ã ŒMÃMÐLÇLùMÌìÍì“íµßíß | 0xunsupported hex flag value
ParseError
InvalidHexFlaggotInvalidNamedFlag EmptyFlag FlagnamevalueÀØÐ âÐ ëÐ ŒÑ Ñ ²Ñ ¼Ñ ÓÑ ãÑ îÑ ùÑ …Ò Té!‚ÇcÜâ}fT¹¦ËB¥í+‘¢ä…'bñÿ{}^ú`§Éµ–"ÔcŽŠýÔöNTš[tdõò ‹â¦¬†Ø¤w?ò¿-©ã?˜õê/§’é)äá ¬P×Ë0-1wÁ,ˆ…,ÿ¸×¯DQ ²gÂ]À–j»›
;ðzõ9§})ô³º÷žKøgÎ z+ÜÊ’ÃóHí ¤D¶IQ¦zP
ƒ-i–Hñu»˜ôˆ$†KÕbõ<aÒïÝRH+Ê%nÝч8À¿;të:‡³ôî9¨‰€Ã»…ѵßOD ÁÈÒòø§•t#©ù5{`$‰…]þR
oÚ"x«•ô?¦Níõ>1ª&™QX®Ìs´G¶¶aÙÃjó*P¬Í—dhÿdê¶Ï›KŒ¤æ¡dôg¬vùÿMUÈÒz˜¡º®x¦®®5\7th!ÔOñ<îï:u“·¸Š›(¸·?!ñÆÖ¼ÍŒåÚã>9SIÔxeõ±téÿò·ºÏå×8½”Ýaa¨\¡ºz{|ŠžW]=
×¥¸Éµ.kò? èHLZò½}Oô³­YÃ4¦Qm, SF~wu¿uŠ!ð:}§•´ïìß¡»´Ê5àù.úM÷Ô[1‡¨
vçNob«ã” I7à„ ]Œ ¶Ž“VÖ{øüú[Lå´ªé¤ÀŠˆ“(þñ.
bãáWN‰2@íÈVß9~(pbû˜'WÀô¦þÚÕØM²î§ŒÐéÚ'¾J-ÆyÔ;rž3
z ­^5ñ/ñzt)o=rtëØª]뛘BL¤ÉôïM`ÔÎî¼^5&Ybºì7«À«“Ö (o>ˆ¢„=1ËÿªÌdã›é}ÎjQ=²ñuד³‡j‰C$²W&H`¸Ôбâ¡’î-ú߸; ç˜`¢x“ª©ñRó×çTUWÀ‘è#Tñ!…ŸP¬ïc°L=>±Ð=y©"Â#N(r÷þÎcø‘ÄG)Á²Q¦D\ü3&ÚíF=¬ÙMg½%åV=—e‡‘ç¯Xö­îà›Yø´@.ó¿=!r„UM2Õ”Øð§ñÇꛩ:õ8h,&«‚³£ EDbÇÐiü#>Œg”dêe.w€·¯;XL¡z.z]Ïö¶»Á`Frz7wËQƒ<0Na4 ²Ó ÝTð‹´n‚Ζ :5@A^Ø|ÄVÊwxw“âu„¨ªVZhYñ­i†Ïÿ¹„ø=ßÊæÄpc;É?êÞúëµ ¤çSìÐʯ…@) ›ãN·Ÿ‰4¦IKKãæl9Ÿ`¹“ÔÇþN%N£ÕèÚà¹Pæ÷nÖ¨¼az]†H¦«UŸˆöv×”ĈøbBc#¦¨·¼4ðÑØ‹¢xU&h¹Œ¶¶‚5èÚmdrøÅiÞ¬'MaÔ-åh°¨~fMÌEìØyKÀžf$ª„Pdº×ùV÷è²pUÈ(
-ß–éé®f ZæCµœŠÌ«ƒÇ‡;/òžš­ñQÆI€›?]ì§ ºÔðž
V^™ëO;åNEêQ%Õû|2†.€]M¼^Î6Ýj8QÒ _«óvàå\a벓Ænï`ÛÍ<‘´†GO˜ÄóÁn·Ý«‚§ –z±R0ëE ÁßBtÏJÕ“Ú3Þ¢*ÛØv<¨"bêžvÒñÅBGäÙ9ãˆþ½hv\X\ÒG„À¹›´¥loV5Û%4Ld´[- ;=žZšøNž
½†€q ëÔóiþІ Fßvb I†˜okÀÎÆC â=pâ~‰sP#—éW`Ü‹²3MìÚU Ôºd-âQn&ËnM§bpÓ
;c
2#NÆÿ-=Âg0ÆÝûKÕ;àmgÑ{É[x /¨º ƾôùÇOõÄ•ìáÜ`»úMžaÈ5y<öwZÈï´¢ëdÄL]œy[²ÔØbˆaÍxSѾ‹ïhTÕÑf_þJYªRöÑÿÊ~Ï.öÄ ·Æ4"$¶nSùYêc›ûä8ßéêôÄiàsÂ&M»
Þõ³„]D,3JÜ7ÀÔò³ÐfHU¤Ãì®Z¾2½Ö­½²|Ò,~ðÄ0àþ¬UìN §ß2ž?>œrñïÍÔ¤!³î^fþrа4¬|œ¨¢¸K÷ϵïxçs4¶ Rný%s=„3Õ³s.|/Ýö#r"Ý`6·óÏÑéUÑí˜ìSïˆu¼cߥ]ƒT+Ø=ÄzƒÿbgAØ*}¿VÔ#Þ®U§s÷¬1Æö©‘}—c|Œì¥Q
´üϤÁ^)üõŽØ}R¬ZcbW64[âÁxÒYÎ~£Ñ5²O.4$5»0v+¾=£¬.fw<Ëâ)X‰à$càW—äã(0mÕ é(;<t“,ð"k­9&ËÖéíðèC²_Bг_8®"ê‚"\ß³žCŸËØ„ë"”€Ÿ‚‰¤'rÿ‹í…jV8´ÕfÐr':(°llûZàIN1˶}}q­'Dqàëð
2ËÉ»’ÝäyS‰ûE¼‹¥²ûŒtÝõ€YsçýžnÒ¬D@Á«÷
Yð_ârë¼ÀÝ籑=Ac|ìÙvxÜ»U¯èð» Í·Ë*¯ŠLßÕN†Ý²q98bõ,åmtÎ×xº*Ó?"‰»À õYEéâišXc¦d!ÅgÕfW
G¹P´Y‘âÔâ äκߛ¸‹wëC‚y™Ý{ªØ‰iV-?}ž{g: —øÅ: §•À°¨šiL’@õ¯Vf•ĸª”uaØ“)÷ßè}ßOn‚ßJýl3,±!9§kk‡w…HG¶Fld „+Ò«aèã->i¡Ó¥2:ÓØY«!E\ UUÉáÊ|¦oXQ$ ;¾gŸ*v-4pf¾Ë+"Ü–öÞùTV=º$þw%)£²€ß‹ôX¿qZ.5(u³p#¨¹6ÆÊÍ^r{ovJ•ô§Á¾@`(jı¡«:}øð}ÏöÊ]åøpîK÷;*Éòo
ím²ì¢h_ulkDw"Fs”û§O²âR 1>®õ<ZÖ_ÈŒª]
øq;?F@=uÒ°T3©v=FIëÊž…º°ðGlœ„IŠÞ6`\“ô6^9ÿhqiw…;¡,¬4—ÆÒ@ÃN.û#PƒÙh
YW(ORí½Àæñ_Ñg\ÂÂ{¸ Ðí„°K}¦ìR¨Á·ýdGûÖä(Öq‚äÔB­•Ô¬;î•^_4êýðfÖ¶êÞè‹d/¦F3‰w>7¶´@d…zñc·áhjA 6’ä KpÄ:)£ü‹Ð˜¸ bÝäÙ6âDË&—8ÃYXLÑ£õµ×4OÕ=c”ìžÛÆIIh».âE`òj 3“n‚½‹#Y
G¦_Ê“"hz6?‰žM:ŇQ<p¹i§Zá´| j‚¥úbæ.c¾ãÐÕæï^Iuî¼\(uÊysе•¿âS]v"ß`2dT³›àÍ¤Úæ“\ê5/}M¤Ë/½É’R×Ëm“O8]Xᶬ7ÔÀzú=ªæöcñ*Rq \¼šöP…=­¿qÚ sš!ñÎ9œ»±œÊØ×pD·LJGó¶Xƒ é{ÆZ°§º
í‚»1P-WäÇ" @B*&‹ˆ‘å´’ÄK¾E4´
šš«3½D)t¶—)c$
&”E½TW•bÕ!šøHs»‚XòCå( ›WVŠü‡M¸}EsÎm»ó˜¡Ý84+‡jŌնN¡&&è…™Ãùh³ch•çöw¡á­L4§R¡QÚÛ4þ^m]¾†Â¦G›Ápxö?M|ÇDP3âOú€M<HÄ1kÄœôæôð ~BÂP†cãå¶Æ¨
R ¤¹¡Ã×DðDÖŒÉçiàÍüS|?ÎÌoF¡ePñ顃²Îo€9vþžGÉI6$8¨PòãýK+Úu¯»‡þ‹ÁaáÏàz(ô¶‡cHßïâ>(³é½Åc|Xsºîʽ7Oy¾§ù² Åþ-Ümö\éǧö
—$DH7òU̬޳H£ÌqMÇÍuøéN[f*¦òR«·Ãú«„õ„à쑽õêÃŽ¾€²ÕØ*nļÄqçp¶‘‚€4*pCìƒ0¸·/q%[Ó?wôwv´ÙuInÝêç Ž”÷W¨JýußX$dÀ+Ï]-¶%•¹ª>÷¸÷OŸ#ÛG:Ø=Ç®'uäŽÆÇ¾ºÇæõ× mð‹Õô§~G÷1ƒuJ¬lÌÝV öºç/Q3gP!³õ ³Ó,8UØÎï\>j2.dO''&)u)5w'œ'b)·)óÊôÇ
3:'ù(-óÐôŽ
9@' )-«c­c¯c°c
ÜHÜ»ÜÝݽÝòÞ ß#ß;ßSßßàß ààâ^â|âã7äPäiä¦äßä)åBåâ忬æÅæçXç¢ç»çZè.ësìíîMîLïjðsñòáò¡ógôâôÀõØõˆöQ÷Ç÷â÷øùÏùúTûçûÀü¡ýÛW¿+m¾JÒpG 

û
" X
¼?fø<é}%E©D¡eÁcy½þD&§'ï'P(Ï)9*½*+!+;+y+-N-È-ÙJ9j¤tô| ´Õ±ã±ˆ´ÏÇîáUë{P!^!$7Ž77^=>?AþB®CÅCåCD×DE4EfEE±EÑEFG0GIGGOHoHˆH£HÃHÜH÷HI¼I]JzJ"KKœKBL_LôLMM4MKMbMMM®MÈMhNÃNÝN}OØOòO{PPQ.Q>Q\QsQŠQ¨Q¿QÖQðQRëRS¥STT£T½TFUVUfUUU²UÐUçUþUV¸VW-WÍW(XBXËXåXnY~YŽY¬YÃYÚYøYZ&Z@ZàZ;[U[õ[P\j\ó\
]]¦]]Ô]ë]^ ^7^N^h^_c_}_`x``a5a¾aÎaë×õÙ« êóÖô˜øš j?F')
--p-Þ±Y!ˆ77µD0Û¡Û3ÜäÜÝÞ|ß à=â$ääåæîæçó×ôÌõÓ÷²ùÖ n?J'!)è*f+
-gCÖCÅDÊDÑDÂEGG[H¯HIiJKNLMM"MnMºMÏNäOP*Q:QJQQâQ÷R T¯TRUbUrU¾U
VW4X×XzYŠYšYæY2ZG[\\ÿ\¢]²]Â]^Z^o_`'aÊaÚa   
   
  
  
      
+


 ++++++++++++++++++++'*              ê×ôÙèÚÍÛ ÝŸÞöÞߨßÒá“âæã½ä˜æ°æç¦çÒçªêÂëªîþïØðÜóœôõûöª÷ù÷–øû£û‡üKF¢ú 2 Ú c
Ò
ã 
{&ºPë˜5ÙAóÅa
p45±§èH 'Ü'<( (* * +%+Ñ,-o-Ë7êKsûtÍ}ëeܱ²²ÃëïW!,"T%†7”78=|?]AECŠC°CûCšDÛDEEPEjEœEçEÈFG4G±GtHHÈHáH,IJ´KwL7MNMƒMšMÞMóNP«P_QvQ«QÂQRS0TÓT‡UžUÓUêU.VCWXXûX¯YÆYûYZVZk[€\#]×]î]#^:^~^“_¨`Ka€Ù†ÙŒÙ’Ù¤Û±ÛܶÜôÜÝݸÝáÞîÞßßߌßÜßàà‡àâã•ä¢äÚäåÝåƒææ¨æÀæñæþæ‘çžç¶çëëëë‚ííþí†ò“òÝòœóÝô¼õÓõƒöÂ÷Ý÷Œøù…ù‰ùù½ùÊùˆúâû»üœýÖS»'i¹EÍlB 

ö
 S
·:bôŠ7äx ˆ@¤?œ`½]u¹ú@Œ&£'ë'K(Ê)4*¹*÷*++6+g+t+->-B-F-J-©-­-±-µ-¹-½-Ä-ÔJjŸtï|®бÞ±ƒ´ÊÇéáuK!Y! $z7Š77Y=9?AûBrCªCÂCâCDÓDíDE0EbE|E®EÎE|FGG,GFGG˜GJHjH…HžH¾HÙHòHI·IXJtJKzKK0L=LYLâLïLMM1MHM_M}M”M«MÅMeNÀNÚNzOÕOïOiPxPP QQ+Q;QYQpQ‡Q¥Q¼QÓQíQRèRS¢SýSTT TºT4UCUSUcUU˜U¯UÍUäUûUVµVW*WÊW%X?X¹XÈXâX\YkY{YY©YÀY×YõY Z#Z=ZÝZ8[R[ò[M\g\á\ð\
]„]“]£]³]Ñ]è]ÿ]^4^K^e^_`_z_`u`` aa2a¬a»aËaÛaáaçaíaóaùaÿab bbbb#b)b/b5b;bAbHbObUb[babgbnbub|bƒbŠbb˜bŸb¦b­b´b»bÂbÉbÐb×bÞbåbëbñb÷býbc cccc!c'c-c3c9c?cEcKcQcWc]cccicocuc{cc‡cc“c™cŸc¥cƒÙ‰ÙÙðÙäÚ¦Û¶ÛöÜÝÝ›ÞãÞòÞ ßß‘ßà»áâã—ä¦äå…æ”æ¬æóæç“ç¢ç»ç¦êëë«ëí„í“îçïÁðòˆòÅó˜ôõ
öäö“÷â÷’øƒù‡ù‹ù¿ùûŒûGB÷ãòõà L
»
Ì 
d£9ÔÂ*Ü®JöYz­£äD'Ø'8(œ(*œ*ù*+!+i+Í,-D-H-k-·-Á-È7çKsøtÊ}èb×±¯²µÀëìR!)"Q%778˜=y?ZAACuC®CåCDÙDïDELEhE˜EÑEÄFGG0GGGoHˆHÃHÜHIzJœK2L_LäL4MKM€M—MÈMÝNòOlP•PQ\QsQ¨Q¿QðQST”T½T7U„UUÐUçUV-WBX¼XåX_Y¬YÃYøYZ@ZU[j\ä\
]‡]Ô]ë] ^7^h^}_` a5a¯aÞaäaêaðaöaüabbbbb b&b,b2b8b>bEbLbRbXb^bdbkbrbyb€b‡bŽb•bœb£bªb±b¸b¿bÆbÍbÔbÛbâbèbîbôbúbcc cccc$c*c0c6c<cBcHcNcTcZc`cfclcrcxc~c„cŠcccœc¢c¨c¡(*¡*ýÚ‡Û®ÛôÛÜ”ÜÐÜþÜݦݴÞëÞß߉ßÏßõßàâãûãŸäÏäôäËåæ¢æºæÚæûæ›ç¯çìŒíøíëîñòÖòô¯ô–õÈõ€ö÷º÷Ï÷¦ùÇùÓû¬üˆý^O´  a±1¿X4 ï x
ç
 ?
£-NàvÁ\kðˆ%ˆL©JƱò'æ'F(¾(/*´*Ô*++/+R+q+æ,LCžC»CÒCyD¢DæDE)E[EuE§E¾EeFßFG$G?GeG•G0HWH~H—H«HÒHëHÿH£IJeJ KfK‡KîK:LJL±LìLüLMMAMXMjMM¤M¶MSN¬NËNhOÁOàO@PuPƒPãPQ&Q6QFQiQ€QQµQÌQÞQ{RÔRóRSéSThTT«T U@UNU^UnUU¨UºUÝUôUV£VüVW¸WX0XXÅXÓX3YhYvY†YY¹YÐYâYZZ.ZËZ$[C[à[9\X\¸\í\û\[]]ž]®]¾]á]ø]
^-^D^V^ó^L_k_`a`€`à`a#aƒa¸aÆaÖaêÚ¨ÛèÛ ÜŒÜ½ÜøÜ
ݚݡÞåÞøÞ߃ßÃßâßàöáâùâèã™äÇäáäå¿å‡æšæ²æÇæõæ•ç§çßë†í¦íîÇîðõðŠòªòýóôŠõÂõ÷²÷É÷“ùÁùÇû üLG¬0%³L( ç p
ß
ý 3
%BÔjµP÷_ä|D¡B²¨é
'Ý'=(ª(&*«*¿*û*
+&+=+k+Ò,FC•C²CÌCkDœDÝDE ERElEžE¸EWFÊFGG6GPGG"HQHuHŽH¥HÉHâHùH•IÏI_JûJ5KKÑK4LDL”LæLöLMM8MOMdM„MM°MGN{NÅN\OOÚO%PoP}PÈPQ Q0Q@Q`QwQŒQ¬QÃQØQoR£RíR„S¸STMT—T¥TðT:UHUXUhUˆUŸU´UÔUëUV—VËVW¬WàW*XuX¿XÍXYbYpY€YY°YÇYÜYüYZ(Z¿ZóZ=[Ô[\R\\ç\õ\@]Š]˜]¨]¸]Ø]ï]^$^;^P^ç^_e_ü_0`z`Å`aaha²aÀaÐaÛŸÛøÛšÜâÜÝªÝÆÞßßÓßàâ ã
ääÓäåÏ妿¾æìæç³çüíïÚò«õÊõÀ÷Ñ÷°ùÙû²üŽý¸$f5Ã\8 ó |
ë

C
§1Räz Íhw)ü)ŒP­N÷æ*+4+d+NC¥CÀCÔC~D¤DëDE.E`EzE¬EÀEjFéF)GDG}G5HYHƒHœH­H×HðHI¨IJgJKkK‰KLLLÈLþLM MFM]MlMM©M¸MXN±NÍNmOÆOâOSP…PöP(Q8QHQnQ…Q”QºQÑQàQ€RÙRõR•SîS
T{T­TUPU`UpUU­U¼UâUùUV¨VWW½WX2X£XÕXFYxYˆY˜Y¾YÕYäY
Z!Z0ZÐZ)[E[å[>\Z\Ë\ý\n] ]°]À]æ]ý] ^2^I^X^ø^Q_m_
`f``ó`%aaÈaØaéÚÏÛ{Ü5Ý ÞªßSàÓáâçã¿äZå6æçÓçÃë'í«îÿïÙð5òÝó õ"öüö«÷ú÷Xúû¤ûˆüdý£û
˜3
 Û d
Ó
ä 
|'»Qì6ÚBôÆbq56FCŒCüCœDEèEÉF²G-IJµKxLßMôN P¬PRS1TÔT/VDWYXüXWZl[\$]^_©`LaÐÛ«ßÔá•âÀäçÔçÅë­îðÛðßóýö«÷ú÷û¥û‰ü¤ü 4 Ü e
Ô
å 
}(¼Ríš7ÛCõÇcr67iCŒCüCèE³G-I“J¶KyLßMôN
P­PRS2TÕT/VDWZXýXWZl[\%]^”_ª`MaºÛ•ß¿á€âªäç¿ç¯ëí“íî—îëïÅð—òÉó õöèö—÷æ÷ûûûçmöùÇ P
¿
Ð 
h§=Ø"Æ.à²Nú]!~"wCèCñDÔEžGI¼IJ"K¡KdLËMhNàN}OõO˜PóQRS¥STÀTV¸V0WÍWEXèXCZàZX[õ[m\]k^_€_`•`8a¢ã5sG[e´ìQ§°¹ÂËÕßéóü!+5?HQZcmw¦¯¹ÃÍ×àéòû#,5>GQ°ÛÝíÞ‹ßà¡äæýæçŽí’ò‚öÉù+s+G—G<LîLwPQŸTBUÇXjYï\’]aºaÀlfî˜÷î%n&y)Œ*S.Ü:¹FyG(HóIRLñQZÄ^µ_˜bÈcvdHe¤fÍg_hlCo)p4q£r<t]uxzyö|ª}r~ ¾ʀÂ¥„Ÿ†¦‡‘‰|‹gvŽ*ï´’®”~–ÂZ\aŽ˜š›´žà ô£ ¦•®Á°ß³ Sš `c%dÔdèe0gµ—'˜Þ£’£Ú¨°­³
£¦’­¿°ë²kœeíöí%m&x)*R.Û:¸FxG'HòIQLðQZÁZ´_Ÿ`aÇcudGe£fÌg^hlBo(p3q¢r;t\uxyyõ|©}q~½ɀ‚¤„ž†¥‡‰{‹fuŽ)î³’­”}–§—‚¸\Ã^—b˜˜™›Ï³žß  ££ó£¦Å¨“­®”®À°ì²Þ³
˜Ü¾÷×û°üŒý£C®— ˜ ˜†˜×Kž¬ž£s£‹£ì£Y¨·¨Ó¨4©©­®®ú²X³v³×³²—˜$˜Š˜ÛOž°ž£w££ð£]¨»¨×¨8©­­ ®0®‘®þ²\³z³Û³ÿÛ¡ܱÝÕßràâãÚäÖåLçOèEìzíïPðEñ~òGô³õoö8÷Â÷}øzúHûÛû´üý»'>Æe; ü 
î
 L
°:[íƒ)Öqz22S°WƒDoF=H­IKLÑL]NrO\PÿPRšST'U­VÂW¬XOYÕZê[Ô\w]ý^`ü`Ÿa»ôs·#*'é(ñ,è×îÙâÚ
ܻܙÞàßâàãßäÅæ¤ê–ôÀõÇ÷ø‘ùE«þ'š(½*;+Ë,-i-Õ±P!7Ž7?CÊC”D×DEfE¶EÂFNGOH£H÷H]JKBLôLMMbM®MÃNØO{PQ.Q>QŠQÖQëRT£TFUVUfU²UþUW(XËXnY~YŽYÚY&Z;[P\ó\]¦]¶]^N^c_x`a¾aÎaÕÞä]C³DøFÛÈÞäPC¦DëF25<@DHLPW[_cnuŒž¢©ÃÇÎÕÜìóÿ &*18<CJQU\cjˆš¡¨¬³ºÁÖÝäëïöý#'+/37;KRcjquy ¸¿ÖÝäú$+:JNe}®²¹ÆÊÎÒÖÚÞâæêîòöúþ ):FR]ipŠ®ÊÑáú!(9Rix¥´ÁÎÛåñ
6GN[fv˜ °¿ÇÏÓÛãëï÷ ( - 2 7 > C H M R V Z i  ” « Á â 

%
F
l
Š
­
Ï
ô
û
 > E M m u } £ § ¯ Ä Õ Ú ò ý    ' 2 : B J N V ^ b j r v ~ Š £ ¨ ¬ ´ ¼ À È Ð Ô Ø Ü ä ì ð ø




"
&
.
6
:
B
J
N
R
V
^
f
j
r
z
~
œ
 
¨
°
´
¼
Ä
È
Ì
Ð
Ø
à
ä
ì
ô
ø
 "*.6>BFJRZ^fnrzƒœ¤¨°¸¼ÀÄÌÔØàèìôùý
"*26:>BFJNRVZ^bfjnrvz~ŠŽ ¥ª¯´¹¾ÃÈÍÒ×Üáæëðõúÿ "',16;@EJOTY^chmrw|ØÞä_C½DÅDÌDûF¢ÛæÜëÜ à à“ä
ååïæƒçˆç—óØôÏõÐõÑõÔ÷·ù¸ù¹ùºù»ùABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^rsN'ƒ'%)t)ì*ñ*ØCÄEG_HdH³H¸HIkJKPL&M+MrMwM¼MÑNæO‰PNQSQšQŸQäQùRT±TvU{UÂUÇU V!W6XÙXžY£YêYïY4ZI[^\]Æ]Ë]^^\^q_†`)aJÌ7ëKsütÎ}ìf³²Äëð-"U%8œ=}?^A³cse¬eÇe
!gtgÕ*g£ÛðÜ
à”äåðæç˜óÙôÒõÙ÷¼ù_t?¢'É)ö*f+
-ÝCÉE†GiH½H IoJKTLMM0M|MÀMÕNêOP*Q:QXQ¤QèQýRTµTRUbU€UÌUV%W:XÝXzYŠY¨YôY8ZM[b\]¢]²]Ð]^`^u_Š`-aÊaÚaecòïš®ƒ«Â¿ÖÓü\ªKêaêaŒªK÷\ªKêa_º3.4:PO@-VR 3\U#9bX&?,
28N>+TQ 1ZT"7`W%M=fZ*C06<)RPB/XS!5^V$;dYAô ô  °±ô 
fmt_internalsÁfmt_arguments_from_strÁTé!‚ÇcÜúW?[‡jê á
ô ¬­ýTé!‚ÇcÜbÒÍgTA$×Èà ÇW•¨¨ Té!‚ÇcÜN—Îü¢~’ ²
ô ¬­ýTé!‚Çcܲóúñ$crate::format_argsÁñö¨ Å‘ ¼© Ì© žœTé!‚ÇcÜ2ªÛ XÀWµAô ¬­ýTé!‚ÇcÜÎM&É
r@Œ« ñ!ö¨ j¼© Ì© žœTé!‚ÇcÜO?,SÊÒÞ¤ £Ÿô ¼© Ì© Té!‚ÇcÜå×6¤6º×Èà YBTé!‚ÇcÜKœ—¯™ƒh ¸"ô ¬­ýTé!‚ÇcÜ5ý÷
Üù¯œ˜6ô ¬­ýTé!‚ÇcÜ‘”KNÕN* „¯ô ¼© Ì© Té!‚ÇcÜ+ÆS?AØN‰×È·öTé!‚ÇcÜîáÞ_vaTù6ô ¬­ýTé!‚ÇcÜ)ʆ.l\U¹Œ« ñö¨ ༩ Ì© žœTé!‚ÇcÜ>ú!åtIÙ Ïô ¬­ýTé!‚ÇcÜ'ó©nµ3ºŒ« ñö¨ H¼© Ì© žœTé!‚ÇcÜÉ]]Ôš"Ì Šœô ¼© Ì© Té!‚ÇcÜæŽiÏÏ©éý×È!Té!‚ÇcÜÌЉŠÕû¸:Pô ¬­ýTé!‚ÇcÜ%i‡—À+ü
Ÿô Té!‚ÇcÜÙR
ûx9ói ô ¼© Ì© Té!‚Çcܨ33bA¥×ÈÎÌTé!‚ÇcÜ>]"&UöhJ à+ô ¬­ýTé!‚ÇcÜübú
Ë
ô ¬­ýTé!‚ÇcÜH¡qÈúíÔÌŒ« ñö¨ 弩 Ì© žœTé!‚ÇcÜšß¼¤’Ç"p,Á0}žØcore_intrinsicsÁfmt_helpers_for_deriveÁÂcÁcTé!‚ÇcÜ´TW,ODШ?ô ¬­ýTé!‚ÇcÜbiNlÄRL Œ« ñö¨ §¼© Ì© žœTé!‚ÇcÜö@AŽ¿wž¥ ò™ô ¼© Ì© Té!‚ÇcÜZÕÂ}Iùõ×È>~Té!‚ÇcÜ)‘Ú
ÂÀN?üä!Ÿô Té!‚Çcܯbg …]saüÇ+‚ô Té!‚ÇcÜ×óg? Óyë ô ¼© Ì© Té!‚ÇcÜ™vd…n9£×Èä$Té!‚ÇcܸjÎOö-@Vô ¬­ýTé!‚ÇcÜYrDú“º„¸0…Ñ÷ ³œTé!‚ÇcÜ¿eOu²Ü6ô ¬­ýTé!‚ÇcÜ9¸øÓ.§ªlŒ« ñö¨ k¼© Ì© žœTé!‚ÇcܽrìêvçE&p,ˆ0γ à³ ÂcÁcTé!‚ÇcÜÄÙ$[ÊèvüÇçô Té!‚ÇcÜ+ÎïÐŒ« ñö¨ ¼© Ì© žœTé!‚ÇcÜ5'ê1ѤaÇüþ& ô Té!‚ÇcÜ T¡è™ÿ—×ÈÒÐTé!‚ÇcÜn–´R­|Ç íô ¬­ýTé!‚ÇcÜ”àî¨êþ_ §ô ¼© Ì© Té!‚ÇcÜ=ýÆó¾ù¼×ÈZXTé!‚ÇcܤH„3ô»¾Žü°'ãô Té!‚ÇcÜ^ó}™Õº„ÿ/-³œTé!‚ÇcÜò•
Ö‘ðú ¤ ô ¬­ýTé!‚ÇcܸóYÖê* ú¶ô ¼© Ì© Té!‚ÇcÜÖc¡Qx}òŒ« ñ
ö¨ ü© Ì© žœTé!‚ÇcÜB>õ‘çs^úü«Zfü˜P‘
¢fTé!‚ÇcÜQ|Ìø}ø$Š Ø
ô ¬­ýTé!‚ÇcÜ áñ+˜ÿꌫ ñö¨ [ ¼© Ì© žœTé!‚ÇcÜ•‡çÃ& ãºü˜cô Té!‚ÇcÜ/mÌ¿èáYXpγ à³ ÂcÁcTé!‚ÇcÜö!±)Oz!*eJô ¬­ýTé!‚ÇcÜÁ@¿¿£¡È} ã¤ô ¼© Ì© Té!‚ÇcÜ)æ~Ç”ç(’×Èy ¹
Té!‚Çc܃AþvB›× û"ô ¬­ýTé!‚ÇcÜú‹wÊ…Œpvô ô ¦ Té!‚ÇcÜ«XÁò™W¢„µ6ô ¬­ýTé!‚Çcܼ™ÖpÅn$ δô ¼© Ì© Té!‚ÇcÜn²‚„Њô×ÈU
 Té!‚ÇcܼŒ€.Î)h¥º„ÄD³œTé!‚ÇcÜRk™èKQ#@7ô ¬­ýTé!‚ÇcÜr“c4%+²Œ« ñö¨ ¬ ¼© Ì© žœTé!‚ÇcÜ¿+yú6Øÿï ñô ¬­ýTé!‚ÇcÜЉŸ¬gy>ÍŒ« ñ#ö¨  ¼© Ì© žœTé!‚Çcܽ¯”ÞQ¹\ Ï¡ô ¼© Ì© Té!‚ÇcÜ>’ñúÆ^×Èí ë Té!‚ÇcÜC‹hBTò… Pô ¬­ýTé!‚ÇcÜ9ÒÆËu†µ!$& $" "%#p"YùÍ­uAå½Q)õÉue5Õ©}q=ݹI%íÅq]1ýÑ¡yi9 Ù±yEéÁU-á€"˜"M|"ñ”"x"a"t"¥Œ"m "
ˆ"µœ"}„"!? Ö©í ˜@ºUû©Jk"äƒO÷")À ^{G!öBã¯!ü¤Èûf ÙRN[!ÈuµØ!Š(ÖwšC" °|$0Õ|>é!·V"Êõ­1V óÉ
!¸ezÆgŠ3"  l>KÝ ˆ0ª¥Èq! Ål
.Ù!ºåƒ !öpky7!æ2ÓõŸ!§Fì¸`"/ ÆBEë:["Ôs?çë° N°4ODHT ª·Þ—dhÿd'E½TW•bjkDw"Fs”*«„õ„àì’ë:‡³ôî—äã(0mé×ùV÷è²pw…HG¶Fq­'DqöâÔâ äÎ ORí½Àæ8.kò? èHL70Na4 ²ÓtN¡&&è…q
R ¤¹}•ô?¦N"WÀ‘è#T^dêeoö¶»Á`FrrÕÑf_þÂ…º°ðG1F¡ePñéIh».âEJ| j‚¥úQp¶‘–€4*—éâišXcÿªÌdã›Vìß¡»=«“Ö (oTq;?F@=.pCìƒ0¸·˜¿uŠ!ð;oÚ"x«!¶%•¹ª>ž·Æ4"$¶nSÅV5Û%4LªC$²W&H`¸YD\ü3&ÚíFdUÈ(
-;¾gŸ*v-4pf¾Ë+"Ü–«aèã->i¡N §ß2ž?>Ð"ß`2dTV´Ê5àù.>3‰w>7¶´@Až{g: —ø
1>®õ<ZÖ,üS|?ÎÌo€§Á¾@`$뛘BL¤ÉPôð ~BÂP†{ EDbÇÐm>9SIÔxe1{ovJ•ô#ê¶Ï›KŒ¤æ(EìØyKÀžf¬vùÿMpÌ*ýÔöNTš[ѵßOD ÁZò½}Oô³­8„PdºŽ†.€]M¼^JYªRöÑÿàÝTð‹´uàþ¬UìÏ„¨ªVZhy Rný%ÕW
G¹P´Y¼^5&YbºRßOn‚ßöÞùTV=ºlœ„IŠÞ62‰…]þR
7à„ ]Œ ¶B5@A^Ø|ÄwôïM`ÔÎîQÞ¬'MaÔ-úMžaÈ5y½ëdÄL]œy¿[²ÔØbˆaÍÀðèC²_BÐíâ}fT¹ò³ÐfHUËñ_Ñg\ÂÂ9Yñ­i†Ïÿz;î•^_4ê>d…zñc·áB—8ÃYXLÑGµ•¿âS]vUm“O8]Xá¶Z;*Éòo
ím(9~(pbûÂHC â=pâ~‰±ó¿=!r„UMiÊ]åøpîK÷'¡ƒ²Îo€9v‚ìSïˆu¼cÚìÙvxÜ»ÿ²ÕØ*nļĕï\>j2.d©Õæï^IuîSIQ¦zPUÈÒz˜¡º+¡ºz{|ŠžW55ñ/ñzt)oNåh°¨~fMÌŒ¬7ÔÀzú=ª[Xƒ é{ÆZ°bå´’ÄK¾E4f"\ß³ïOú€M<HyþžGÉI6$8ƒìÐʯ…@)~¼az]†H¦«„uד³‡j‰XäÙ9ãˆþ½h§M:ŇQ<O·Ë*¯ŠLßÕÚu¯»‡þ‹Á…aáÏàz(ô¶†2Õ”Øð§ñj°¨šiL¡dôg)Û4þ^muêÃŽ¾€”³Ó,8UØΨ:}§•´ï<L¡z.z]ÏqÅ: §•À
—$DH=žZšøNž¬ \¼š/Ó]9œ»±œÊØ×`YsçýžnÒûñ!…ŸP¬ï_óHí ¤D¶”€Ÿ‚‰¤ñç˜`¢x“ª\v+¾=£¬.fæúëµ ¤çS}]=
×¥¸Éµ6³›àÍ¤Úæ“Wõê/§’é)
4¬|œ¨¢¸KÓi§Zá´Píõ>1ª&™Q#¬D@Á«÷
üäá ¬P× Ø}R¬Zcbâß–éé®f e‡‘ç¯Xö­g¤Ãì®Z¾Ì³_8®"ê‚î•ĸª”ua5(u³p#¨!ú[Lå´ªDì¥Q
´üϤàû§O²âR +ï:u“·¸Š›.ýðfÖ¶êÞè?]¾†Â¦G›vÎ×xº*Ó?sÂ&M»
ÞõÈ#¦¨·¼4ðчXsºîʽ‰bæ.c¾ãÐRnÝêç Ž”›Õô§~G÷¤ÄG)Á²Q¦cO˜ÄóÁn·ÝŸÞ¢*ÛØv<¤ KpÄ:)£DÄ1kÄœôæz벓Ænï`-WäÇ" d1ƒuJ¬lÌÝ¥3gP!³õ §âQn&ËnMµw<Ëâ)çó*P¬Í&œrñïÍÔ¤!ÑIN1˶}}õ8´ÕfÐr'ó7òU̬޳ŽÓ¥2:ÓØY«U Ôºd-´=rtëØª]OžCŸËØ„ë"ðc”ìžÛÆIIÎ z+ÜÊ’ÃÎ6Ýj8š|‚/Ýö#r×’î-ú߸; [˜¡Ý84+oõÄ•ìáÜ`»¼äÙ6âDË&FNob«ã” IA¦IKKãæl9€óvàå\dGûÖä(Öq<XòCå( ›lçöw¡á­Ls§ŒÐéÚ'¾KN‰2@íÈVßG{¸ Ðí„°K:‡cHßïâ>(‡Ò,~ðÄæöcñ*Rq\tdõò ‹â˜'WÀô¦þI`\“ô6^93Ê~Ï.öÄ ÄúM÷Ô[1?îà›Yø´@.hà¹Pæ÷nÖ¨ƒÿ{}^ú`§É”ĈøbBc†Á^)üõŽáJýl3³î^fþrаÒõ<aÒïÝZæCµœ’’@õ¯Vfÿhqiw…4D)t¶h‹²3MìÚ³§bpÓ
;c
"‰»À õYEPƒÙh
YW(7¨"bê¥ÚÕØM²îJ
ƒ-i–ÙMe_ÈŒª]
ø-UŸˆöv×…‹d/¦F@êQ%Õû|2˜2½Ö­½²|Í@B*&‹ˆ‘e SF~wu:ì7«ÀSòžš­ñQƔՓÚ3£ßvb I†˜¯(¸·?!ñÆÖ/okÀÎÆ°“,ð"k­ë²O.4$5»0åX‰à$càWè—)c$
&”i‘¢ä…'ÛG: $þw%)£²€Çæõ× mð‹£$dÀ+Ï]-³„]D,3JɉiV-?} Ò@ÃN.û#6É[x /¨ººz±R0ëE ¡Ë0-1wÁ, àëð
2ËÉ÷uÒ°T3©/;¡,¬4—Æ5t#©ù5{`$"Ý`6·óÏØhjA 6’äC£õµ×4OÕ=HÇꛩ:õ8hk^™ëO;åNE—¹„ø=ßÊæ{c°L=>±Ð=`I€›?]ì§•Ý籑=Ac|þ"hz6?‰žNHñu»v=FIëÊž0pD·LJGó¶aÕ!šøHs»kH£ÌqMÇÍuth!ÔOñ<î-DP3âxé}ÎjQ=²ñW/½É’R×ËY÷¸÷OŸ#Ÿߥ]ƒT+Ø=ÛØ‹¢xU&hˆg½%åV=—f!E\ UUÉáÊ|¦oXQ$ d´[- øéN[f*/q%[Ó?æ¶¶aÙÃj%½”Ýaa¨\4þñ.
bãáWFÄzƒÿbgAØÜ;àmgѦd!ÅgÕf²ì¢h_ul):(°llûZàô
½†€q ëÔ­Yð_ârë¼ÀýÁßBtÏJ¢VÊwxw“âux÷ϵïxçs4Ôrž3
z ­^M\ê5/}M¤ËXY’Î~£Ñ5ä²ûŒtÝõ€ú¦ËB¥í+Té!‚ÇcÜ,&«‚³£l>ˆ¢„=1ËU¹Œ¶¶‚5èÚ‰˜ôˆ$†KÕbóiþІ é¤ÀŠˆ“(Eld „+ÒöP…=­¿^iü#>ŒgnxSѾ‹ïhTÁûE¼‹¥ùºß›¸‹wëC
§º
í‚»1Pc‡jŌնpÕ é(‘;<tꑽõŸ`¹“ÔÇn‚Ζ :v©‘}—c|ŒßqÚ sš!ñÎ_j»›