Files
boc/aamos-ledger-rust/target/release/deps/libbitflags-ec116a54fb05b2cc.rlib
T

1518 lines
254 KiB
Plaintext
Raw Normal View History

!<arch>
/ 0 0 0 0 1502 `
½¼½¼½¼½¼½¼½¼½¼½¼½¼½¼½¼½¼½¼_ZN67_$LT$bitflags..parser..ParseError$u20$as$u20$core..fmt..Display$GT$3fmt17h24e2e0add3520acbE_ZN8bitflags6traits59_$LT$impl$u20$bitflags..parser..ParseHex$u20$for$u20$i8$GT$9parse_hex17hf9f8ee61b536b5e7E_ZN8bitflags6traits59_$LT$impl$u20$bitflags..parser..ParseHex$u20$for$u20$u8$GT$9parse_hex17hc1b8d93ac948b34fE_ZN8bitflags6traits60_$LT$impl$u20$bitflags..parser..ParseHex$u20$for$u20$i16$GT$9parse_hex17h82a6af14986a6b07E_ZN8bitflags6traits60_$LT$impl$u20$bitflags..parser..ParseHex$u20$for$u20$i32$GT$9parse_hex17h59b7be0b0a6751efE_ZN8bitflags6traits60_$LT$impl$u20$bitflags..parser..ParseHex$u20$for$u20$i64$GT$9parse_hex17h3f33b04c9bf61591E_ZN8bitflags6traits60_$LT$impl$u20$bitflags..parser..ParseHex$u20$for$u20$u16$GT$9parse_hex17h0ead541e317dfd7cE_ZN8bitflags6traits60_$LT$impl$u20$bitflags..parser..ParseHex$u20$for$u20$u32$GT$9parse_hex17hb796ce851837ea28E_ZN8bitflags6traits60_$LT$impl$u20$bitflags..parser..ParseHex$u20$for$u20$u64$GT$9parse_hex17hecbda657abce8990E_ZN8bitflags6traits61_$LT$impl$u20$bitflags..parser..ParseHex$u20$for$u20$i128$GT$9parse_hex17h3297c06f0e22c721E_ZN8bitflags6traits61_$LT$impl$u20$bitflags..parser..ParseHex$u20$for$u20$u128$GT$9parse_hex17hf99e4edc4c9f4a94E_ZN8bitflags6traits62_$LT$impl$u20$bitflags..parser..ParseHex$u20$for$u20$isize$GT$9parse_hex17h1a7a6a9ec1e727fdE_ZN8bitflags6traits62_$LT$impl$u20$bitflags..parser..ParseHex$u20$for$u20$usize$GT$9parse_hex17hb01fa3459238991eE// 66 `
bitflags-ec116a54fb05b2cc.bitflags.b59d097ab52816eb-cgu.0.rcgu.o/
lib.rmeta/ 0 0 0 644 243424 `
ELF·@@GNUÀrust
º²#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  ç
ùT4Ó ùMà÷ƒšÏk®¨Ö5ÚÛ"ùM**î,÷-ƒI? Ð{Û"ùM55Å7ù8´€²Ü£„¯\¥¿cÓÓÔÕˆ@ ½æQ\eÎ.¿cØÙÚÉÛßÜ÷@ÝÞ÷@
F¡ìÁÄc¹$¿cáá«ãÐ fä»fùU%%Éób9Û"žž\˜&\¢&Y˜&Y¢&¡¢&¡˜&žž\ä&\î&Yä&Yî&¡î&¡ä&žž\°'\º'Y°'Yº'¡º'¡°'žž\ü'\†(Yü'Y†(¡†(¡ü'žž\È(\Ò(YÈ(YÒ(¡Ò(¡È(žž\”)\ž)Y”)Yž)¡ž)¡”)¦Û"¯Û" &1*<ÓߨåádÓèëüÿ¤§¸»ÌÏîñª­¾ÁÒÕô÷ˆœŸ°³ÄÇØÛúûŽ¢£·ÊËÞß©­ùM¥¿cÄcž \ <Y <¡ <¦<¯¬Ç

!Û"(ü­S  Û"6 ÿüþˆ§" Û",è"Œ÷8Õ,©üá8üÀg Û"Ç”)üÇv  Û"ø ¼ÃüàãüÙÔ$Û"§"$¸ 
Ö%,Û"Û"è"À÷%)š-xü,€4‡L;
Côá
$Û"ZL>o ˜N  Û",­NMGU§"?”/:Û"9Û"8è"÷”/ýÛ"ñÛ"å÷rwš|ÈŒ¾è"$
ûMè"3 ÎQ¼¸qLÛ Û"Û" Û¼Û" ú
 š  Û¼Û"
(„±ü·
!è"Û""C
Û"´·

K   Û¼Û"ü³
 üô
0 ܈ 
¤ˆ   è"Û"'Î
Û" 6

4  ¢  _ý
Û"
m  ~ £ 
üï
6 Û¼Û" ¤  º  è 
   ¡ ü…œìÞüË=%Û"\Â
 Û¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙÛ"”› §"LÛ¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙô3R è"Už)Û"ÐþQ¿- Û"äÛ"}é¿-é¨flagÁ>ñ2К5«¥6+Ô6:ü“!
÷¥64­6Ô6>O ³üÊ!
R¥67vÔ6?Q êü¿· Û"|Û"”/¿”) õüüì!è"¿-Û"QÓ9PÛ"Ó9÷,[³|Û"”/¥6ŒÔ6¥6=Ô6LÛ"´é Û"®”)­$´è"”/Û"4•Û"L ÷"š& 
Lÿ4–É Û" ð”) ¦õ$§è"ó”/ñÛ"ïÛ"í”/µÛ"©Û"÷#š( Û"ˆ%Ù¿-æ è" ü’® Ä©”/”)•Î@-]Õ@- /̆ ž Û¼ô3 ËW  1”)”)ƒ ”)Lö3Uç,
-ì,
¥ã†
  
˜&­é(
.´›%¿  )\ Û"œô2 ¥6 4ü™/
\™  Û"Ì® 
 Ô6 %M  
Û" [ G
 ü¥#z

 Ç  üÜ4
Û"Ìö

Ô6 %M6

Û"[G
 üë%z

 Û"ÌÅ
£
Ô6%ü¯0Ç

Û"_Jü¾! Þüþ(n
ö3ÌŒ 
$Ô6$  %C  ¥ üù. Û¼ô3 ¦  µ 

%,¡Ó Ú ¹H
N
Ð4áÔ  
ß@-ý·A -
ý²A&- Û¼ Ö%
×A-
…B- ÀÛþJLt†Û"nš5-T•´pmÁ Û¼ô3÷) üßõ üÂþüé×ýЗ,üsÖ%”)l´ý™@ó-ŸkÖ%MΘ,üêBwÛ"4 ý¸,D
Ø|ý¾(F
×|Âý×…¨
à|Uî(
üç;xÛ"<ùewÛ"4„ Ì8”õ™9Û¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙþJd”)RþJÎ
¿-¿ö3\›Ó9¿- ¿-Û"ñ¿-ƒÛ"rÁ Û"Û"ÿô3 ö3\ÿÛ"”/ñÛ”)ÚþJÉ”)*šD}é(
#ù8¡´¿ š5ô¥6íÔ6®÷EÖÔ6$GLÔ6¢žH}Ô6-
ÚsÖ%f
Ús˜&Šü¾#M *Û"Dä#|Û"”/”)$0ü˜#yº#$¯#P|Û"”/ ü¢%‚Ĺ%T¹% ”/DÈ%”)E C
J
 ` 
