📄 libbitflags-d809e88748d1a502.rmeta
/home/palash/git/iron_learn/target/debug/deps/libbitflags-d809e88748d1a502.rmeta
Language: rmeta • Lines: 2315
rust
ߧ#rustc 1.92.0 (ded5c06cf 2025-12-08)��١�	�T�6a��D�
-5080178c80bf7a93��**�٭T��HО�9�-3e2e950d4bac10b5��example_generated�����<���������tests�,���$���_core�bitflags�__impl_all_bitflags�__impl_bitflags���,�H�D�V���\�|�d������OL A typesafe bitmask flag generator useful for sets of C-style bitmask flags.���@= It can be used for creating typesafe wrappers around C APIs.�����MJ The `bitflags!` macro generates `struct`s that manage a set of flags. The���MJ flags should only be defined for integer types, otherwise unexpected type���%" errors may occur at compile time.���l�
 # Example���<� ```��� use bitflags::bitflags;���|� bitflags! {���     struct Flags: u32 {���!         const A = 0b00000001;���!         const B = 0b00000010;���!         const C = 0b00000100;���C@         const ABC = Self::A.bits | Self::B.bits | Self::C.bits;�L�     }�,� }���|� fn main() {���%"     let e1 = Flags::A | Flags::C;���	%"     let e2 = Flags::B | Flags::C;���	52     assert_eq!((e1 | e2), Flags::ABC);   // union���	<9     assert_eq!((e1 & e2), Flags::C);     // intersection���
>;     assert_eq!((e1 - e2), Flags::A);     // set difference���
>;     assert_eq!(!e2, Flags::A);           // set complement�,��	<������eb See [`example_generated::Flags`](./example_generated/struct.Flags.html) for documentation of code���1. generated by the above `bitflags!` expansion.�����DA The generated `struct`s can also be extended with type and trait���
 implementations:��
�<�
���
 use std::fmt;��
