! / 0 0 0 0 44 ` __rustc_debug_gdb_scripts_section__// 58 ` bitflags-69acfc798c96d00c.bitflags.doteuzai-cgu.0.rcgu.o/ /0 0 0 0 644 760 ` ELF>8@@gdb_load_rust_pretty_printers.pymI!".text.debug_gdb_scripts.debug_aranges.note.GNU-stack.strtab.symtab__rustc_debug_gdb_scripts_section__bitflags.doteuzai-cgu.09@2@"b)bAhHlib.rmeta/ 0 0 0 644 49227 ` rust rustc 1.48.0coreƞ-3375e4f89d420e7acompiler_builtins-f74b197469e67088rustc_std_workspace_core扪ڹ8-5e0675f526ef5c6b^P|S1V3ycoreX,5P#/compiler_builtins]}\-i^_coreb?﷤yebitflagsNw8_0V|__impl_all_bitflagsW !R%y)|__impl_bitflags.ǃ<٢_coreHHbitflagsVV__impl_all_bitflags\\__impl_bitflagsddэrL A typesafe bitmask flag generator useful for sets of C-style bitmask flags.O= It can be used for creating typesafe wrappers around C APIs.@J The `bitflags!` macro generates `struct`s that manage a set of flags. TheMJ flags should only be defined for integer types, otherwise unexpected typeM" errors may occur at compile time.% # Example  ``` use bitflags::bitflags; bitflags! { struct Flags: u32 { const A = 0b00000001;! const B = 0b00000010;! const C = 0b00000100;!@ const ABC = Self::A.bits | Self::B.bits | Self::C.bits;C }  } fn main() {" let e1 = Flags::A | Flags::C;%" let e2 = Flags::B | Flags::C; %2 assert_eq!((e1 | e2), Flags::ABC); // union 59 assert_eq!((e1 & e2), Flags::C); // intersection <; assert_eq!((e1 - e2), Flags::A); // set difference >; assert_eq!(!e2, Flags::A); // set complement > }  ```  b See [`example_generated::Flags`](./example_generated/struct.Flags.html) for documentation of code e. generated by the above `bitflags!` expansion. 1 A The generated `struct`s can also be extended with type and trait D implementations:   ```  use std::fmt;   use bitflags::bitflags;   bitflags! {  struct Flags: u32 {  const A = 0b00000001;! const B = 0b00000010;! }  } impl Flags { pub fn clear(&mut self) {!L self.bits = 0; // The `bits` field can be accessed from within theOP // same module where the `bitflags!` macro was invoked.S }  } impl fmt::Display for Flags {!; fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {> write!(f, "hi!") }  } fn main() {) let mut flags = Flags::A | Flags::B;, flags.clear(); assert!(flags.is_empty());"- assert_eq!(format!("{}", flags), "hi!");0? assert_eq!(format!("{:?}", Flags::A | Flags::B), "A | B");B0 assert_eq!(format!("{:?}", Flags::B), "B");3 } ``` # VisibilityK The generated structs and their associated flag constants are not exportedNJ out of the current module by default. A definition can be exported out ofM4 the current module by adding `pub` before `struct`:7 ``` mod example { use bitflags::bitflags; bitflags! {! pub struct Flags1: u32 {$" const A = 0b00000001;% }  # pub struct Flags2: u32 { " const B = 0b00000010;% }  }  } fn main() {$ let flag1 = example::Flags1::A;'C let flag2 = example::Flags2::B; // error: const `B` is privateF } ``` # AttributesF Attributes can be attached to the generated `struct`s by placing themI before the `struct` keyword.  ## RepresentationsO It's valid to add a `#[repr(C)]` or `#[repr(transparent)]` attribute to a typeRR generated by `bitflags!`. In these cases, the type is guaranteed to be a newtype.U ``` use bitflags::bitflags; bitflags! { #[repr(transparent)] struct Flags: u32 { const A = 0b00000001;! const B = 0b00000010;! const C = 0b00000100;! }  } ``` # Trait implementationsG The `Copy`, `Clone`, `PartialEq`, `Eq`, `PartialOrd`, `Ord` and `Hash`JQ traits are automatically derived for the `struct`s using the `derive` attribute.TC Additional traits can be derived by providing an explicit `derive`F attribute on `struct`.  J The `Extend` and `FromIterator` traits are implemented for the `struct`s, MM too: `Extend` adds the union of the instances of the `struct` iterated over, P+ while `FromIterator` calculates the union.!.!J The `Binary`, `Debug`, `LowerHex`, `Octal` and `UpperHex` traits are also!MA implemented by displaying the bits value of the internal struct."D# ## Operators##K The following operator traits are implemented for the generated `struct`s:#N## - `BitOr` and `BitOrAssign`: union#&, - `BitAnd` and `BitAndAssign`: intersection$/& - `BitXor` and `BitXorAssign`: toggle$)( - `Sub` and `SubAssign`: set difference$+ - `Not`: set complement%% # Methods% %? The following methods are defined for the generated `struct`s:%B&! - `empty`: an empty set of flags&$& - `all`: the set of all defined flags&)6 - `bits`: the raw value of the flags currently stored&9G - `from_bits`: convert from underlying bit representation, unless that'JH representation contains bits that do not correspond to a'K defined flag(M - `from_bits_truncate`: convert from underlying bit representation, dropping(PI any bits that do not correspond to defined flags)LM - `from_bits_unchecked`: convert from underlying bit representation, keeping)PK all bits (even those not corresponding to defined*N flags)+#6 - `is_empty`: `true` if no flags are currently stored+9J - `is_all`: `true` if currently set flags exactly equal all defined flags+ML - `intersects`: `true` if there are flags common to both `self` and `other`,OP - `contains`: `true` if all of the flags in `other` are contained within `self`-S1 - `insert`: inserts the specified flags in-place-41 - `remove`: removes the specified flags in-place.4M - `toggle`: the specified flags will be inserted if not present, and removed.P if they are./N - `set`: inserts or removes the specified flags depending on the passed value/QP - `intersection`: returns a new set of flags, containing only the flags present0SM in both `self` and `other` (the argument to the function).0PG - `union`: returns a new set of flags, containing any flags present in1JD either `self` or `other` (the argument to the function).2GL - `difference`: returns a new set of flags, containing all flags present in2OH `self` without any of the flags present in `other` (the3K+ argument to the function).3.K - `symmetric_difference`: returns a new set of flags, containing all flags4NL present in either `self` or `other` (the argument4O: to the function), but not both.5=K - `complement`: returns a new set of flags, containing all flags which are5NH not set in `self`, but which are allowed for this type.6K7 ## Default77P The `Default` trait is not automatically implemented for the generated structs.7S7T If your default value is equal to `0` (which is the same value as calling `empty()`8W; on the generated struct), you can simply derive `Default`:8>9 ```9 use bitflags::bitflags;99 bitflags! {9- // Results in default value with bits: 090 #[derive(Default)]: struct Flags: u32 {: const A = 0b00000001;:! const B = 0b00000010;:! const C = 0b00000100;:! };  };; fn main() {;5 let derived_default: Flags = Default::default();;8+ assert_eq!(derived_default.bits(), 0);;. }< ```<<T If your default value is not equal to `0` you need to implement `Default` yourself:! const C = 0b00000100;>! }>  }>>% // explicit `Default` implementation>( impl Default for Flags {? fn default() -> Flags {? Flags::A | Flags::C? }?  }?? fn main() {@9 let implemented_default: Flags = Default::default();@<< assert_eq!(implemented_default, (Flags::A | Flags::C));@? }A ```AA # Zero FlagsAA^ Flags with a value equal to zero will have some strange behavior that one should be aware of.AaB ```B use bitflags::bitflags;BB bitflags! {B struct Flags: u32 {B! const NONE = 0b00000000;B$! const SOME = 0b00000001;C$ }C  }CC fn main() {C let empty = Flags::empty();C# let none = Flags::NONE;D let some = Flags::SOME;DD0 // Zero flags are treated as always presentD3* assert!(empty.contains(Flags::NONE));D-) assert!(none.contains(Flags::NONE));E,) assert!(some.contains(Flags::NONE));E,F= // Zero flags will be ignored when testing for emptinessF@ assert!(none.is_empty());F! }F ```FFC Users should generally avoid defining a flag with a value of zero.FFGno_stdGGGdocGGH html_root_urlG Ghttps://docs.rs/bitflags/1.3.2G G9V\VXVVWVVWV outerVV metaW WW visWW visW structWW BitFlagsWW identWWW TWW tyWWXWWXWWWWWWW innerWW identWWWWW argsWW ttW W W constXX FlagXX identXXX valueXX exprXX XXXXX tXX ttX XXX[XXXXXXX outerX XXYY deriveYYY CopyYY PartialEqY Y EqYY CloneYY PartialOrdY Y OrdYY HashYY visY structYY BitFlagsYYY bitsYYY TYY __impl_bitflagsZ ZZ[Z BitFlagsZZZ TZZ[ZZ[ ZZZZZZZ innerZZZZZ argsZ Z Z[ Flag[[[ value[[ [ bitflags[ [[[[[[[ t[ [[[\\\\\ V0 The macro used to generate the flag structures.H3IO See the [crate level docs](../bitflags/index.html) for complete documentation.IRI # ExampleI I ```I use bitflags::bitflags;IJ bitflags! {J struct Flags: u32 {J const A = 0b00000001;J! const B = 0b00000010;J! const C = 0b00000100;K!@ const ABC = Self::A.bits | Self::B.bits | Self::C.bits;KC }K  }KK fn main() {L" let e1 = Flags::A | Flags::C;L%" let e2 = Flags::B | Flags::C;L%2 assert_eq!((e1 | e2), Flags::ABC); // unionL59 assert_eq!((e1 & e2), Flags::C); // intersectionM<; assert_eq!((e1 - e2), Flags::A); // set differenceM>; assert_eq!(!e2, Flags::A); // set complementN> }N ```NNA The generated `struct`s can also be extended with type and traitND implementations:OO ```O use std::fmt;OO use bitflags::bitflags;OO bitflags! {O struct Flags: u32 {P const A = 0b00000001;P! const B = 0b00000010;P! }P  }PP impl Flags {Q pub fn clear(&mut self) {Q!L self.bits = 0; // The `bits` field can be accessed from within theQOP // same module where the `bitflags!` macro was invoked.RS }R  }RR impl fmt::Display for Flags {R!; fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {S> write!(f, "hi!")S }S  }SS fn main() {S) let mut flags = Flags::A | Flags::B;T, flags.clear();T assert!(flags.is_empty());T"- assert_eq!(format!("{}", flags), "hi!");T0? assert_eq!(format!("{:?}", Flags::A | Flags::B), "A | B");UB0 assert_eq!(format!("{:?}", Flags::B), "B");U3 }V ```VV  macro_exportV VV local_inner_macrosVV#V]c]^ ] BitFlags]] ident]]] T]] ty]]^]]^ ]]]]]]] attr]] ident]]]]] args]] tt] ] ]^ Flag^^ ident^^^ value^^ expr^^ ^^^b___ allow___ non_snake_case_ trait_ __BitFlags_ _`__` const__ Flag___ T__0__ ```` allow``` non_snake_case` impl` __BitFlags` for`` BitFlags``b``b __impl_bitflags` aabaaa allowaaa deprecateda aaaaaaaa attraaaaa argsa a a constaa Flagaab Tbb Selfbbb Flagbb bitsbb b Selfbbb bitsbbbbbb Selfb asb __BitFlagsb bbb Flagb b bccc c BitFlagscc identccc Tcc tycccccc Selfccc bitscc0cc \\  macro_export\ \\ local_inner_macros\\#\doc\\\ hidden\\\dde d BitFlagsdd identddd Tdd tyddedde ddedded attrdd identdeeee argsee tte e ee Flagee identeee valueee expree eee implee crateee _coreee fmtee Debugf forff BitFlagsffy fnf fmtfff f selfff fff f mutff crateff _coreff fmtff Formatterf ff crateff _coreff fmtff Resultffy0jjj allowjjj non_snake_casej traitj __BitFlagsj jkjjk kkk inlinek fnkk Flagkkk k selfkk boolkkk falsek kllm allowllm non_snake_casem implm __BitFlagsm formm BitFlagsmmrmmr __impl_bitflagsm mnrnnn allownnn deprecatedn nnn inlinennnonnnon attrnoooo argso o o fnoo Flagooo o selfoo boolooq ifo Selfooo Flagoo bitsoo0oo selfpp bitspp0ppp falsep elseppq selfqq bitsq q Selfqqq Flagqq bitsqq Selfqqq Flagqq bitsq r letr mutr firstrr truerrrru ifss Selfs ass __BitFlagss sss Flagsss selfssu ifs s firstsst fss write_strs st | stt firsttt falsett ftt write_strt tut cratett _corett stringifyt uuuu Flaguuu u letu extra_bitsu u selfuu bitsu u u Selfuu alluuuu bitsuuuu ifv extra_bitsv v0vvx ifv v firstvvw fvv write_strv vv | vvv firstww falseww fww write_strw ww0xwwww crateww _coreww fmtww LowerHexww fmtxxx x extra_bitsx x fxxx ifx firstxxy fxx write_strx xx(empty)x xx Okyyyyy implyy crateyy _coreyy fmtyy Binaryy foryy BitFlagsyy{ fny fmtyyz y selfyz fzz z mutzz cratezz _corezz fmtzz Formatterz zz cratezz _corezz fmtzz Resultzz{ z cratezz _corezz fmtzz Binaryzz fmtzz{ z selfzz bits{{ f{ impl{{ crate{{ _core{{ fmt{{ Octal{ for{{ BitFlags{{} fn{ fmt{{| { self{{ f{{ { mut{{ crate{| _core|| fmt|| Formatter| || crate|| _core|| fmt|| Result||} | crate|| _core|| fmt|| Octal|| fmt||| | self|| bits|| f| impl}} crate}} _core}} fmt}} LowerHex} for}} BitFlags}} fn} fmt}}~ } self}} f}} } mut}} crate}} _core}} fmt}} Formatter} ~~ crate~~ _core~~ fmt~~ Result~~~ ~ crate~~ _core~~ fmt~~ LowerHex~~ fmt~~~ ~ self~~ bits~~ f~ impl crate _core fmt UpperHex for BitFlags fn fmt  self f  mut crate _core fmt Formatter  crate _core fmt Result  crate _core fmt UpperHex€ʀ fmt̀π݀ Ѐ selfрՀ bitsրڀ f܀ allow dead_code impl BitFlags ́́΁ρ߁Ё attrсցׁ݁؁ argsف ށ  pub const Flag Self Self bits value # Returns an empty set of flags." inline pub const fn empty Selfσ Self bits0#& Returns the set containing all flags.ރ) inline pub const fn all Selfńۆ __impl_all_bitflagsׄ ͆ BitFlags T Ʌʅ݅˅̅܅ͅ attr΅ӅԅڅՅ argsօ ۅ ޅ Flag value #5 Returns the raw value of the flags currently stored.8 inline pubŇ constɇ fnχ bits҇և܇ ׇ self؇އ T self bits#8 Convert from underlying bit representation, unless that;#? representation contains bits that do not correspond to a flag.B inline pubȉ const̉ fn҉ from_bitsՉ މ bits߉ T crate _core option Option Self if bits   Self all bitsŠ0ŊNJ ݊ crateފ _core option Option Some Self bits else  crateË _coreŋʋ option̋ҋ Optionԋڋ None܋#> Convert from underlying bit representation, dropping any bitsA#! that do not correspond to flags.܌$ inline pub const fn from_bits_truncateˍ bitsÍǍɍ Tʍ͍ SelfЍՍ Self bits bits  Self all bits#; Convert from underlying bit representation, preserving all>#7 bits (even those not corresponding to a defined flag).:## # Safetyˏ ##: The caller of the `bitflags!` macro can chose to allow or=#- disallow extra bits for their bitflags type.0##9 The caller of `from_bits_unchecked()` has to ensure that<#9 all bits correspond to a defined flag or that extra bitsԑ<#" are valid for this bitflags type.%ϒВג inlineђ pub const unsafe fn from_bits_unchecked bits T Self˓ Self bits#1 Returns `true` if no flags are currently stored.ړ4 inline pub const fn is_emptyƔ̔ ǔ selfȔΔ boolє֔ self bits Self empty bits#/ Returns `true` if all flags are currently set.2 inline pub const fn is_all  self bool Self all bits – selfĖȖ bitsɖΖ selfіՖ bits֖#E Returns `true` if there are flags common to both `self` and `other`.H˗̗ӗ inline͗ pub const fn intersects   self other Self bool ͘ Self̘ bits self bits  other˜ǘ bitsȘΘ is_emptyϘטؘ#K Returns `true` if all of the flags in `other` are contained within `self`.NЙљؙ inlineҙ pub const fn contains  self other Self boolݚ self bits  other bitsÚ otherƚ˚ bits̚#& Inserts the specified flags in-place.) inline pub fn insertśܛ ƛ mutǛ self˛ϛ otherћ֛ Self؛ޛ self bits  other bits#& Removes the specified flags in-place.)ڜۜ inlineܜ pub fn remove  mut self other SelfΝ self bits   other bits#& Toggles the specified flags in-place.ݝ) inline pub fn toggle͞  mut self otheržǞ SelfɞϞ self bits  other bits#F Inserts or removes the specified flags depending on the passed value.I inline pub fn set  mut self other Self value boolա ifà valueƠ̠ self insert other elseǡ self remove other#9 Returns the intersection between the flags in `self` and<# `other`. #Ƣ#A Specifically, the returned set contains only the flags which are֢D#( present in *both* `self` *and* `other`.+#ߣ#3 This is equivalent to using the `&` operator (e.g.6#) [`ops::BitAnd`]), as in `flags & other`.,##E [`ops::BitAnd`]: https://doc.rust-lang.org/std/ops/trait.BitAnd.htmlHХѥإ inlineҥ must_use pub const fn intersection  self other Self Self SelfŦʦ bitșЦ selfҦ֦ bitsצ ܦ otherަ bits#> Returns the union of between the flags in `self` and `other`.A#ԧ#< Specifically, the returned set contains all flags which are?#A present in *either* `self` *or* `other`, including any which areD#< present in both (see [`Self::symmetric_difference`] if that?# is undesirable).ͩ##3 This is equivalent to using the `|` operator (e.g.6#( [`ops::BitOr`]), as in `flags | other`.+##C [`ops::BitOr`]: https://doc.rust-lang.org/std/ops/trait.BitOr.htmlFܫݫ inlineޫ must_use pub const fn union self other Self Self SelfʬϬ bitsѬլ self׬۬ bitsܬ  other bits#@ Returns the difference between the flags in `self` and `other`.C#ۭ#= Specifically, the returned set contains all flags present in@#0 `self`, except for the ones present in `other`.3##A It is also conceptually equivalent to the "bit-clear" operation:D#6 `flags & !other` (and this syntax is also supported).ٯ9##3 This is equivalent to using the `-` operator (e.g.6#& [`ops::Sub`]), as in `flags - other`.)##? [`ops::Sub`]: https://doc.rust-lang.org/std/ops/trait.Sub.htmlB inline must_use pub const fn difference² ̲޲ selfͲѲ otherӲز Selfڲ Self Self bits self bits   other bits#? Returns the [symmetric difference][sym-diff] between the flagsB# in `self` and `other`.##@ Specifically, the returned set contains the flags present which´C#> are present in `self` or `other`, but that are not present inA#> both. Equivalently, it contains the flags present in *exactlyA#% one* of the sets `self` and `other`.(##3 This is equivalent to using the `^` operator (e.g.6#) [`ops::BitXor`]), as in `flags ^ other`.,##? [sym-diff]: https://en.wikipedia.org/wiki/Symmetric_differenceB#E [`ops::BitXor`]: https://doc.rust-lang.org/std/ops/trait.BitXor.htmlθH inlineù must_use pubѹ constչ fn۹ symmetric_difference޹ self other Self SelfҺ Selfĺ bits self bits  other bits#- Returns the complement of this set of flags.0##@ Specifically, the returned set contains all the flags which areC#8 not set in `self`, but which are allowed for this type.;#Ƽ#: Alternatively, it can be thought of as the set differenceּ=#? between [`Self::all()`] and `self` (e.g. `Self::all() - self`)B##3 This is equivalent to using the `!` operator (e.g.6# [`ops::Not`]), as in `!flags`.¾"## [`Self::all()`]: Self::all#? [`ops::Not`]: https://doc.rust-lang.org/std/ops/trait.Not.htmlB inline must_use pub const fn complement  self Self Self from_bits_truncate  self bits impl crate _core ops BitOr for BitFlags type Output Self#, Returns the union of the two sets of flags./ inline fn bitor self other BitFlags Self Self bits self bits  other bits impl crate _core ops BitOrAssign for BitFlags# Adds the set of flags. inline fn bitor_assign   mut self other Self self bits  other bits impl crate _core ops BitXor for BitFlags type Output Self#> Returns the left flags, but with all the right flags toggled.A inline fn bitxor self other Self Self Self bits self bits  other bits impl crate _core ops BitXorAssign for BitFlags# Toggles the set of flags. inline fn bitxor_assign   mut self other Self self bits  other bits impl crate _core ops BitAnd for BitFlags type Output Self#8 Returns the intersection between the two sets of flags.; inline fn bitand self other Self Self Self bits self bits  other bits impl crate _core ops BitAndAssign for BitFlags#( Disables all flags disabled in the set.+ inline fn bitand_assign   mut self other Self self bits  other bits impl crate _core ops Sub for BitFlags type Output Self#5 Returns the set difference of the two sets of flags.8 inline fn sub self other Self Self Self bits self bits   other bits impl crate _core ops SubAssign for BitFlags#' Disables all flags enabled in the set.* inline fn sub_assign   mut self other Self self bits   other bits impl crate _core ops Not for BitFlags type Output Self#- Returns the complement of this set of flags.0 inline fn not self Self Self bits  self bits  Self all impl crate _core iter Extend BitFlags for BitFlags fn extend T crate _core iter IntoIterator  Item Self   mut self iterator T for item in iterator self insert item impl crate _core iter FromIterator  BitFlags for BitFlags fn from_iter  T crate _core iter IntoIterator  Item Self  iterator T Self let mut result Self empty result extend iterator result  filtered meta  cfg cfgargs tt  rest ident restargs tt   fn item tt  __impl_bitflags   filtered  cfg cfgargs  rest restargs   fn item   filtered meta  next ident nextargs tt  rest ident restargs tt   fn item tt  __impl_bitflags   filtered  rest restargs   fn item  filtered meta  fn item tt  filtered  fn item   filtered meta  cfg cfgargs tt  rest ident restargs tt   const item tt  __impl_bitflags   filtered  cfg cfgargs  rest restargs   const item   filtered meta  next ident nextargs tt  rest ident restargs tt   const item tt  __impl_bitflags   filtered  rest restargs   const item  filtered meta  const item tt  filtered  const item dэc  macro_exportc cc local_inner_macroscc#cdoccdd hiddendcd/,?0/?00?u8?& 0B6?)"?g/W{crate3?T/home/seth/.cargo/registry/src/github.com-1ecc6299db9ec823/bitflags-1.3.2/src/lib.rswĹ(m OLTX?1""" 9/X""" ) =@b%% $ 4.--A"G : 4S"""D &&6=??E"" "PT "? -#1C4$111  E  ,$  3$#!0+ AP)#":N*)0+1&56M*)U"&;$1'HB% -#(H- 8a? 7a> :aA :aA '?/+!6)'$3,E-HOV7G8N1@7KGJ=II2HA34?1:UBC[@764)64*64)V>((IQ8C9UC6NLQL!C8S<6PM@QFC6OA7O'PNN5C9OUK6=PHJOC/+O45 7 <76 ='6) 8 N36 >*7) 8 H36 >87) 5 E07 ;74* 5 =#8 Da'& Ja0) INNQ7*95'('!.  ) *. ")  INNQ7*95&(&!.  ) *. ")  & 3#T9'"Y""!&+D  !!5 '(  / !  713=C< ?;?LGA9' LN $CNJK9" ;% ; H@*  ,')>1/ (%&C"/0;-/ -!!%^ 3!% $% '&$ &#"*\D &149 *&"644 &&49;5<-1/4 $C.&>9E55D5 +++$$$222--.--+..2330011*/KK N9F7E9N)09+W "C8+%8391//X #IK#I; ('(''''(' ]% 3)G)P%%5,%54%5*&5K*&5M'V'4/4[K[L'Y''2//2  * !- %%&""( +$"$"  *+ <0<0>' KE G  $$'$! $$#""""%* $$(( 6 C@DA4C1% E 8;FDG BEJKN @CIJM @CIJM)& %  +  %&&&  ' ,4 (<  .# 1 L/5'2I.7# ' ! "" 74)=:  $EEEH LQQQ 6 777G )3A1 +X66 )3o38! ͩޑѣbitflagsx86_64-unknown-linux-gnu-69acfc798c96d00cӳUw{~Ll  @