r üÓ&7Óö3üá&(œõ& u
Û"¤¥6
dõ& 4'HÇÔ6 Pa ˆ'   ‰'üÎ&= Û¼ô3 Š' ™'&£'¸'e!d
bi ` Û¼þJZX Ð%$±%ÛþJlà%”)”)Ø”)|¥&Tª&¤Ýö3m k i  šDb Ž }ç,
U”)
õ,
¬Ü ð¤¥
b 
ˆ$®' Û¼ô34
üï$ÉüÒ%ÒëüsÖ%”)lÄ%æŸkÖ%âü­JyÛ"9ÞØ|Ü×|
Ùà|Ô#wÛ"4Ù&äxÛ"<ú&Ì8”…% º#L÷$šN®”)œþJÌô3_ö3\Ô&Û"VÓ9U¿-0”/Q ”) þJý
ö3”)n šDDù8Œ]¥6ÅÔ6Ô—Ql £QŠ üÜ)" Ñ
¬$%d*
Ñ
¬$,*4˜*üÂ)g 5¬$ ¨*¯*;ü“)œø#$³) ¬$,¥)**î,÷-ƒI? Ð{¬$î¬$}Ò»TyÍ[õ[õTÕ+î\ø'Ç+˜'Õ+}âÙgÑ
ûMî\EâÙg5ëÙg< Ì+Ûö3¬$ö3 Ï+ÛØ^¬$¬ú+Dú+ ú+

$Ñõ[
'  4ü+'È,$Ò,ÑÛ¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙö3Ü, ² ,
L†,  ©]éÑ
·ß©]©]ü ;  Ž,  <©, Û¼ö3 ¾,
F L R*< JQ4bi
 
ü”+Èn{?/¤«ýà…YgÃNî\Dà+ý’O,dÏL î\Ñý²ÙEgÌPî\é ë_”ª+ ø#Lœ+Îc*Û¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙØ^Už)iö3#¬$ ò ©]õ©]ýâ\÷ûdG¢ù®¹x±ekõ[Oø`]¬$¬$¬$#œ^ì0ÑÑ”õ Ñ
ŒÛ""
ø(
ŸH(ž
~Ññ2u#sÑ$
Ûô3ö3
  ¼Ê



Ñ
ëbÖ
1Ñö3,Û
„Ñ
 à

À)Ê
 %ã¶  Uݶ %$
Ñ´Ž  

ÑŸh
(  |•  £ 
¸ #"# Œ"#'&%ž6L… ö(Û"¼‘ Ñ¥6„‘   ܱ





ŸÓ9Ó9&
P
Ñ
¸ßÓ9Ó9cT
y
 Ë



¼ï



ÑŸh(Ñö3,€
„ö 
À-ï
&)&)&)(´œ



ÑŸh(Ñö3$­

 ±
¸
)/)/)+* ×

à1½
,Ç5,Ä5,-,U
\
c
 ß
Ͼ
ÑÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
ÎOŸÈŸÈ ÈErrorÁ O˜éBL ú

" È
4ÑSbÑh"v~ û
¥©"ü–åÅÔãó!r
¼ 
 Ì!Ó"EÔº! uκ"!Ñž)# "•õº Ñòn,"3!ÑD ˆ ü²
;
Í#  Ý
$ä
%¡%$%%$Ñž)¼% %™&Ñòn1
%8
$ÑI#| X

â
&-†
ò'ù(;,'8,('Ñž)X, (6-ÑònJ(Q'Ñ
b
&
ü× ;

þ
)
*+Ô2*Ñ2+*Ñž)ñ2 +Ï3Ñònf+m*Ñ
~
)
ܽ




Ñ
D
Ñ
ZÓ9¥hUFŒÇ
Ç
,
×-Þ.Ò8-Ï8.-Ñž)ï8 .Í9Ñòn/.6-
nw."\
,
-
,
Ñòn¯¸/"ÇÐØáG;7üÌ ¯üæ •Ž 
 ÄÊ
   ¼Ž  ü ú.†

 