���
��
�|�
���
���!���!�L��,��	����
 impl Flags {���!     pub fn clear(&mut self) {���OL         self.bits = 0;  // The `bits` field can be accessed from within the���SP                         // same module where the `bitflags!` macro was invoked.�L��,��	����! impl fmt::Display for Flags {���>;     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {��         write!(f, "hi!")�L��,��	��|��	��,)     let mut flags = Flags::A | Flags::B;���     flags.clear();���"     assert!(flags.is_empty());���0-     assert_eq!(format!("{}", flags), "hi!");���B?     assert_eq!(format!("{:?}", Flags::A | Flags::B), "A | B");���30     assert_eq!(format!("{:?}", Flags::B), "B");�,��	<������
 # Visibility�����NK The generated structs and their associated flag constants are not exported���MJ out of the current module by default. A definition can be exported out of���74 the current module by adding `pub` before `struct`:���<���� mod example {���     use bitflags::bitflags;�����     bitflags! {���$!         pub struct Flags1: u32 {���%"             const A = 0b00000001;�l�
         }���|� #       pub���          struct Flags2: u32 {���%"             const B = 0b00000010;�l��L��,��	��|��	��'$     let flag1 = example::Flags1::A;���FC     let flag2 = example::Flags2::B; // error: const `B` is private�,��	<������
 # Attributes�����IF Attributes can be attached to the generated `struct`s by placing them���  before the `struct` keyword.����� ## Representations�����RO It's valid to add a `#[repr(C)]` or `#[repr(transparent)]` attribute to a type���UR generated by `bitflags!`. In these cases, the type is guaranteed to be a newtype.���<��ܖ���|����     #[repr(transparent)]������!���!���!�L��,��	<����܁ # Trait implementations�����JG The `Copy`, `Clone`, `PartialEq`, `Eq`, `PartialOrd`, `Ord` and `Hash`���TQ traits are automatically derived for the `struct`s using the `derive` attribute.���FC Additional traits can be derived by providing an explicit `derive`�Ԉ  attribute on `struct`.�� ��� MJ The `Extend` and `FromIterator` traits are implemented for the `struct`s,��� PM too: `Extend` adds the union of the instances of the `struct` iterated over,���!.+ while `FromIterator` calculates the union.��!���!MJ The `Binary`, `Debug`, `LowerHex`, `Octal` and `UpperHex` traits are also���"DA implemented by displaying the bits value of the internal struct.��#���#
 ## Operators��#���#NK The following operator traits are implemented for the generated `struct`s:��#���#&# - `BitOr` and `BitOrAssign`: union���$/, - `BitAnd` and `BitAndAssign`: intersection���$)& - `BitXor` and `BitXorAssign`: toggle���$+( - `Sub` and `SubAssign`: set difference�ܥ% - `Not`: set complement��%�l�%
 # Methods��%���%B? The following methods are defined for the generated `struct`s:��&���&$! - `empty`: an empty set of flags���&)& - `all`: the set of all defined flags���&96 - `bits`: the raw value of the flags currently stored���'JG - `from_bits`: convert from underlying bit representation, unless that���'KH                representation contains bits that do not correspond to a���(                defined flag���(PM - `from_bits_truncate`: convert from underlying bit representation, dropping���)LI                         any bits that do not correspond to defined flags���)PM - `from_bits_unchecked`: convert from underlying bit representation, keeping���*NK                          all bits (even those not corresponding to defined���+#                           flags)���+96 - `is_empty`: `true` if no flags are currently stored���+MJ - `is_all`: `true` if currently set flags exactly equal all defined flags���,OL - `intersects`: `true` if there are flags common to both `self` and `other`���-SP - `contains`: `true` if all of the flags in `other` are contained within `self`���-41 - `insert`: inserts the specified flags in-place���.41 - `remove`: removes the specified flags in-place���.PM - `toggle`: the specified flags will be inserted if not present, and removed��/             if they are.���/QN - `set`: inserts or removes the specified flags depending on the passed value���0SP - `intersection`: returns a new set of flags, containing only the flags present���0PM                   in both `self` and `other` (the argument to the function).���1JG - `union`: returns a new set of flags, containing any flags present in���2GD            either `self` or `other` (the argument to the function).���2OL - `difference`: returns a new set of flags, containing all flags present in���3KH                 `self` without any of the flags present in `other` (the���3.+                 argument to the function).���4NK - `symmetric_difference`: returns a new set of flags, containing all flags���4OL                           present in either `self` or `other` (the argument���5=:                           to the function), but not both.���5NK - `complement`: returns a new set of flags, containing all flags which are���6KH                 not set in `self`, but which are allowed for this type.��7�t�7 ## Default��7���7SP The `Default` trait is not automatically implemented for the generated structs.��7���8WT If your default value is equal to `0` (which is the same value as calling `empty()`���8>; on the generated struct), you can simply derive `Default`:��9�<�9�ܣ9��9�|�9���90-     // Results in default value with bits: 0�Ԅ:     #[derive(Default)]�ܟ:���:!���:!���:!�L�;�,�;�	�;�|�;�	��;85     let derived_default: Flags = Default::default();���;.+     assert_eq!(derived_default.bits(), 0);�,�<�	<�<��<���<WT If your default value is not equal to `0` you need to implement `Default` yourself:��=�<�=�ܣ=��=�|�=���=���=!���>!���>!�L�>�,�>�	�>���>(% // explicit `Default` implementation��? impl Default for Flags {���?     fn default() -> Flags {���?         Flags::A | Flags::C�L�?�,�?�	�?�|�@�	��@<9     let implemented_default: Flags = Default::default();���@?<     assert_eq!(implemented_default, (Flags::A | Flags::C));�,�A�	<�A��A���A
 # Zero Flags��A���Aa^ Flags with a value equal to zero will have some strange behavior that one should be aware of.��B�<�B�ܥB��B�|�B���B���B$!         const NONE = 0b00000000;���C$!         const SOME = 0b00000001;�L�C�,�C�	�C�|�C�	��C#      let empty = Flags::empty();���D     let none = Flags::NONE;���D     let some = Flags::SOME;��D���D30     // Zero flags are treated as always present���D-*     assert!(empty.contains(Flags::NONE));���E,)     assert!(none.contains(Flags::NONE));���E,)     assert!(some.contains(Flags::NONE));��F���F@=     // Zero flags will be ignored when testing for emptiness���F!     assert!(none.is_empty());�,�F�	<�F��F���FFC Users should generally avoid defining a flag with a value of zero.���G�G�H8�l�G�G7https://docs.rs/bitflags/1.3.2���G ��G9�3�C�S�b�q333��HC��V��H30 The macro used to generate the flag structures.��I���IRO See the [crate level docs](../bitflags/index.html) for complete documentation.��I�l�I��I�<�I���I��J�|�J�ܨJ���J!���J!���K!���KC�L�K�,�K�	�K�|�L�	��L%�	��L%�	��L5�
��M<�
��M>���N>�,�N�	<�N��N���ND���O��O�<�O���O��O���O��O�|�O�܍P���P!���P!�L�P�,�P�	�P���Q���Q!���QO���RS�L�R�,�R�	�R���R!���S>���S�L�S�,�S�	�S�|�S�	��T,���T���T"���T0���UB���U3�,�V�	<�V�'��V#S�V�\�V�X,�V�V�W+�V�V�W,�V8outer�,�V&�V8�
$�W
�W,�W8��W&�W8��W84�W,�W8BitFlags�D�W&�W8�,�W&�W,�W8��W&�W8��W�W�X,�W�W�X,�W�W�W+�W�W�W,�W8inner�,�W&�W8�,�W,�W�W�W,�W8�$�W&�W8��W
�W
�W8,�X,�X8Flag�$�X&�X8�,�X�X,�X8�,�X&�X8�$�X%�X
�X,�X�X�X,�X8t��X&�X8��X
�X*�X�X�[,�X�X�X+�X�X�X,�X8�X,�X
�X+�X�Y�Y8�4�Y�Y�Y
8~$�Y$�Y8�L�Y$�Y8��Y$�Y8t,�Y$�Y8�T�Y$�Y8��Y$�Y8�$�Y,�Y8��Y84�Y,�Y8�YD�Y�Y�Y8bits�$�Y&�Y,�Y8��Y$�Y8�|�Z	�Z�Z�[,�Z8�YD�Z&�Z,�Z8��Z�Z�[,�Z�Z�[	,�Z�Z�Z+�Z�Z�Z,�Z8�Z,�Z,�Z�Z�Z,�Z8�$�Z
�Z
�Z,�[8�[$�[�[,�[8�,�[%�[
�[8�D�[	�[�[�[,�[�[�[,�[8�\�[
�[%�[�[�\*�\�\�\%�\��\ ��\�\�\8�4�\t�\'��\#b�]�c�]�^
,�]8�YD�]&�]8�,�]&�],�]8��]&�]8��]�]�^,�]�]�^
,�]�]�]+�]�]�],�]8�$�]&�]8�,�],�]�]�],�]8�$�]&�]8��]
�]
�],�^8�[$�^&�^8�,�^�^,�^8�,�^&�^8�$�^%�^�^*�^�^�b+�_�_�_8�,�_�_�_8non_snake_case�t�_8,�_8
__BitFlags�T�_�_�`,�_�_�`	8,�_,�_8�[$�_&�_,�_8��_�_7��_%�_�`+�`�`�`8�,�`�`�`8�ft�`8$�`8�fT�`8
�`,�`8�YD�`�`�b,�`�`�b8�|�`	�a�a�b+�a�a�a8�,�a�a�a8�T�a,�a�a�a-�a+�a�a�a,�a8�$�a,�a�a�a,�a8�$�a
�a
�a8,�a,�a8�[$�a&�a,�b8��b�b8$�b'�b,�b8�[$�b �b8�_$�b%�b�b8$�b�b�b8�_$�b&�b,�b�b�b�b8$�b8�b8�fT�b�b'�b,�b8�[$�b�b�b%�c�c�c
,�c8�YD�c&�c8�,�c&�c,�c8��c&�c8��c�c�c*�c�c�c8$�c�c�c8�_$�c&�c7��c%�c�d��c�d�d8�4�dt�c'��c#q�d���d�e
,�d8�YD�d&�d8�,�d&�d,�d8��d&�d8��d�d�e,�d�d�e
,�d�d�e+�d�d�e,�d8�$�d&�d8�,�d,�e�e�e,�e8�$�e&�e8��e
�e
�e,�e8�[$�e&�e8�,�e�e,�e8�,�e&�e8�$�e%�e
�e*�e�e���8$�e,�e8,�e'�e8�,�e'�e8��e'�e8�,�f8
�f,�f8�YD�f�f�y
8�f8��f�f�f�f8$�f$�f8��f&�f�f8�f,�f8,�f'�f8�,�f'�f8��f'�f8�L�f(�f,�f8,�f'�f8�,�f'�f8��f'�f8�4�f�f�y0+�j�j�j8�,�j�j�j8�ft�j8,�j8�fT�j�j�k,�j�j�k	+�k�k�k8�4�k8�k,�k8�[$�k�k�k�k8$�k(�k8�$�k�k�k8,�k
�k+�l�l�m8�,�l�l�m8�ft�m8$�m8�fT�m8
�m,�m8�YD�m�m�r,�m�m�r8�|�m	�m�n�r+�n�n�n8�,�n�n�n8�T�n+�n�n�n8�4�n,�n�n�o-�n+�n�n�o,�n8�$�n,�o�o�o,�o8�$�o
�o
�o8�o,�o8�[$�o�o�o�o8$�o(�o8�$�o�o�q8�o8$�o'�o,�o8�[$�o �o8�_$�o�o7��o�o8$�p �p8�_$�p�p7��p�p�p8,�p8$�p�p�q8$�q �q8�_$�q�q8$�q'�q,�q8�[$�q �q8�_$�q�q8$�q'�q,�q8�[$�q �q8�_$�q
�r8�r8�r8first�,�r�r8 $�r%�r,�r�r�u8�s�s8$�s8�s8�fT�s�s'�s,�s8�[$�s�s�s8$�s�s�u8�s	�s8�},�s�s�t8��s �s8�L�s�s�t7 | �,�s-�t%�t8�},�t�t8,�t%�t8��t �t8�L�t�t�u,�t8,�t'�t8�,�t'�t8�L�t	�u�u�u,�u8�[$�u-�u%�u
�u8�u8
extra_bits�T�u�u8$�u �u8�_$�u�u	�u8$�u'�u8��u�u�u �u8�_$�u�u�u%�u8�v8�T�v�v7��v�v�x8�v	�v8�},�v�v�w8��v �v8�L�v�v�v7�,�v-�v%�v8�},�w�w8,�w%�w8��w �w8�L�w�w�w70x�$�w-�w%�w,�w8,�w'�w8�,�w'�w8��w'�w8LowerHex�D�w'�w8��x�x�x�x8�T�x$�x8��x-�x%�x8�x8�},�x�x�y8��x �x8�L�x�x�x7(empty)�L�x-�x%�x8��y�y�y�y�y8$�y,�y8,�y'�y8�,�y'�y8��y'�y8Binary�4�y8
�y,�y8�YD�y�y�{
8�y8��y�y�z�y8$�y$�z8��z&�z�z8�z,�z8,�z'�z8�,�z'�z8��z'�z8�L�z(�z,�z8,�z'�z8�,�z'�z8��z'�z8�4�z�z�{,�z8,�z'�z8�,�z'�z8��z'�z8��4�z'�z8��z�z�{�z8$�z �z8�_$�{$�{8��{8$�{,�{8,�{'�{8�,�{'�{8��{'�{8Octal�,�{8
�{,�{8�YD�{�{�}
8�{8��{�{�|�{8$�{$�{8��{&�{�{8�{,�{8,�{'�|8�,�|'�|8��|'�|8�L�|(�|,�|8,�|'�|8�,�|'�|8��|'�|8�4�|�|�},�|8,�|'�|8�,�|'�|8��|'�|8��,�|'�|8��|�|�|�|8$�| �|8�_$�|$�|8��|8$�},�}8,�}'�}8�,�}'�}8��}'�}8ȄD�}8
�},�}8�YD�}�}�
8�}8��}�}�~�}8$�}$�}8��}&�}�}8�},�}8,�}'�}8�,�}'�}8��}'�}8�L�}(�~,�~8,�~'�~8�,�~'�~8��~'�~8�4�~�~�~,�~8,�~'�~8�,�~'�~8��~'�~8ȄD�~'�~8��~�~�~�~8$�~ �~8�_$�~$�~8��~8$�,�8,�'�8�,�'�8��'�8UpperHex�D�8
�,�8�YD����
8�8�����8$�$�8��&��8�,�8,�'�8�,�'�8��'�8�L�(�,��8,��'��8�,��'��8���'��8�4�����,��8,��'��8�,��'��8���'��8ГD€'ʀ8�̀π݀Ѐ8$р Հ8�_$ր$ڀ8�܀+������8�,������8�L��8$��,��8�YD�������,������
,́́��+΁ρ߁,Ё8�$с,ցׁ݁,؁8�$ف
ށ
�8�8,��,��8�[$��&��8$����8$������8�_$��&��,��8�,��%��
��< Returns an empty set of flags.����"+����8�4�8��8,��8��8empty�,������(��8$����σ8$������8�_$��&��7���<& Returns the set containing all flags.��ރ)+������8�4��8��8,��8��8�������(��8$��ńۆ8��ׄ	��͆,��8�YD��&��,��8�������,������	,Ʌʅ݅+˅̅܅,ͅ8�$΅,Ӆԅڅ,Յ8�$օ
ۅ
ޅ,��8�[$����,��8�,��%��
��<5 Returns the raw value of the flags currently stored.���8+������8�4��8Ň8,ɇ8χ8�_$҇և܇ׇ8$؇(އ,�8�����8$�� ��8�_$��<8 Convert from underlying bit representation, unless that����;<? representation contains bits that do not correspond to a flag.���B+������8�4��8ȉ8,̉8҉8	from_bits�LՉމ�8�_$߉&�,�8��(�,�8,�'�8�,�'��8�4��'��8�4����8$��������8������
8�_$����	��8$��'��8������� ��8�_$������Š7�ŊNJ��,݊8,ފ'�8�,�'�8�4�'�8�4�'��8�$������8$������8�_$��8$�����
,��8,��'Ë8�,ŋ'ʋ8�4̋'ҋ8�4ԋ'ڋ8�$܋<> Convert from underlying bit representation, dropping any bits����A<! that do not correspond to flags.��܌$+������8�4��8��8,��8��8from_bits_truncate����ˍ8�_$Í&Ǎ,ɍ8�ʍ(͍8$ЍՍ��8$����
8�_$�&�8�_$���8$��'��8������� ��8�_$��<; Convert from underlying bit representation, preserving all����><7 bits (even those not corresponding to a defined flag).���:<���<	 # Safety�dˏ<��<: 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.����%+ϒВג8�4ђ8�8,�8"4�8��8from_bits_unchecked��������8�_$��&��,��8���(��8$����˓8$������8�_$��<1 Returns `true` if no flags are currently stored.��ړ4+������8�4��8��8,��8��8is_empty�D��Ɣ̔ǔ8$Ȕ(Δ8�$є֔��8$� �8�_$�����8$��'��8͛,������ ��8�_$������</ Returns `true` if all flags are currently set.����2+���8�4�8��8,��8��8is_all�4��������8$��(��8�$�����8$��'��8������� ��8�_$��–8$Ė Ȗ8�_$ɖΖ8$і Ֆ8�_$֖<E Returns `true` if there are flags common to both `self` and `other`.����H+˗̗ӗ8�4͗8�8,�8�8
intersects�T�������8$��$��8�,��&��8$��(��8�$�����	����͘8$����̘	8�_$��&��8$�� ��8�_$����8�,˜ ǘ8�_$Ș Θ8γDϘטؘ<K Returns `true` if all of the flags in `other` are contained within `self`.����N+Йљؙ8�4ҙ8�8,�8�8contains�D�������8$��$��8�,��&��8$��(��8�$����ݚ����8$�� ��8�_$����8�,�� ��8�_$��Ú8�,ƚ ˚8�_$̚<& Inserts the specified flags in-place.���)+������8�4��8��8��8insert�4��śܛƛ8Ǜ8$˛$ϛ8�,ћ&֛8$؛ޛ��8$� ��8�_$����8�,�� ��8�_$��%��<& Removes the specified flags in-place.����)+ڜۜ�8�4ܜ8�8��8remove�4��������8��8$��$��8�,��&��8$����Ν	8$�� ��8�_$����	��8�,�� ��8�_$��%��<& Toggles the specified flags in-place.��ݝ)+������8�4��8��8��8toggle�4����͞��8��8$��$��8�,ž&Ǟ8$ɞϞ��8$� �8�_$��8�,� �8�_$��%��<F Inserts or removes the specified flags depending on the passed value.����I+���8�4�8��8��8set���������8��8$��$��8�,��&��8$��$��8�,��&��8�$����ա8à8�,Ơ̠��8$� �8�4����8�,�%��8$����ǡ8$�� ��8��4������8�,��%��<9 Returns the intersection between the flags in `self` and���<<	 `other`.�d��<�Ƣ<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.html����H+Хѥإ8�4ҥ+���8�
D�8��8,��8��8intersection�d������8$��$��8�,��&��8$��(��8$������8$Ŧʦ�	8�_$̦&Ц8$Ҧ ֦8�_$צܦ8�,ަ �8�_$�<> 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 are����D<< 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.html����F+ܫݫ�8�4ޫ+����8�
D��8��8,��8��8C,������8$��$��8�,��&��8$��(��8$������8$ʬϬ�	8�_$Ѭ&լ8$׬ ۬8�_$ܬ�8�,� �8�_$�<@ 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.html����B+������8�4��+������8�
D��8��8,��8��8
difference�T²̲޲8$Ͳ$Ѳ8�,Ӳ&ز8$ڲ(�8$����8$������
8�_$��&��8$�� ��8�_$����	��8�,�� ��8�_$��<? Returns the [symmetric difference][sym-diff] between the flags����B< 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 in����A<> both. Equivalently, it contains the flags present in *exactly���A<% 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_difference����B<E [`ops::BitXor`]: https://doc.rust-lang.org/std/ops/trait.BitXor.html��θH+������8�4��+����ù8�
D��8ѹ8,չ8۹8symmetric_difference��޹���8$�$��8�,��&��8$��(��8$����Һ8$����ĺ	8�_$��&��8$�� ��8�_$����8�,�� ��8�_$��<- Returns the complement of this set of flags.���0<���<@ Specifically, the returned set contains all the flags which are����C<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.html����B+������8�4��+������8�
D��8��8,��8��8
complement�T������8$��(��8$������8$��'��8ת�������	��8$�� ��8�_$��8$��,��8,��'��8�,��'��8���'��8BitOr�,��8
��,��8�YD������8!$��8�4����8$��%��<, Returns the union of the two sets of flags.����/+������8�4��8��8�,������8$��$��8�,��&��,��8�YD��(��8$������8$������	8�_$��&��8$�� ��8�_$����8�,�� ��8�_$��8$��,��8,��'��8�,��'��8���'��8BitOrAssign�\��8
��,��8�YD������< Adds the set of flags.�ԙ�+������8�4��8��8�d��������8��8$��$��8�,��&��8$������8$�� ��8�_$����8�,�� ��8�_$��%��8$��,��8,��'��8�,��'��8���'��8BitXor�4��8
��,��8�YD������8!$��8�4����8$��%��<> Returns the left flags, but with all the right flags toggled.����A+������8�4��8��8�4������8$��$��8�,��&��8$��(��8$������8$������	8�_$��&��8$�� ��8�_$����8�,�� ��8�_$��8$��,��8,��'��8�,��'��8���'��8BitXorAssign�d��8
��,��8�YD������< Toggles the set of flags.����+������8�4��8��8�l��������8��8$��$��8�,��&��8$������8$�� ��8�_$����8�,�� ��8�_$��%��8$��,��8,��'��8�,��'��8���'��8BitAnd�4��8
��,��8�YD������8!$��8�4����8$��%��<8 Returns the intersection between the two sets of flags.����;+������8�4��8��8�4������8$��$��8�,��&��8$��(��8$������8$������	8�_$��&��8$�� ��8�_$����8�,�� ��8�_$��8$��,��8,��'��8�,��'��8���'��8BitAndAssign�d��8
��,��8�YD������<( Disables all flags disabled in the set.����++������8�4��8��8�l��������8��8$��$��8�,��&��8$������8$�� ��8�_$����8�,�� ��8�_$��%��8$��,��8,��'��8�,��'��8���'��8Sub���8
��,��8�YD������8!$��8�4����8$��%��<5 Returns the set difference of the two sets of flags.����8+������8�4��8��8�������8$��$��8�,��&��8$��(��8$������8$������
8�_$��&��8$�� ��8�_$����	��8�,�� ��8�_$��8$��,��8,��'��8�,��'��8���'��8	SubAssign�L��8
��,��8�YD������<' Disables all flags enabled in the set.����*+������8�4��8��8�T��������8��8$��$��8�,��&��8$������	8$�� ��8�_$����	��8�,�� ��8�_$��%��8$��,��8,��'��8�,��'��8���'��8Not���8
��,��8�YD������8!$��8�4����8$��%��<�����0+������8�4��8��8�������8$��(��8$������8$������8�_$��&��	��8$�� ��8�_$����8$��'��8�������8$��,��8,��'��8�,��'��8�	$��'��8Extend�4����,��8�YD����8
��,��8�YD������8��8extend�4����8���&��,��8,��'��8�,��'��8�	$��'��8�d����8�$����8$����������8��8$��$��8�	D��&��8�������8
��8�	$��8��8�	D������8$�� ��8�4������8�	$��8$��,��8,��'��8�,��'��8�	$��'��8�d����,��8�YD����8
��,��8�YD������8��8�L����8���&��,��8,��'��8�,��'��8�	$��'��8�d����8�$����8$��������8�	D��&��8���(��8$������8��8��8�
4����8$��'��8͛,������%��8�
4�� ��8ˑ4������8�	D��%��8�
4��%������
,������+������,��8filtered�D��&��8�
$��
��-��+������8���,������,��8cfgargs�<��&��8���
��,������-��+������,��8rest�$��&��8�,��,������,��8restargs�D��&��8���
��
��8��,������,��8�	$��&��8���
��*������8�|��	������,������+������,��8��D��
��+������8���,������,��8��<��
��,������-��+������,��8�$��,������,��8��D��
��
��8��,������,��8�	$��
��%������
,������+������,��8��D��&��8�
$��
��-��+������,��8�$��&��8�,��,������,��8nextargs�D��&��8���
��,������-��+������,��8�$��&��8�,��,������,��8��D��&��8���
��
��8��,������,��8�	$��&��8���
��*������8�|��	������
,������+������,��8��D��
��,������-��+������,��8�$��,������,��8��D��
��
��8��,������,��8�	$��
��%������,������+������,��8��D��&��8�
$��
��8��,������,��8�	$��&��8���
��*������,������+������,��8��D��
��8��,������,��8�	$��
��%������
,������+������,��8��D��&��8�
$��
��-��+������8���,������,��8��<��&��8���
��,������-��+������,��8�$��&��8�,��,������,��8��D��&��8���
��
��8,��,������,��8�	$��&��8���
��*������8�|��	������,������+������,��8��D��
��+������8���,������,��8��<��
��,������-��+������,��8�$��,������,��8��D��
��
��8,��,������,��8�	$��
��%������
,������+������,��8��D��&��8�
$��
��-��+������,��8�$��&��8�,��,������,��8��D��&��8���
��,������-��+������,��8�$��&��8�,��,������,��8��D��&��8���
��
��8,��,������,��8�	$��&��8���
��*������8�|��	������
,������+������,��8��D��
��,������-��+������,��8�$��,������,��8��D��
��
��8,��,������,��8�	$��
��%������,������+������,��8��D��&��8�
$��
��8,��,������,��8�	$��&��8���
��*������,������+������,��8��D��
��8,��,������,��8�	$��
��%���crate level docs�../bitflags/index.html�example_generated::Flags�%./example_generated/struct.Flags.html�������������������������������������I�I�I�H�J������}�t$)6A����alM��
��3�)�D	Ja��kr��y<�cR��Msl��8N��M(��B(c1"7M()))L(,�1S7}�(�(�(�(^17�(�(,�1P7J(�����,�1T7[��"%�}�t$)6A��Z�`*�l�"�&�G�7�\��ODHT ��l��8N������alM�}�t$)6A�)�D	Ja��
��3�kr��y<�cR��MsE������� Z��M9E������� Z��M9[/home/palash/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bitflags-1.3.2/src/lib.rs� �wĹ(m�<�Z
<���
A?#EB@A$PANN&"""D
&&6=??f2E""
"PT
"?
-#1C4ON8 %&!&
(GJ!SV"""
KUGNQ/NEO'0*,C%*:KL QMQO$:NPT55QRTQKHPL/OP>OLTX?1"""
9/X"""
)  
=@b%%
$  4.--A"G : 4S"""D
&&6=??E""
"PT
"?
-#1C4$111
E 
,$

3$#!0+
<!%
!(#)-8
8#$!0+
7aKH>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<?;<G412I6#B>?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 6777G)3A1+X66)3o38!
��7��2㏘]JJ,O�p!g~�x86_64-unknown-linux-gnu�|����n����#*0�C��-d809e88748d1a502�}�t$)6A��R޻8N�rust-end-file