Äï 

 
¼œ


 
ä½
å ÏL™92
ß ÌPè"F
ý–¶Ä÷\ÎOÃoŒ ýö¶!ý¥·$ýºü\ÎOÃoÃoÁ åëºýáè$W Ãomùºt÷\ÎOÃoj n""i""d
ü\ÎOÃoÃo ^%%Z&ÃoU%[%Û"\ ×
÷\ÎOÃoHÑ))Ì))Çü\ÎOÃoÃomÁ,,½-Ão¸,(
÷\ÎOÃo#////ü\ÎOÃoÃoE223Ão2
÷\ÎOÃo@{55w55sü\ÎOÃoÃohn88k9Ãog8/òn´×¿-¥h½ è" ™9o Ì8Z ž)n ö35 òný  ¥h Ö¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
ˆê)?ÈXM´­ÃoaònÜ ÷Ü ‚€]Ó9j ¿-D :  Ó9= Ÿ2 Ó9: òn«
÷«
‚€ònG
÷G
‚€~ònŸ¥ht‚€ƒ ž)-ö¶ž)5ëºòž)"ž)%%ž)2)ž).,,ž)G/ž)C212ž)\5ž)X8F8÷ÜwriterÁçfirstÁ¯ùùLÐ #Ž ÛÑ‚€¹ÙÑÎOŽ ã Ñ‚€¹á ÑÎOš
Ž íÑ‚€¹ëÑÎOŽ õÑ‚€¹óÑÎOŽ ýÑ‚€¹ûÑÎOü /
ŸÓ9Ó9ÆfÌ8âŸhןh<Ì8ô¥6¢
»k
Ÿh× Ÿh` Àwè" Ì8è" Ì8*è"# ¥h) ¥h/ ¥h5 ñ2#„›ÑÑ
~Û"0ý—Ñ&
Ñ
¯}
2%—Ñ
ÑŒ‡©Ñ
ýœÑ!
¼„ª Ö¿Û"¹$ ¹ÑJý¬½¿
Uã½
-è½
! šD¡!&½„¾
 Ñ
¥zÑ|„¾
%–¾
ˆ¾
€3Ó1nôz–   ËwËw
SplitInternalÁÎw¹¯vÏwþ¯vÐwmatcherÁ¯vÑwallow_trailing_emptyÁ¯vÒwfinishedÁ¯vÐÐjn'ç|tinôzÑ
Ûw Ê1nûz–Ñ Ûö3)ц‡ ÑŒ‡
3­ „´ Ö¿Û"¹$ Ã ÅÆ!ìô Ö¿Û"¹$ѹ$Ñ8!¼Ä ­£œ
$
%&ÝÜ›á#!"& Ñö3šDýŽ’ Ñ
Õt˜&"Ž’á&}®’á#墒áü /.%üŒ2.UöŒ2.ü°Ì
ü¾36 7%ÍŒ1?6UÇŒ1?6!" ü d‡ü‡ Ñ
Û"1\œ” ¦Üø3Ççl ÑÊÙØâõü´y!!! šD¡!‚!­l ËwÑ”)ÑÑ
ê¾

ý¦½Æ
 üÏ
ë¾
]dW n€{ y!!!"
šD¡!!"8! ­åœá%&­ô·
$'%„¸
$(
$(
ö·
$)±^()
¥Õ˜a&*ýÉ7#a**)%ýú7Ba++õ”8a+,u”8a+-…Þ×Z.-( ˜&ýÇœZ/,-%
±8a+-ýî#)^1+ œD,*
»8a+,ýú7Pa+'+ 
É8a++¦&*Å$)
ˆ¸
$(½ò·
$$'$'ýÉœ Û¼ö3$
«á#G&N%U$ Ûö3ø4…K
Ô…Ñ
]Ó9 
#j#¬&³%º$ø6«Gü«F”«
Ñ
ŠÛ"
 ,ð#4 Ö¿Ó9¹$ѹ$Å.Ñ/×0Ý1Y9è.ô/ú019/ˆ9/ 
©·91¹$5·;2
;2 Ö¿Ѐ¹$1Õ¯·;
•¢Ö¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
Ѐ¹$Ó92
È·;2Þ1å0ì/
[ט  3 5Ì<3É<53Ñž)é< 5
ïº<4¹$ß= Ö¿Û"¹$4 5 3 Ð
Ñ
ù¶90«Ó9Åÿ¶:
•¢טÓ90Û1â0é/ü…K
lÓ9w
ÌßÑÔ6 U†1? Ö¿Û"¹$ѹ$7!6 ð!8(9XE9¹$UG:\G: Ö¿Ѐ¹$9SG •¢טÛ":ÿG:Œ98[ט»
;Â
=ÊH;ÇH=;Ñž)çH =þH<¹$ÚI Ö¿Û"¹$</
=6
; ûÑ
åŒ1?7ÛÛ"-ëŒ1@ Ö¿Û"¹$776|œ8£9VE8«Û"SF •¢טÛ"8Ý9ä8Qü«GlÛ"Ì+ 
JK4ü—¯¬³üîÀüžüܦüê˜ÁÈÏÙ
ßæ í¥ýòÐQ
ª}4‡#&Ø|6&×|!I&à|Y&ý伎
Š}6&×|
I&à|Y&ˆÏLüÏüÏýÏSplitÁ€Ðˆ¯v ÁÀ³UEÝkù ùn¼zS–‰Ð
âª}#&Ø|6&×|!I&à|Y&ü½9WcÄøýЛn
´}ö3”Éý–›œáÀ{º ýÖ‘¾{µá›áI& à|U—’á I& à|U³’á I&à|Uêœáý‘µ
è|—£—£»™£¹< =áï_å”)ýלýã–Ža$Ãy? $ýµ—¼a%%ý«Ï>Z%˜&-Ö—a%ýÙk^'µœDuÕÏZ'ýÃ/— a&£yz %ý•0Åa))ý»7™a*)_*˜&-Ù5a)Y,µœDU,ý®×FZ+˜˜&Eš8a)ýö‘ø
Z+ý˜&}£8a)ý»µpN+Ę&ä )ýà"¹^0·œD˜N0ýð‹àç[Ó9¹$¹$LÛ"º'¹$¹$ ö3/
u22¥«22ü¨&4LÛ"º'¨ލ2üé3˜5_ö3ü¬"5ü¬4Õ66üÇ4º76´÷\Ó9¹$® ¯99«99§ ü\Û"¹$¹$Ö ¢<<Ÿ=¹$<ý¾‹ã1ÈTÛ"¹$MÛ"º'ÎO¹$ލæ
…àŒ1??üÉ'?MÛ"º'ø©ލ1?üÞ6œAaö3üÌ$Aü£7×BBü¾7¼CBš÷\Û"¹$F
EEEE
ü\Û"¹$¹$n
ˆHHI¹$H>Ö¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
Û"¹$¬Þö3Û"íö3dÛ"sÓ¢„ÓÓ¢±ë_¹ž)¦ö3Ûö3ë_ ö3° •¢˜¢™¢lš¢ˆ›¢œ¢[¢ˆe0<#˜טÓ9ò Ö¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
Ó9¹$? טa
Ó9l •¢˜¢™¢lš¢ˆ›¢œ¢[¢ˆe0<#˜טÛ"g ¿«f ò7e טÞÛ"ÎONÖOmÛ"ó”)y!šD«'º‰å”)á®Ó®Ó CharSearcherÁ°ÓhaystackÁz±ÓfingerÁz²Ó finger_backÁz³ÓneedleÁz´Ó utf8_sizeÁzµÓ utf8_encodedÁz…]àdt‰ÅdšD«' º‰$”)y!šD«'Xö3ýΜ”)šD* Ò”$Ò”$”)¹—a%”)=¿7a* œDT)S)S)ž)-2ž)69Ó9Ô 9¹$Y
9טJ
9ž)L<¹$I <C <ž)=àŒ1?Û"
?Û" E¹$œ
Eט
Ež)H¹$Œ H† H inputÁ parsed_flagsÁ´ù`ù8~ ù8§
parsed_flagÁ\¢ù8j ´Ž y
¹ˆ
Ž  ¹P
_â†Eú•ŸÔ6¢ ×–W.Û"Û"†‡=£Q¡!äˆs
ñ¾
£Q¡!ÞŠ†‡f£Q¡!£Qy¹G
øÒéàˆ%Fö§
Ïö3 €6í©
 1ö3 ù8üÉ52ѹ$ÎL$_ö3ÿ¹$«ö§[¹$ ©ù8Ô¨~ö3ª
_ref__flagÁüÀ84ѹ$ðMâÆaö3ÃÀ½¹$Ëí©ù8Ш3ö34À¶ ü‘$Ñü’#
Ñ¥67Ñ
ˆÛ"EW ´yÑü‡7Ñ
GÛ"¥hÉI* ½ ¿À"ü‡¹>NN1òn´Í¿-¥h¿-nÛ"`Ó9_¥h¨÷;™‚@˜¥6º¹©ºÛ"çÛ"ì¥hñ üÃ3ä٬٨8Ù¤Ù
Ñ
JÛ"*7
= C N*
K*

Ñ ôѺ¹¢´ õüÀ7 Ö¿Û"¹$ ö øù 0üÔ¥o ¹$l
s
Ö¿Ѐ¹$ j •¢טÛ"

p w ~
[ט¦­è&å&Ñž)' ¹$ø& Ö¿Û"¹$!¸wt{g 4 «Û"1 •¢טÛ" ˆ  
² ¹ lÛ"Î > áøÑ¥6Q ƒŠ4Å#÷\Û"¹$>À#¼#¸#ü\Û"¹$¹$f³#°# ¹$¬#¿«¬‡ö3Û"½Ó9¼¿-¼Û"Ä®¿¿«¿טCÛ"çž)*!Û"ȹ$Mט>ž)@!¹$=7)˲ˆŽ œ¹D 6€½A¥6fº¹vÛ"Û"š$³!ÑDÁ!”Ì!ÑÆf,Ì!dÒ!Lõ!ø:ä!ŸH:õ!.Ññ2¨.´.Ñ$é!Ûô3ö3,":# ¼¡" 4¡"

ÑŸh
(Ñö3,²" „¨" ·"
À;¡"¨/ ¥/lÎ"Ñ´å" 4å"

ÑŸh
($ö"  |ì" ú"
¸=å"20 /0)œ‰#Ñòn # o~?MUž#üËÓUb
¨;¸" ¸¿”, ‘,Ñž)±, ,ÑònÑ
( ü‰";
·=û" Ç
Î
--*-Ñž)J- (-Ñòn
&
Ñ
7 7
Sfü£!ûü½!á×Þ<¸" Ä¡">û"  ¼å" ?1ÏL™9!W1ÌPè"5 )÷\ÎOÃo)—)“)ü\ÎOÃoÃo§Ž)‹)Ão‡)ø)÷\ÎOÃoMó)ï)ë)
ü\ÎOÃoÃouæ)ã)Ãoß)òn´“ ¿-¥hL§!è"]™97Ì8"ž)6ö3ýònÅ÷Å‚€rònL÷L‚€nž)„'ž)'p/ž)'ž)˜'‡/
÷¥™‚ª­‚°ùùÐÐ §Ž Ñ‚€¹
ÑÎOŽ  Ñ‚€¹ ÑÎOäÆfzÌ8ÛŸhПhDÌ8íè"«¥h±Ì8ÿè"½¥hÃÌ8è"Ï¥hÕñ2.„„&T—&ÑÑâ†,ˆ&
ц‡|&ÑŒ‡y&v&¼ê&d'„“' Ö¿Û"¹$ ¢'ÑJr&m&j&! šD¡!&h&q&ÑäˆÑ|b&_&\&€?¼'Y&`&º‰È%ÑÞŠˆ&¿%Ñ$´' Ûö3ä'ц‡ Ø'ÑŒ‡Õ'
Ò'?, dœ,„™, Ö¿Û"¹$ ¨, ª,«,|¸(ìÝ( Ö¿Û"¹$ѹ$Ñ8´ˆ* •¶ÿ
‹! Ñö3šD¤%ѹš%–% ’%ü´*? Ö¿Û"¹$ѹ$ ý* Ñ ø@š+G üš+F
”š+
Ñ×–
$§+ 'ü­+3  Ñ%Î% ‹,ø?°'ã²¹{ЦüÁ$êÃy! ! !
 šD¡! ‚! §Ø) ËwÑ”)ÑÑl%s%j% üÏe%fm=b%Šy!!
šD¡!Û ¤µ 
Ó 
Ö¿Û"¹$ѹ$   ß+m!t"(#%"
¹$%#'#,#'# Ö¿Ѐ¹$"##' •¢טÛ"#Ï"'#Ø"ß!@à+
Aà+ [ט$&š6($—6(&$Ñž)·6( &Î"(%¹$ª6) Ö¿Û"¹$%{&$ á+ ÑÐ  ÛÛ"Í
Ö¿Û"¹$  vâ!é" #%!
«Û"#& •¢טÛ"!#"*!K
üš+G lÛ"Æ dì+üì+ Ñ,\€,
œù+V+Êü€&«29ü×'¼üˆ+‹áèï­Ò ª}4ð&#&Ø|T÷&6& ×|! I& à|Y& Î Š}TÂ'6&×|Ú-I&à|Y&?1ÏLÓ¢.Ž ‰ÐBk!ª}4ç'#&Ø|T½(6&×|!I&à|Y&Š cÄá(ýòþ\
þ|ö3Œ*p ¾{I&à|g I&à|c ~_ö3ü¸*:zwÈTÛ"¹$XÛ"º'ø©ލ%ü¸+'XÛ"º'ø©ލ

!aö3ü»+$!""#"5÷\Û"¹$Ã5%%5%%Ž5ü\Û"¹$¹$ë‰5((†5)¹$5('¿«¬ò$ö3,â$Û"
ö3dê&Û"² Ó¢„¼'Ó¢ ë_ ž)Ûö3Ñö3$Û'®x¿«wò7vט£Û"bÎO6ÖOUÛ"Íœ”)y! šD«' º‰z0”)v0ý¯I0šD«'¾±0”)y!šD«'šDð-ž)@Û"Q%Û"T'%¹$Ù(%טÊ(%ž)Ì3(¹$É'(¼8(˲>Þ²V ù5
ù8ñ  ù8$
š³\Œ+Ž ¹yæâ†¬ ×–¹gÛ"¼ Û" Û" ,†‡*2£Q¡!äˆ`1í£Q¡!ÞŠq0†‡P2£Q¡!¹+/ö3Ì„æËö3È#ѹ$ß+Xöç aö3Ýá Þ ¹$º+„æ-ù8@¨Gö3UÀ¶p¦0 ñ$ , ¿c(ˆ0Ñ
‡dÑ
ö3&s3Œ0 0×Yònd ¹$n  c cˆ¢cµ
 `£cbufÁ `àB¤GS
´¼í  ñ$ŽïݱêôŒï¼íIÙí(Á0$8Þ2 ÎO & 2 ¼íoÑ
ùcÑö3Ñö3uz¬8×1 ßÎO &2¼íõÑÙðÑö3Ñö3sx07Ñ
êcNÑ ö3\eÅ0 &Æ0ર·
ònÄŽïͽîÖž)Þ ÎO9¼íB ÂóNÂóݼíæÖóï#±1__self_0Áœó*]Öó¼íAÙðrÖó¼íÌÙðƒ¢òŠ,°4$¸4_ѹ$¢6_v&e&a&¹$$4é
$4çõù8_flagÁž÷Ë4ÑÎOÝ&çõ, ,§7$¯7ѹ$S a ú8a`&O&K&¹$$”7çõ$ø6çõù8Œõ˜÷Â7ÑÎOÁ&çõå üé9%ѹ$”:cJ*¹$$Ú9_*Ìô9 Øe Ó :jc²*¹$hñ$WÌ* î ö3¼í@  Û" ,¼í( ÍÑ
ûcÑö3&Ñ ö3¢Ñ
ö3R Ñ  Òç~ònþJ½î˜¼í
¨¼íñ ¿-û¿-ͱÚ䨼í[çû¼í:¿ú¤Ø áÛ"òvü—[Ö%ö3Û"Ð »C¤ áÛ" ë°v®Ö%«ö3©Û"§ö3}Û"qÐ È»Ìög!ö3¬w&ö3d†þJ &g!ö3[w&ö3YþJW`&ç!Û"¢x`&¿-þJ `&ç!ç!Û"ç! ¡yx`&¿-wþJu¿-ç!`& Ì*Ô*ö3y!!! šD¡!!+Ñ”)9+B+P+÷yî+#&Ø| ,6&×|!I&à|Y&þJÞ,Ì*ö3Þ,”)y!šD«'Þ,î+£Q¡!Ì*Ô*Ô*ö3Ô*Ì*
Ì*
Ø|Ô* ,P+B+P+yî+áþJÞ,Ì*ö3Ô*ö3Þ,Þ,î+ö3y!!! šD¡!!+Ñ”)9+Ð zü… K#&Ø|6&×|!I&à|Y&þJ, ö3 ”)y!šD«'"r£Q¡!ö3¤¶ 
 ׄC¾ É îzì¹þJ·ö3ö3ÆÏüå)Ñ
ŒüŸ£‰}µ‰;~üÈL£‰RŸµ‰µ‰ƒŒü
Ÿµ‰µ‰
|£‰ 
áá«ãÐ fä»fùU%%Éób9£‰,eÅ‘e  
ŸX%
ŕX% 
§ ïíe¼îËè¿*ÒŠ^
emÇš%
ýÕ€$%  ÒŠ½Çš%
 ÓŠ
Ýš%
ý½š"%
 § ïíe¼îËè¿*ÓŠŠ
¯e eÑÓŠ
 !'-Ap¼2iypç2i
IpÉ4iÑÓŠ
üÑÑ
™úµ‰µ‰œÝ1 ïøN˜c¬åÎÌN
  ÓŠýžGeÍÌe e ±  ÅŒý¾ºO  
âe ?
 ¬
äe d ýã1!Z ”)Ap¥5i ÑùpÁ;CiùpÈ;<i åŒ^ ÅŒu¿¤%x ÅŒý®¤%
̤%i  pÈ<iÑý¯Î(% Ñ”)ý¥Î3% åŒ
×Î%ùpÆ4ò i
ÕÏŠ% Mè'O" ¬åÍŠ% 
èŠ% ¹p±@i Û¼ ÓŠØßæíôûÛ‘“ç!#£‰µÑ
£‰ù’Þ$!Ñ”)ùpÍ8>i
 ¬A
½ÄËÒÙàç7ü…!Ñ$üÍßüèÄryý’G,“tÓŠý¢eÔlÓŠ¥ýÜÖeýû·eýý¯eý®W‡% ÒŠÈý²™µ%¯ÒŠÓŠý†~û%
ªÒŠEÌš%
ýŒÌ`N´Óн­eýÚÙN ¸ÓŠ? NªÓŠeýí¯ø
OéÓŠe?1ÏLÄlÄlçÇlµ ™lÈl
end_or_lenÁ™lÉl_markerÁ™lŒœjSžÓгùpó0õi‡ÍÓŠÎùp²2¶iùpÖ2’iùpí4µiý¥.çZâÓŠ1p‚5iý˜@ZÛÓŠÎOe÷1Zù’¨Ú¡!»Õpú8iý¬*ñFšî$Fù߬Þ[ÿÝùß“á4~¸ÓŠùpß8,iý¤R%ûÓŠãªÓŠE³¤%úªÓŠEŤ%ý—ËÉ%µÓŠ1p>i-ªÓŠEÇÎ%ý߈%«ÓŠYp¼@ib ªÓŠEÔŠ% ý´'CO ÈÓŠeÝŠ% `&x£‰£‰Њ Û¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙ‘“Ò‘“Òµ‰pµ‰Yµ‰[ £‰”)àeÕ‹2 ¬UeÅŒ0ÅŒ0 ÒŠmŸX% ÅŒØ
°Œ
åŒp¶2i¬QpÚ2i”)pñ4i”)¡pö8iíåŒëåŒQp—>i‘“‰p¶@iÅŒm®¤%ÅŒôÅŒ¬M  truncatedÁlìùï˜åŒù ˜¬
ù ˜ PhantomDataÁFu\»Ÿ‘“ÑêŸù8]N Ÿµ‰µ‰ |£‰Њµ ÓŠT ÓŠÆ¢”) ÈŽW
ÚsÓŠ
³Öéïˆ%F ü¡¢
|£‰ЊM T [ 
X V  ] 
U 
S  
Õ‹ 
$ "   °Œ ÅŒ   åŒi à
 Þ
ÑÓŠl¤Ñ¢”$4›  ý–,7¦Ñ
óN˜µ‰‰:‘“µ‰£‰î& ‘“ÎO£‰î&µ‰‘“µ‰ÎOî&¾¤‹¤±¤M–,¦%¥,¦Ñý£ý«,!¦
ý ,-¦ Í ÓÔ!üÜø>
 ¬9  6  4  ã  ÅŒ2  .  k 
 ¬-    ýô.e ÄlÓŠ
ÑêŸç

î
õ
ÚñøÑ
~£‰ ÂüýÑÑ+ (÷“tÓŠóÔlÓŠïëçã ÒŠ§ß¯ÒŠÓŠ[ÚªÒŠÖÓ´ÓŠÏÍ ¸ÓŠ
  ªÓŠÉÇéÓŠÂýŠƒªg£N˜‹¤üÖ ý°
ô9˜‹¤å’„g
ýš+¹¦§:˜‹¤µ‰±¤üˆ;ý½Ø¦ƒ:‘“µ‰‹¤±¤Õ£‰µ‰²˜ü¡#Њ¼µ‰ÕÁ÷”)ÑåŒÿeÕ‹ ¬ÚŌŌýÖÅŒ¬°ŒÕ"6|£‰ЊaÓŠ ¯§}¢”t`£‰£‰•¡¨ï£jµ‰
Ì,¦˜
 œâ âg!ö3y!!! šD¡!!+Ñ”)9+¤á ôõÄÝ&w£‰#&Ø|6&×|!I&à|Y&à ‹¤\ ‘“ Þö3‘“”)y!šD«'±4¥£Q¡!„²ç!£‰Ñ¢”´¬ÑÈŽ¬\# ÁÂü£`&x£‰<´µ‰« ±¤/µ‰¤‘“ ©µ‰ÍÁ¦accÁ)±,w¢”ÈŽÉ
Ñ¢””ÄÑ
£‰*.DÑ¢”N Õü¶ Ñ
ùøµ‰µ‰».<B ÛÜ!ü‰Sƒµ‰Á,—µ‰=µ‰Á£‰$/`¢”vª²I¢”X„³ð£‰£‰¼ 
Ñ¢”œÐ”ÑѪ²%)?Ñ¢”I ârÑ
—!µ‰/üÂ!Ñ„³à¹#^d èé!ü“Vµ‰Áµ‰bµ‰?µ‰@ÁA£‰J8i¢”¤ª²o¢”~¦¶„³õ£‰Æ£‰ÌœåÑ
£‰8ŒüŸµ‰µ‰(üå(Ñ
¸ßµ‰µ‰š[- Œ ü³`Á µ‰ýµ‰ʺʵ‰Ò/P韵‰µ‰ï¸DܹÑ $„!ôë Ñ
ˆ£‰/" ˆ!Ä—!„—!L—!$Ñ¢”(4¡!E ¦!$«!wÑ
·ßµ‰µ‰Œ8¢¨ ®!LÃ!  |¾! Û¼£‰ Ì! ø! þ!]ci$ë! Û¼£‰=;Hÿ!Zü¢ ÝüÛ ¤
Û¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙ£‰µ‰£‰@µ‰Aʺµ‰Á
ʺÈ£‰h´RžàÔ»Œ¢”]÷¼l£‰i£‰pÌ•#”œ#\œ#Ѫ²%)?Ñ¢”I4¨# ­#rÑ„³$•#ƒ0üþ"1ѵ ®# ´#µ#!üÄ"qˆ£‰$ï"µ‰$Ú"µ‰.µ‰/Á0£‰9´0aª²X¢”g„³vÝ£‰·£‰½‹!
 šD¡! 
|À& $å& Û¼£‰ÑXOŠ'  \Š'|£‰Њó ð  î 
õ í  ë
 Õ‹ ¼ º
·
°Œ±
ÅŒ¬
©
 åŒ x 
v
ÑÓŠ
ÛáçíóùÿrolÑÓŠ üÙ'+œð'ç!1£‰Ñ¢”dð'4ý'JÑSd ƒ(üÔ'1 Û¼£‰ „( “(O(ÑøOþ& ²(× ¬Ò
Ï
Í
| ÅŒË Ç

®
(
T Œ Ì ”)É
ÑÆÂ åŒ ÅŒ¾3 ÅŒ»·µÑƳ º Ñ”)°  匬 ©¤"¡$ ¬Ÿ"œ" Û¼‘“ÒÙàçîõü$'Û‘“œ§'g!%ö3åО"& 
&!&#&$!(  šD++! •á+," ,"! ,"Ñ”)° ¬í+,%%±Á,-% õ±Á,-#%,,%+,&2.&
..$&$,&ýª/'+0' 0Ñ
#E¸/+$EÂ/+!%Ì/+';
Ÿ+,"@&$G&#N&!U& wýª/,+0'Ѻ'
Õ/+0'W,"&$&#¢&!©& Ë õü
H$¨( Û¼£‰:Š2üØ%Úah#&Ø|TÅ&6&×|!I&à|Y&ýú=e½lÓŠ²
“tÓŠe ÔlÓŠ¬# ÿ
û  ÒŠ¿#÷ ¯ÒŠÓŠs#ò
ªÒŠî
ë
´ÓŠçå¸ÓŠ".
ªÓŠáß
éÓŠÚl‡ÍÓŠœgb]XâÓŠTQÛÓŠÎONL»ÕEBš>:ÿÝ4¬¸ÓŠ.*ûÓŠ8" ªÓŠ&ªÓŠ# µÓŠE ªÓŠ «ÓŠo"ªÓŠ
"
"ÈÓŠ"&w£‰4¬'ý¡žU"ŒÚýUa&ŒyÓ&I&'à|a'I&'à|a'R'ŒœDœDý¼#a'ý”+*†j˜&˜&-*ýÀæ+++ý€ÁU,,„t˜&´+,„t˜&+ý˜,Î+,¢j˜&˜&ý¬E++ýà.€+//`&x£‰<õ'(¿dô%ö3$å%Ïœñ ‘“÷æö3\§'£‰Ñµ‰ÑÁ«”)y!šD«'Њ>
”)ÕÕ‹'¬Ó
ÅŒ%ÅŒ%ýÏ ÅŒ¥&
°ŒÎ&
åŒÍ¬Ê”)Ç”)Ä®$匬$åŒÁ‘“¾ÅŒ»ÅŒ¬$ÅŒS$ ¬$"šDa'”)Ä++š+++++¥²•±Á,-¥² .º'/Ð ^ùS ˜åŒùh ˜¬ù} ˜êŸÑêŸù8K |£‰Њo'ÓŠ'ÓŠU/+˜&”)¢”¥
µ
£Q¡!•¡É(¢¡Â£Q²£Q]è+¢ÏôÂÂÑ
!£‰àÂî  £‰ÑË*üƒ*H*£‰¬°*  ç
ùT4Ó £‰„•*Á,‹*à÷ƒšÏk®¨Ö5Ú£‰Â\Æ ÝÂÔ‚-Ñ Ý$—-¢-ŒüÊ,XÜÞ¬â,Á,Ø, . Ýl7( *£‰M(|£‰ЊÑ”)Ð.üë-e‚(0£‰ì­.**î,÷-ƒI? Ð{£‰ä†._M(|£‰Њ7-7-Ñ
£‰7-`-`-Ñ¢”-‹-- 5£‰®-®-ü0Žü”0hÍ-;£‰ü×055Å7ù8´€²Ü£„¯\£‰Ô²0Á,¨0µá7-µ‰`-ˆ«â7-¢”`-\ß1Ñ¢”$ß14ä12Œî1Ÿµ‰µ‰(üß1 Ñ÷¼P" þ1 „2…2üº1K$Ð1Á,Æ1ʺ鵉ñʺ»µ‰Ã+LÚŸµ‰µ‰¢”/÷¼Â
üñ3  ”ñ3\ñ3Ѫ²%)?Ñ¢”I4ý3 4\†4
Ñ¢”$†44‹4¦ÑÈŽ©FÆÊ 4\•4 Ñ¢”$•4 4š43 üñ3/Ñ÷¼:\$ Ÿ4 ¥4 
¦4/ üÇ2ß
$Û2Á,Ñ2ʺʵ‰Óµ‰ÍÁΣ‰×µ‰ʺµ‰%Sƒª²¢”¢”¾ÈŽ<¢”_÷¼%£‰ö£‰üÔÃ5\Ã5
Ñ¢”$Ã54È5dÑ5,Ñ5Ñ¢”(4×5 Ü5Ñ„³ˆ`¤¨:@Œá5  Ÿµ‰µ‰( üÃ5/Ñܹ Q$ ñ5 ÷5 ø5)üì4Œ
$‘5Á,ú4£‰,5ʺŸµ‰¨µ‰£µ‰Áʺ µ‰T¹
W:Ÿµ‰µ‰¢”¢”Þ„³ ܹ1£‰£‰  Ô“7\“7
Ñ¢”$“74˜7d¡7,¡7Ñ¢”(4§7 ¬7Ñ„³ˆ`¤¨:@d±7 ,±7

$Ñ¢”
( 4·7E ¼7
ü“7*Ñ÷¼0v$28 Â7 Ã7)ü¾6… $á6Á,Ê6£‰,Ñ6ʺµ‰Ëµ‰Æµ‰¢Á£ʺ/µ‰8Á3]¹
`𢔢”ø„³:¢”÷¼-£‰£‰üÅ8%\Þ8$Þ8Ñ¢”)4ã8 è8RÑÔ»[l é8,½8'ñ8-üù7xÎO8 £‰L…8£‰èµ‰çÁç#V¢” Ô»£‰© üŽ:0ÑüŽ:#\¥:$¥:Ñ¢”)4ª: ¯:SÑ\n °:,¸:ѾÑ
š£‰ºEd²: ½:,†:-Å:-Kü·9Ž Ä:4 ÎOØ9èöLÁ9£‰,Ì9£‰£‰ˆµ‰ˆÁ£‰)|H¹
K¨¢”ËÛˆùþ£‰ £‰Â ü”=5Ñü”=#\«=$«=Ñ¢”)4°= µ=SÑ\n ¶=,Ã=ѾÑ
£‰ºEŒ¸= È=,Œ=-Ð=-Kü½<“ Ï=4 ÎOÞ<èöLÇ<£‰,Ò<£‰£‰ˆµ‰ˆÁ£‰)|H¹
K¨¢”ËÛŸýþ£‰ £‰Â ü÷>?Ñü÷>#\Ž?$Ž?Ñ¢”)4“? ˜?SÑ\n ™?,°?ѾÑ
œ£‰ºEÜ›? µ?,ï>-½?-Kü > ¼?4 ÎOÁ>èöLª>£‰,µ>£‰£‰ˆµ‰ˆÁ£‰)|H¹
K¨¢”ËÛþ£‰ £‰Â,ƒA”—AÑ
£‰$—A,£AlœA”ÈAÑ
£‰$ÈA,ÔAlÍAëAü§@ÄÎOÒ@èöL®@£‰,¹@,Æ@ÎOªÎO~+¹
.»3h¥„èØ„»làB
ѯ§,ØB ìBôB/ü—B]˜ÎOªBèöL B£‰C¯§¯£‰
Ô—D\—D$—DÑ¢”(4œD ¡Dd¥D,¥DÑ¢”(4«D °D˜Ñ„³¢`¸.4ü€D2Ñß ±D ·D¸D+; üËCm£‰$ñC£‰$ÛC£‰,áCµ‰|µ‰}Á~µ‰HÁIB¹
E¢”┃„³Ù£‰ñ£‰÷£‰ý£‰
ÔÓE\ÓE$ÓEÑ¢”(4ØE ÝEdáE,áEÑ¢”(4çE ìE˜ÑÈŽ¢`¸.4ü¼E2Ñß íE óEôE+; üŽEfš£‰$­E£‰$—E£‰,Eµ‰|µ‰}Á~µ‰HÁIB¹
E¢”┃Ȏ٣‰ñ£‰÷£‰ý£‰ ÜÊH\ÊH$ÊHÑ¢”(4ÏH ÔHlØHdÙH,ÙHÑ¢”(4ßH äHQѦ¶[l)ÇÑ„³ÑçU[ü³H3Ñ åH ëH ìH+ ;
ü€Hl £‰$¤H£‰$ŽH£‰,”Hµ‰¬µ‰­Á®µ‰xµ‰yÁzK¹
N ¢”ü¢”´¦¶Ã„³'£‰£‰£‰£‰
Ô J\ J$ JÑ¢”(4¥J ªJd®J,®JÑ¢”(4´J ¹J˜Ñ
¹ûµ‰µ‰­kÃ9?ü‰J2Ñê ºJ ÀJÁJ+; üÌIuœ£‰$úI£‰$äI£‰,êIµ‰µ‰ˆÁµ‰SÁTB¹
E¢”΢”ŽÆ•䣉ñ£‰÷£‰ý£‰dçK\èK$èKÑ¢”(4íK òKQѦ¶[l)üÎK&ÑÔ» óK ùKúKü¨KR£‰$¿K£‰$¶Kµ‰µ‰Á&W¢”(¦¶7Իƣ‰ £‰¦˜&H ½Q ÏΘ&Ð ­Qê˜&¼Z%CÏΘ&u8::MAXÁ¢&ø ñQVH »RÏΘ&¢&ø «R í¢&ÀZ&>ÏΘ& 0 ÎW ñö¨  QÞWñQö¨  Q×W  
ù æÇ$ ù "$
I
H

§ ïíe¼îËè¿*ÎOù šì$ ¥Õ%$ Ñ
Ëc ˜& Éž  c cˆ¢cµ
 `£cÞí `àB¤GS
òn¹ Û$  ð  c cˆ¢cµ
 `£cÞí `àB¤GS
ònW òÇ
ÑøžFu\»ŸÂó  ¬ $  
ù »
ý$ ‚È  · $ ò
ù   ‚È‚ÈArgumentÁ„È´ÀbökÏ®ÝWj´ Q“© _űù
 Ñ  ˜&”)§ ïíe¼îËè¿*˜&¥Ñù
 § ïíe¼îËè¿*²¡ý›ùL äÈ
æù
ù
ç¨. Ñ
îb¨ù
ì¨) 
”©   ôW  õW%ø ðV…õ ßæýø$x$ÎbÉžöù °Ö$SG ÉžÙ $SG¯ÉžÎO1 µ$QGªÉžMGýÅ÷ª«c”)”)ˆònX ¥WÉž( ŒWü£P “W ü£æäÈäÈ ArgumentsÁæÈtemplateÁ `çÈÀ `üöMõô]Td& Éž'²¡”)/²¡- »§DòÇôÇ PlaceholderÁõÇ»ÀböÇ formatterÁÀb÷Ç _lifetimeÁÀbøÇùÇCountÁúLjÀb©¡â] å.ʷ𳾟fΞ  ´$ ÉžœE¼¢ž‚£D™‚À:¯§¯§ÀQö£ü£Úü£áÞê 0 –Y ñö¨  S¦YñSö¨  SŸY  
 °
ÊO
:O

ð~ x Ñ
Ëc ¢& ¿«ážòn2  ¾Ÿ2 òÇ
Ѷ ´ »
± ‚È « ã
é ú ²¡ S“© ls Ñ ©¢¼¢-4 ‚£ý äÈùùç¨. Ñö£ÐÀùì¨)  ”©   ¼Y  ½Y%ø ¸X…ø ïÎb¿«,ì9L ¿«æ5L¯¿«ÎOâ/Lª¿«+LÞ«c”)”)«ònX íX¿«( ÔXü£P ÛXͦÙ¦ù ¿«ú»§ô²¡òÛ§ç§¥ ð¡ ¾ŸT Ä«î ¿«†I¼¢ˆ‚£.™‚Àl¸°¸°ÀƒŒö£ü£Óü£Ú¹«Ò ä& Ž øÏä& þ ä&ÈZ¨ Ç øÏä&u16::MAXÁî&  øÏä&î&  î&ÍZ¦ ¿ øÏä&   ñö¨  UÞWñUö¨  U×W  
  { 
•T
T

ðI  C  Ñ
Ëc ä& еážòný
  ¾Ÿý  òÇ
Ѷ 
 

|
 ‚È v
 ã
é ú ²¡ U“© 7
>
 Ñ ©¢¼¢ø ÿ  ‚£È  äÈÄ Ë ùç¨. Ñö£Q
Àùì¨)  ”©  º à ¹ Ü ¸  Ç µ Îbе'² ÿP е¬ ûP¯еÎO¨ õPªеñP¤ «c”)”)¦ònŸ е ü£ͦ|Ù¦î еﻧ鲡çÛ§ûç§eða¾Ÿµ® еFN¼¢H ‚£î *
™‚.
Àcø¹ø¹Àz= ö£ü£ ü£ „µ ª±ñö¨  W¦YñWö¨  WŸY  
_ Y
sX
ãW

ð' ! Ñ
Ëc î& è¼ážònÛ  ¾ŸÛ òÇ
Ѷ ] d
Z ‚È T ã
é ú ²¡ W“©  Ñ ©¢¼¢Ö
Ý
 ‚£¦
 äÈ¢
©
ùç¨. Ñö£y
Àùì¨)  ”©  ©²¨Ë§Œ 
Îbè¼'
ÝT è¼Š
ÙT¯è¼ÎO
ÓTªè¼ÏT
«c”)”)¦òn¤è¼¢ü£ ͦ¤ Ù¦î è¼ï»§é²¡çÛ§ûç§Cð?¾Ÿòí¼Œ  è¼$R¼¢&‚£Ì/ ™‚3 ÀcÖÁÖÁÀz,
ö£ü£s
ü£z
â¼r°''0 Ñ°'&5°'ÖZJi Ñ°'u32::MAXÁº'+( Ñ°'º'&5º'ÛZJc Ñ°' &-ñö¨  YÞWñYö¨  Y×W  
% 
9]
©\

ðí ç Ñ
Ëc °' ®Æážòn¡  ¾Ÿ¡ òÇ
Ѷ # *
  ‚È  ã
é ú ²¡ Y“© Ûâ Ñ ©¢¼¢œ£ ‚£l äÈhoùç¨. Ñö£õÀùì¨)  ”©  ^g]\ kYÎb®Æ'V£Y ®ÆPŸY¯®ÆÎOL™Yª®Æ•YH«c”)”)¦ònC®ÆAü£?ͦ Ù¦î ®Æï»§é²¡çÛ§ûç§ ð¾Ÿ¸³ÆR ®ÆêV¼¢ì‚£Î™‚ÒÀcœËœËÀzáö£ü£(ü£/¨Æ8 NUñö¨  [¦Yñ[ö¨  [ŸY  
 ý
a
‡`

ðË Å Ñ
Ëc º' ŒÎážòn  ¾Ÿ òÇ
Ѷ  
þ ‚È ø ã
é ú ²¡ [“© ¹À Ñ ©¢¼¢z ‚£J äÈFMùç¨. Ñö£Àùì¨)  ”©  MVLoK  Z7ÎbŒÎ'4] ŒÎ.}]¯ŒÎÎO*w]ªŒÎs]&«c”)”)¦ònHŒÎFü£DͦHÙ¦î ŒÎﻧ鲡çÛ§ûç§çð㾟‘Î0 ŒÎÈZ¼¢Ê‚£pÓ™‚×ÀcúÒúÒÀzÐö£ü£ü£†Îü'ÏØÈÒü'ΦÝü'äZòÈÒü'u64::MAXÁ†(×ÔÈÒü'†(Ò©á†(éZöÈÒü' ÒÙñö¨  ]ÞWñ]ö¨  ]×W  
Ñ Ë
åe
Ue

ð  Ñ
Ëc ü' Ú×ážònM  ¾ŸM òÇ
Ѷ Ï Ö
Ì ‚È Æ ã
é ú ²¡ ]“© Ž Ñ ©¢¼¢HO ‚£ äÈùç¨. Ñö£¡Àùì¨)  ”©  
 ,± ÎbÚ×'Ob Ú×üKb¯Ú×ÎOøEbªÚ×Abô«c”)”)¦ònïÚ×íü£ëͦÌÙ¦î Ú×ﻧ鲡çÛ§û秵𱾟dß×þ Ú×–_¼¢˜‚£>z™‚~ÀcÈÜÈÜÀzö£ü£Ôü£ÛÔ×ä úñö¨  _¦Yñ_ö¨  _ŸY  
¯  © 
Ãi
3i

ðw  q  Ñ
Ëc †( ¸ßážòn+   ¾Ÿ+! òÇ
Ѷ ­ ´
ª ‚È ¤ ã
é ú ²¡ _“© el Ñ ©¢¼¢&- ‚£ö äÈòùùç¨. Ñö£ÉÀùì¨)  ”©  ùø÷´ ãÎb¸ß'à-f ¸ßÚ)f¯¸ßÎOÖ#fª¸ßfÒ«c”)”)¦ònô¸ßòü£ðͦôÙ¦î ¸ßﻧ鲡çÛ§ûç§“#ð#¾ŸB#½ßÜ ¸ßtc¼¢v!‚£!™‚ƒÀc¦ä¦äÀz|ö£ü£Ãü£Ê²ßÂ#È(ƒ%Œ%ðÓÈ(‚%º%È($òZ¦%Å%ðÓÈ( u128::MAXÁÒ(”%‘%ðÓÈ(Ò(%½ž%Ò($øZ³%Ì%ðÓÈ( %–%ñö¨  aÞWñaö¨  a×W  
Ž% ˆ%
¢n
n

ðV% P% Ñ
Ëc È( —éážòn
%  ¾Ÿ
& òÇ
Ѷ Œ$ “$
‰$ ‚È ƒ$ ã
é ú ²¡ a“© D$K$ Ñ ©¢¼¢$ $ ‚£Õ# äÈÑ#Ø#ùç¨. Ñö£^'Àùì¨)  ”©  Ç#Ð#Æ#é#Å#Å Ô#Â#Îb—é'¿# k —é¹#k¯—éÎOµ#kª—éþj±#«c”)”)¦òn¬#—éª#ü£¨#ͦ‰(Ù¦î —éﻧ鲡çÛ§ûç§r(ðn(¾Ÿ!(œé»" —éSh¼¢U&‚£û%7$™‚;$Àc…î…îÀzJ%ö£ü£‘%ü£˜%‘é¡( ·"¾"ñ ö¨  c¦Yñcö¨  cŸY  
l) f)
€r
ðq

ð4) .) Ñ
Ëc Ò( õðážònè(  ¾Ÿè) òÇ
Ѷ j( q(
g( ‚È a( ã
é ú ²¡ c“© "()( Ñ ©¢¼¢ã'ê' ‚£³' äȯ'¶'ùç¨. Ñö£†$Àùì¨)  ”©  ¶"¿"µ"Ø"´"È Ã" 'Îbõð''ên õð—'æn¯õðÎO“'ànªõðÜn'«c”)”)¦òn±"õð¯"ü£­"ͦ±%Ù¦î õðﻧ鲡çÛ§ûç§P,ðL,¾Ÿÿ+úð™& õð1l¼¢3*‚£Ù)<#™‚@#ÀcãõãõÀz9$ö£ü£€$ü£‡$ïð,”)8.A.—Õ”)7.ÎF.”),[[.z.—Õ”)
usize::MAXÁž)B.?.—Õ”)ž)=.ÑL.ž),‰[a.z.—Õ”) =.D.ñ"ö¨  eÞWñeö¨  e×W  
<. 6.
Pw
Àv

ð. þ- Ñ
Ëc ”) Åúážòn¸-  ¾Ÿ¸. òÇ
Ѷ :- A-
7- ‚È 1- ã
é ú ²¡ e“© ò,ù, Ñ ©¢¼¢³,º, ‚£ƒ, äÈ,†,ù!ç¨. Ñö£ 0Àù!ì¨)  !”©  u,~,t,—,s,Ù ,p,ÎbÅú'm,ºs Åúg,¶s¯ÅúÎOc,°sªÅú¬s_,«c”)”)¦ònZ,ÅúX,ü£V,ͦ71Ù¦î Åúﻧ鲡çÛ§ûç§ 1ð1¾ŸÏ0Êúi+ Åúq¼¢/‚£©.å,™‚é,Àc³ÿ³ÿÀzø-ö£ü£?.ü£F.¿úO1 e+l+ñ$ö¨  g¦Yñgö¨  gŸY  
2 2
.{
žz

ðâ1 Ü1 Ñ
Ëc ž) £‚ážòn–1  ¾Ÿ–2 òÇ
Ѷ 1 1
1 ‚È 1 ã
é ú ²¡ g“© Ð0×0 Ñ ©¢¼¢‘0˜0 ‚£a0 äÈ]0d0ù#ç¨. Ñö£4-Àù#ì¨)  #”©  d+m+c+†+b+Ü q+N0Îb£‚'K0˜w £‚E0”w¯£‚ÎOA0Žwª£‚Šw=0«c”)”)¦òn_+£‚]+ü£[+ͦ_.Ù¦î £‚ﻧ鲡çÛ§ûç§þ4ðú4¾Ÿ­4¨‚G/ £‚ßt¼¢á2‚£‡2ê+™‚î+Àc‘‡‘‡Àzç,ö£ü£.-ü£5--5¬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.
Á  ÍìÛ" §Û"§"T4Ó 
')œ¹  è"TÒ  ´á·Ï æ{Û"§"üþ$Œà àÛ"§" 
Û"÷EÄŠ·Ï ÇÏ<§"üà\œí /Û"Û"§"
Û"÷$š-üÇ#·Ï ÌÉЧ"ú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.
Á·Ï ÇÏ<è"Ïk®¨Ö5Ú')ÌŸµÒ¾”)LÎÛ"dÝÛ"Üî  ·Ï óÉÐè"!ü$žâ âÛ"è" ©Õ,÷øì€##·Ï ÇÏ<ˆè"$%üÙ\œæµÒÛ"Û"è"""Ç0÷¾ÇšÐìËü³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Òã ãè" ãÛ"" Ü"
%Û"üŒ(''·Ï ÉÐ,”è"()ú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.
Á„ž"++·Ï ¯"ÇÏ<²"º#I? Ð{,-%'ÌÁ",Á"**µÒ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Íì¬$ œ({¬$,Ÿ(ø#€²Ü£„¯\78+-Ô¬(,¬(55î\lÌ($Ì(55©]üÞ( ¥::‰æ ã(™æ,æ(ø#;ü“)$¡)æ æ¬$ø#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è èÛ"¥hònHÖIIH ¸·Ï §Íì¥hÉÐYÓ9Dêb¥hº÷1?™‚LNIKü´\ü¡
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 Õ·Ï ÄÉÐ\Ó9D‡€½˲œU%'¨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.
Á”Žê êÛ"¥hònOÖPPO ²·Ï ¡ÊñÉÐâñðñ
NÛ"¥h÷>]™‚G]=?BDüÔ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Û"˲wa#%üË^üûOJ
Write only the contained, defined, named flags in a flags value as text.
Á„Òì ìÛ"¥hònTÖUUT ô·Ï ãÊñT„ ÉÐðñ,‰
SÛ"¥h÷©g™‚68;=üÁ$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Û"˲Ms¸+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Î-î ¨ònY¨[[ ç-YÍì³ Ø-êb³TÛ-
Z£‰³$è-™‚4î-02”´.üŒ.'"
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
_çõù8mz#%üÞ6:ü‡6RO A named flag that doesn't correspond to any on the flags type was encountered.Á”å6çõ¹$^é
bb^ˆ†Œþ6™†dƒ7
açõù8;{ü½9!ü€985 A hex or named flag wasn't found between separators.ÁTÊ9¹$^^
cü˜: ¹$eÅceü¿:8Â:ðñò ð¹$ ñ c cˆ¢cµ
 `£cÞí `àB¤GS
òònd Æ: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Û"Ð ~» ~üê(üømh
Get the name of this flag.
If the flag is unnamed then the returned string will be empty.
Á$÷ó óÖ%­Þt üt
wÛ"üçü²0+
Get the flags value of this flag.
Á,ôô ôÖ% ôÛ"t út
xÛ"ü­$ü¨{
Whether the flag is named.
If [`Flag::name`] returns a non-empty string then this method will return `true`.
ÁDºõ õÖ%t Ãt
yÛ"ü… &üýƒ~
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¥ µ‰¿{{
£‰´`ŸüÄ"/ü…":7 Convert from a bits value, unsetting any unknown bits.Á”Ç"µ‰£‰{{Ô»´¡üæ#.ü»#&# 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ƒ ƒ£‰ÎO{ …8{Ü„,¨8
£‰$Š8ü·9@ü÷8;8 The bitwise or (`|`) of the bits in `self` and `other`.Á4º9 £‰£‰ÎO{ Á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À< £‰£‰ÎO{ Ç<{Ü„,÷<Ø„$Ì<¹
ê¢ü >@üÖ=EB The bitwise exclusive-or (`^`) of the bits in `self` and `other`.Á4£> £‰£‰ÎO{ ª>{Ü„,Ú>
£‰$¯>¹
‹¡ü§@JüÃ?_\ Call [`Flags::insert`] when `value` is `true` or [`Flags::remove`] when `value` is `false`.Áª@ £‰£‰ÎO{ ®@{Ü„,ë@
£‰$³@¹
»*¡ü—B2üñA! Unsets all bits in the flags.Á,šBˆ ˆ£‰ÎO{  B{Ü„,ÃB
˜£‰$¥BüËC*üúB<9 The bitwise and (`&`) of the bits in `self` and `other`.Á.\»CdÎC£‰£‰£‰{{
£‰ÈŸ¹
ÅŸüŽE#ü¾D;Ô¿.\þD,E£‰£‰£‰{{ˆù ž¹
žü€H(üúEEüÀÄFúüÌFW×Áü¨GC@ `difference` won't truncate `other`, but the `!` operator will.Á.\ðGTƒH£‰£‰£‰{{Ÿý¯œ¹
¬œüÌ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™‚4—W& W8¨ ŸW(¢W8×¥W'¨W8Í4ªW ±W ôW8writeÁ,ÇW ÌW ÍW âW8™‚4Î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™‚4ßX& åX8¨ çX(êX8×íX'ðX8Í4òX ùX ¼Y8¤á,Y ”Y •Y ªY8™‚4Y$ œ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„©Cu¬Æ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å