ELF@@8@#!@@@ppRtdPtd   <<Qtd88Android%GNU's{FRZOAz6(2AN`c hTD rust_metadata_static_assertions_351233de52bd9ed6__cxa_finalize__cxa_atexit__register_atforklibc.soLIBClibstatic_assertions.dylib.soAPS2;<Th| zR| x ,p@`TP hH|L  @X_@_ ` V ՃV{@b    @ @ @ `mooooH8 0 oooo@@@rustc version 1.93.1-dev (01f6ddf75 2026-02-11) (Android Rust Toolchain version 14933020-linux-x86)Android (14863223, +pgo, +bolt, +lto, +mlgo, based on r584948b) clang version 22.0.1 (https://android.googlesource.com/toolchain/llvm-project 2d65e4108033380e6fe8e08b1f1826cd2bfb0c99)Linker: LLD 22.0.1 (/mnt/disks/build-disk/src/googleplex-android/llvm-r584948-release/out/llvm-project/llvm 2d65e4108033380e6fe8e08b1f1826cd2bfb0c99)rust rust D[rustc 1.93.1-dev (01f6ddf75 2026-02-11) (Android Rust Toolchain version 14933020-linux-x86)*˝NӥLBٿ\hRꋔ Yi@|W  |pȲΦxJ$l3< P!97, hashbrownpp|S\M std_detect;! QRXrustc_demanglec.0"gcfg_ifSLU {"tĪg=/_core assert_cfgassert_eq_alignassert_eq_sizeassert_eq_size_ptrassert_eq_size_val assert_fields  assert_implassert_impl_oneassert_impl_allassert_impl_anyassert_not_impl_allassert_not_impl_anyassert_obj_safe assert_traitassert_trait_sub_allassert_trait_super_all assert_typeassert_type_eq_allassert_type_ne_all const_assertconst_assert_eqconst_assert_ne ,T |t    l  | ||'H\|  d | |  [![Banner](https://raw.githubusercontent.com/nvzqz/static-assertions-rs/assets/Banner.png)](https://github.com/nvzqz/static-assertions-rs)ē
=: ]Z Downloadsd C@ mj Build Statusd [X rustc ^1.37.0

T
NK Assertions to ensure correct assumptions about constants, types, and more.MJ _All_ checks provided by this crate are performed at [compile-time]. ThisIF allows for finding errors quickly and early when it comes to ensuringJG certain features or aspects of a codebase. These macros are especiallyPM important when exposing a public API that requires types to be the same size  or implement certain traits.\ # UsageOL This crate is available [on crates.io][crate] and can be used by adding the /, following to your project's [`Cargo.toml`]: \  ```toml  [dependencies]  static_assertions = "1.1.0"<  ```  85 and this to your crate root (`main.rs` or `lib.rs`): <  #[macro_use] # extern crate static_assertions;  # fn main() {}<   MJ When using [Rust 2018 edition][2018], the following shorthand can help if )& having `#[macro_use]` is undesirable.   ```edition2018 )& extern crate static_assertions as sa;   sa::const_assert!(true);<  t # Examples  74 Very thorough examples are provided in the docs for PM [each individual macro](#macros). Failure case examples are also documented.l # Changes`] See [`CHANGELOG.md`](https://github.com/nvzqz/static-assertions-rs/blob/master/CHANGELOG.md)KH for an exhaustive list of what has changed from one version to another.d # DonateNK This project is made freely available (as in free beer), but unfortunatelyNK not all beer is free! So, if you would like to buy me a beer (or coffee orKH *more*), then consider supporting my work that's benefited your project and thousands of others.,) vs Become a Patron!D *' nk Buy me a coffeeD!GD [Rust 1.37]: https://blog.rust-lang.org/2019/08/15/Rust-1.37.0.htmlXU [2018]: https://blog.rust-lang.org/2018/12/06/Rust-1.31-and-rust-2018.html#rust-201874 [crate]: https://crates.io/crates/static_assertions>; [compile-time]: https://en.wikipedia.org/wiki/Compile_timeKH [`Cargo.toml`]: https://doc.rust-lang.org/cargo/reference/manifest.html  8l 7'https://docs.rs/static_assertions/1.1.0)B  8l 7Lhttps://raw.githubusercontent.com/nvzqz/static-assertions-rs/assets/Icon.pngNg # 2 A P _n}tT .+ Asserts that a given configuration is set./t3BFPM A project will simply fail to compile if the given configuration is not set.<?< # #[macro_use] extern crate static_assertions; fn main() {} // We're not masochists>; # #[cfg(not(target_pointer_width = "16"))] // Just in case2/ assert_cfg!(not(target_pointer_width = "16"));<JG If a project does not support a set of configurations, you may want toPM report why. There is the option of providing a compile error message string:<?,  # #[cfg(any(unix, windows))]QN assert_cfg!(any(unix, windows), "There is only support for Unix or Windows");0- // User needs to specify a database back-end63 # #[cfg(target_pointer_width = "0")] // ImpossibleEB assert_cfg!(all(not(all(feature = "mysql", feature = "mongodb")),EB any( feature = "mysql", feature = "mongodb")),NK "Must exclusively use MySQL or MongoDB as database back-end");<NK Some configurations are impossible. For example, we can't be compiling for,) both macOS _and_ Windows simultaneously:   ```compile_fail ?, (% assert_cfg!(all(target_os = "macos", +( target_os = "windows"), 85 "No, that's not how it works! ಠ_ಠ");< &|      *   %    ,   , 8 & 8 $  $ , 8msg & 8$ ,   $ - *   +   8   8    ,   , 8  8l    , 88 % %   ,   , 8 & 8  *   +   8   8    ,   , 8  8l    84    7Cfg does not pass: $ 8L    ,   , 8  % % |.+ Asserts that types are equal in alignment./3NK This is useful when ensuring that pointer arithmetic is done correctly, orOL when [FFI] requires a type to have the same alignment as some foreign type.t96 A `usize` has the same alignment as any pointer type:<?,0- assert_eq_align!(usize, *const u8, *mut u8);<LI The following passes because `[i32; 4]` has the same alignment as `i32`:<?,$! assert_eq_align!([i32; 4], i32);<KH The following example fails to compile because `i32x4` explicitly has 4&# times the alignment as `[i32; 4]`:5?,$! # #[allow(non_camel_case_types)] #[repr(align(16))] struct i32x4([i32; 4]);&# assert_eq_align!(i32x4, [i32; 4]);<C@ [FFI]: https://en.wikipedia.org/wiki/Foreign_function_interface&|     , 8x & 8$ ,   , 8xs& 8$  ,   $ - *   8,8 & 8       8# , 8, ' 8, ' 8mem ' 8D % ,   8 8 &      % 8D '  , 8F          % 8D '  , 8F    %  % % tܐ )& Asserts that types are equal in size.*.NK When performing operations such as pointer casts or dealing with [`usize`]}OL versus [`u64`] versus [`u32`], the size of your types matter. That is where this macro comes into play. # AlternativesOL There also exists [`assert_eq_size_val`](macro.assert_eq_size_val.html) andPM [`assert_eq_size_ptr`](macro.assert_eq_size_ptr.html). Instead of specifyingPM types to compare, values' sizes can be directly compared against each other.tLI These three types, despite being very different, all have the same size:<?,.+ assert_eq_size!([u8; 4], (u16, u16), u32);<PM The following example fails to compile because `u32` has 4 times the size ofL `u8`:5?, assert_eq_size!(u32, u8);<A> [`usize`]: https://doc.rust-lang.org/std/primitive.usize.html=: [`u64`]: https://doc.rust-lang.org/std/primitive.u64.html=: [`u32`]: https://doc.rust-lang.org/std/primitive.u32.html&| #     , 8F & 8 $ ,   , 8F & 8 $  ,   $ - *    8, 8 & 8        ,   8 8  , 8, ' 8, ' 8H ' 8L '  , 8F $ , 8F  %  % %  52 Asserts that values pointed to are equal in size. t   PM This especially is useful for when coercing pointers between different types 96 and ensuring the underlying values are the same size. <  ?, 0- fn operation(x: &(u32, u32), y: &[u16; 4]) { " assert_eq_size_ptr!(x, y);t  // ...,  }<   KH The following example fails to compile because byte arrays of different! lengths have different sizes:52/ # #[macro_use] extern crate static_assertions; # fn main() { static BYTES: &[u8; 4] = &[ /* ... */t # 0; 44 ];  static TABLE: &[u8; 16] = &[^| # 0; 164^&# assert_eq_size_ptr!(BYTES, TABLE);<&|2     , 8F & 8$$ ,   , 8F& 8$$  ,   $ - *   +   8,  8 unknown_lintsl$ 8 unsafe_code\$ 8 forget_copy\$ 8useless_transmute88  8"4  8#, 8,'8,'  8H$ 8 % 888$ 8 '8read$  , 8F % ,   8 '8write,   88$$ 8H'8L  8 '8d$  , 8F%  8H'84  8$% % *' Asserts that values are equal in size.?< This macro doesn't consume its arguments and thus works for non-[`Clone`]able values.t<2]^ struct Byte(u8); let x = 10u8;63 let y = Byte(42); // Works for non-cloneable types assert_eq_size_val!(x, y);# assert_eq_size_val!(x, y, 0u8);< # }<JG Even though both values are 0, they are of types with different sizes:52]^# assert_eq_size_val!(0u8, 0u32);<k<C@ [`Clone`]: https://doc.rust-lang.org/std/clone/trait.Clone.html&#A     , 8F & 8$$ ,   , 8F& 8$$  ,   $ - *  8    , 8F $ ,    , 8F$  % lԀ /, Asserts that the type has the given fields.0t4CGMJ One common use case is when types have fields defined multiple times as aHE result of `#[cfg]`. This can be an issue when exposing a public API.<2] pub struct Ty { #[cfg(windows)] pub val1: u8, #[cfg(not(windows))] pub val1: usize, #[cfg(unix)] pub val2: u32, #[cfg(not(unix))] pub val2: usize,,\*' // Always have `val2` regardless of OS assert_fields!(Ty: val2);</, This macro even works with `enum` variants:<?,| enum Data {l Val { id: i32,̆ name: String, bytes: [u8; 128],T }, Ptr(*const u8),,\)& assert_fields!(Data::Val: id, bytes);<b_ The following example fails to compile because [`Range`] does not have a field named `middle`:5?, use std::ops::Range;'$ assert_fields!(Range: middle);<   B? [`Range`]: https://doc.rust-lang.org/std/ops/struct.Range.html&| P    , 8t & 8, ' , 8v & 8, & ,   , 8 & 8, $  *    +   8,   8bl $ 8unneeded_field_pattern 8, 8 & 8        +   8,   8L $ 8unreachable_patterns 8  84   8, & , 8{   8, 8,   ,    , 8{ ' , 8|   , 8 & 8 $ ! *   $  8 *   % %    , 8{ & 8 $ & ,   , 8 & 8, $  *    +   8,   8bl $ 8} 8, 8 & 8      ,   8, 8{   , 8 & 8 $ !%  % % |\ DA Asserts that the type implements exactly one in a set of traits.EdI Related:V - [`assert_impl_any!`]q - [`assert_impl_all!`] - [`assert_not_impl_all!`] - [`assert_not_impl_any!`]tPM Given some type `Foo`, it is expected to implement either `Snap`, `Crackle`,l or `Pop`:5:7 # use static_assertions::assert_impl_one; fn main() {}| struct Foo; trait Snap {} trait Crackle {} trait Pop {}.+ assert_impl_one!(Foo: Snap, Crackle, Pop);<=: If _only_ `Crackle` is implemented, the assertion passes:<:ۈ # struct Foo; # trait Snap {} # trait Crackle {} # trait Pop {} impl Crackle for Foo {}.<B? If `Snap` or `Pop` is _also_ implemented, the assertion fails:5:ۈ͋ # impl Crackle for Foo {} impl Pop for Foo {}.<   85 [`assert_impl_any!`]: macro.assert_impl_any.html 85 [`assert_impl_all!`]: macro.assert_impl_all.html <9 [`assert_not_impl_all!`]: macro.assert_not_impl_all.html <9 [`assert_not_impl_any!`]: macro.assert_not_impl_any.html&| _     , 8F & 8 & ,   , 8{ & 8 $ $  ,   $ - *    8, 8 & 8        8, 8AmbiguousIfMoreThanOne  8A    8  8 some_itemL     ,     +   8,  8L848Token,% 8$ 8 & - 8, , 8{  8̓ 8, 8 8    88   , 8F 88̓ 8 '8L% % % ?< Asserts that the type implements _all_ of the given traits.C@ See [`assert_not_impl_all!`] for achieving the opposite effect.tOL This can be used to ensure types implement auto traits such as [`Send`] and@= [`Sync`], as well as traits with [blanket `impl`s][blanket].<?,&# assert_impl_all!(u32: Copy, Send);)& assert_impl_all!(&str: Into);<PM The following example fails to compile because raw pointers do not implement?< [`Send`] since they cannot be moved between threads safely:5?,&# assert_impl_all!(*const u8: Send);<<B? [`Send`]: https://doc.rust-lang.org/std/marker/trait.Send.htmlB? [`Sync`]: https://doc.rust-lang.org/std/marker/trait.Sync.htmlwt [blanket]: https://doc.rust-lang.org/book/ch10-02-traits.html#using-trait-bounds-to-conditionally-implement-methods&|n     , 8!$& 8& ,   , 8,& 8 $$  ,   $ - *   8,8 & 8      8 8| 8 & - 8,,    , 8,      8|' , 8!$   % % % '?< Asserts that the type implements _any_ of the given traits.C@ See [`assert_not_impl_any!`] for achieving the opposite effect.t  LI `u8` cannot be converted from `u16`, but it can be converted into `u16`: <  ?,!/, assert_impl_any!(u8: From, Into);, From, Send);<###P$MJ [`Send`] or [`Sync`] since they cannot be moved or shared between threads\$ safely:$$5%?,%,) assert_impl_any!(*const u8: Send, Sync);<%%&<&B'B؞&|'} ' : ' ( , '8F '& '8'& ', ( ( (, (8{ (& (8 $($ ( (, ( ( ($ (- (*( ( : 8,(8 (& (8 ( ( ( (( ( :68#(, (8,('(8,('(8 4('(8 PhantomData\(% (8#(, (8,(')8,)')8 )')8,)% )8)8previousD) )8AssertImplAnyFallback*% *84*8*% *84-8ActualAssertImplAnyToken-% -8,.8AssertImplAnyToken. . .8$.8.8 .8. . .8 .8assert_impl_any_token. /8 /& /8/ / / /8 /& /8 / / /, / / 78/8D/ / / 7184/8>OL Although `u32` implements `From`, it does not implement `Into`:><>>?,?63 assert_not_impl_all!(u32: From, Into););: Sync, Send);: Send); [`Cell`]: https://doc.rust-lang.org/std/cell/struct.Cell.htmlGw&|H H O H H , H8F H& H8H& H, H H H, H8{ H& H8 $H$ H H, H H H$ H- H*H H O 8,H8 I& I8 I I I II I O88,I8AmbiguousIfImpl|I I8 I I J J8 J8LJ J J J J8$K K8 K& K- K8,K K8|K K K K K8 K8 K K K+ L L L8,L L L8LL84L8Invalid, Into);, Into); u32;,\30 assert_obj_safe!(std::fmt::Write, MySafeTrait);<96 Works with traits that are not in the calling module:<?,| mod inner { pub trait BasicTrait { fn bar(&self);L  } %" assert_obj_safe!(BasicTrait);, \  (% assert_obj_safe!(inner::BasicTrait);<   NK The following example fails to compile because raw pointers cannot be sent  between threads safely:  5 ?, " assert_impl!(*const u8, Send);<   C@ The following example fails to compile because generics without OL `where Self: Sized` are not allowed in [object-safe][object] trait methods:  5 ?,  trait MyUnsafeTrait {  fn baz(&self) -> T;,\$! assert_obj_safe!(MyUnsafeTrait);<52 When we fix that, the previous code will compile:<?,0- fn baz(&self) -> T where Self: Sized;,\$<sp [object]: https://doc.rust-lang.org/book/ch17-02-trait-objects.html#object-safety-is-required-for-trait-objects&|    ,   , 8F& 8 $$  ,   $ - *  ,    8,8 & 84  , 8F  8$%  % d !A> Asserts that the trait is a child of all of the other traits.BdFS! - [`assert_trait_super_all!`]uty?< All types that implement [`Copy`] must implement [`Clone`]:<?,'$ assert_trait_sub_all!(Copy: Clone);<NK All types that implement [`Ord`] must implement [`PartialEq`], [`Eq`], and [`PartialOrd`]:<?,:7 assert_trait_sub_all!(Ord: PartialEq, Eq, PartialOrd);<MJ The following example fails to compile because [`Eq`] is not required for5?,*' assert_trait_sub_all!(PartialOrd: Eq);<B? [`assert_trait_super_all!`]: macro.assert_trait_super_all.htmlHE [`Copy`]: https://doc.rust-lang.org/std/marker/trait.Copy.htmlHE [`Clone`]: https://doc.rust-lang.org/std/clone/trait.Clone.htmlDA [`Ord`]: https://doc.rust-lang.org/std/cmp/trait.Ord.htmlKH [`PartialOrd`]: https://doc.rust-lang.org/std/cmp/trait.PartialOrd.html C@ [`Eq`]: https://doc.rust-lang.org/std/cmp/trait.Eq.html JG [`PartialEq`]: https://doc.rust-lang.org/std/cmp/trait.PartialEq.html&|      , 8 & 8 $ & ,   , 8, & 8 $ $  ,   $ - *   8, 8 &      ,     +   8,   8non_camel_case_types 8, 8__Impl_Implication & , 8,   8$  8 & , 8  8 8  8    % % #B? Asserts that the trait is a parent of all of the other traits.d - [`assert_trait_sub_all!`]tMJ With this, traits `A` and `B` can both be tested to require [`Copy`] on a single line:<41 # use static_assertions::assert_trait_super_all; trait A: Copy {} trait B: Copy {}(% assert_trait_super_all!(Copy: A, B);<;8 Otherwise, each sub-trait would require its own call to [`assert_trait_sub_all!`]:<?, # trait A: Copy {} # trait B: Copy {}# assert_trait_sub_all!(A: Copy);# assert_trait_sub_all!(B: Copy);<MJ The following example fails to compile because trait `C` does not requirel [`Copy`]:54t trait C {}+( assert_trait_super_all!(Copy: A, B, C);<>; [`assert_trait_sub_all!`]: macro.assert_trait_sub_all.htmlB? [`Copy`]: https://doc.rust-lang.org/std/marker/trait.Copy.html&#     , 8,& 8 $& ,   , 8& 8 $$  ,   $ - *  ,   8   , 8& , 8,%  % |\ ?< Asserts that _all_ types in a list are equal to each other.@tDSWPM Often times, type aliases are used to express usage semantics via naming. InPM some cases, the underlying type may differ based on platform. However, other;8 types like [`c_float`] will always alias the same type.<?, use std::os::raw::c_float;&# assert_type_eq_all!(c_float, f32);<MJ This macro can also be used to compare types that involve lifetimes! Just use `'static` in that case:<2]^ type Buf<'a> = &'a [u8];52 assert_type_eq_all!(Buf<'static>, &'static [u8]);<k<LI The following example fails to compile because `String` and `str` do not refer to the same type:5?,%" assert_type_eq_all!(String, str);<GD This should also work the other way around, regardless of [`Deref`] implementations.5?, %" assert_type_eq_all!(str, String);<   GD [`c_float`]: https://doc.rust-lang.org/std/os/raw/type.c_float.html A> [`Deref`]: https://doc.rust-lang.org/std/ops/trait.Deref.html&|      , 8F & 8 $ ,   , 8F & 8 $  ,   $  *    8, 8 & 8        ,     48, 8TypeEq4   8!$ 8$ & - 8, % 8$  8 & - 8,  8ޛ4 8  8   8!$ 8$  8$ % 8  8  8 $ 8U    8$, 8 & - 8,  8ޛ4  8$  8  $ 8 & - 8,$   8' , 8F $ , 8F   %  % % =: Asserts that _all_ types are **not** equal to each other.tMJ Rust has all sorts of slices, but they represent different types of data:<?,*' assert_type_ne_all!([u8], [u16], str);<NK The following example fails to compile because [`c_uchar`] is a type alias| for [`u8`]:5?, use std::os::raw::c_uchar;*' assert_type_ne_all!(c_uchar, u8, u32);<GD [`c_uchar`]: https://doc.rust-lang.org/std/os/raw/type.c_uchar.html;8 [`u8`]: https://doc.rust-lang.org/std/primitive.u8.html&|     , 8F & 8$ ,   , 8y & 8$  ,   $ - *   8,8 & 8       8,8MutuallyExclusive  8$88 , 8F   ,   8$88 , 8    % % d 9 6 Asserts that constant expressions evaluate to `true`.: >K H Constant expressions can be ensured to have certain properties via thisP M macro If the expression evaluates to `false`, the file will fail to compile.B ? This is synonymous to [`static_assert` in C++][static_assert].  M I F There also exists [`const_assert_eq`](macro.const_assert_eq.html) forJ G validating whether a sequence of expressions are equal to one another. t  N K A common use case is to guarantee properties about a constant value that's# generated via meta-programming. < ? ,  const VALUE: i32 = // ...D  # 3;   const_assert!(VALUE >= 2);<  ( % Inputs are type-checked as booleans:  5? ,  const_assert!(!0);<  B ? Despite this being a macro, we see this produces a type error: T  ```txt  | const_assert!(!0);? < | ^^ expected bool, found integral variable<  |"  = note: expected type `bool`' $ found type `{integer}`<   L I The following fails to compile because multiplying by 5 does not have an  identity property:  5 ? ,  const_assert!(5 * 5 == 5);<   L I [static_assert]: http://en.cppreference.com/w/cpp/language/static_assert&|   , 8F & 8$ ,  $ - *   +  8,  8bl $ 8eq_op, 8, 8 &   % 7   8, 8ASSERT4 & 8$ , 8F % 84 8 8,   % %   . + Asserts that constants are equal in value. t   : 7 This works as a shorthand for `const_assert!(a == b)`: < ? ,  const TWO: usize = 2; + ( const_assert_eq!(TWO * TWO, TWO + TWO);<  M J Just because 2 × 2 = 2 + 2 doesn't mean it holds true for other numbers:  5? ,# const_assert_eq!(4 + 4, 4 * 4);< &#        ,  8F  &  8$ $  ,  8  &  8$ ,     $  -  *    8d      ,  8F   ,  8  %  %   6 3 Asserts that constants are **not** equal in value. t  : 7 This works as a shorthand for `const_assert!(a != b)`: < ? ,  const NUM: usize = 32; $ ! const_assert_ne!(NUM * NUM, 64);<  Q N The following example fails to compile because 2 is magic and 2 × 2 = 2 + 2:  5? ,# const_assert_ne!(2 + 2, 2 * 2);< &#        ,  8F  &  8$ $  ,  8  &  8$ ,     $  -  *    8d      ,  8F   ,  8  %  %  -Rust 2018 editionBhttps://blog.rust-lang.org/2018/12/06/Rust-1.31-and-rust-2018.htmleach individual macroBanner CHANGELOG.md-https://github.com/nvzqz/static-assertions-rs compile-time*https://en.wikipedia.org/wiki/Compile_timeFhttps://github.com/nvzqz/static-assertions-rs/blob/master/CHANGELOG.md6https://blog.rust-lang.org/2019/08/15/Rust-1.37.0.html on crates.io*https://crates.io/crates/static_assertions Cargo.toml7https://doc.rust-lang.org/cargo/reference/manifest.html8https://en.wikipedia.org/wiki/Foreign_function_interfaceFFI$0https://doc.rust-lang.org/std/primitive.u32.htmlmacro.assert_eq_size_val.htmlmacro.assert_eq_size_ptr.htmlu4https://doc.rust-lang.org/std/clone/trait.Clone.html2https://doc.rust-lang.org/std/primitive.usize.html0https://doc.rust-lang.org/std/primitive.u64.htmluu3https://doc.rust-lang.org/std/ops/struct.Range.html0macro.assert_not_impl_all.htmlassert_not_impl_any!macro.assert_not_impl_any.html4https://doc.rust-lang.org/std/marker/trait.Send.html4https://doc.rust-lang.org/std/marker/trait.Sync.htmlassert_impl_any! blanket implsmacro.assert_impl_any.htmlassert_impl_all!macro.assert_impl_all.html2https://doc.rust-lang.org/book/ch10-02-traits.html3https://doc.rust-lang.org/std/cell/struct.Cell.htmlassert_not_impl_all!qqq object object-safe object-safety9https://doc.rust-lang.org/book/ch17-02-trait-objects.html0assert_trait_sub_all!macro.assert_trait_sub_all.htmlassert_trait_super_all!!macro.assert_trait_super_all.html4https://doc.rust-lang.org/std/marker/trait.Copy.htmlu0https://doc.rust-lang.org/std/cmp/trait.Ord.html6https://doc.rust-lang.org/std/cmp/trait.PartialEq.html/https://doc.rust-lang.org/std/cmp/trait.Eq.html7https://doc.rust-lang.org/std/cmp/trait.PartialOrd.htmluuc_float/https://doc.rust-lang.org/std/primitive.u8.html6https://doc.rust-lang.org/std/os/raw/type.c_float.html2https://doc.rust-lang.org/std/ops/trait.Deref.htmlc_uchar6https://doc.rust-lang.org/std/os/raw/type.c_uchar.html 7http://en.cppreference.com/w/cpp/language/static_assertmacro.const_assert_eq.htmlstatic_assert in C++֞R35ﲌ$pD[bZǦNLIP|284k9~4sŨQ܅!xҔZeмhh[}O6B^M*qV#~{O"bb="׆WR121;mӖiLrv#ne`e{9e&W2` o1sm B%WhՒȝqDYJx@M-\9fg'}܌Tb=Jc:Y$OWo&#%!%r",3$8<48B8BK$"R1](foFo.yG'y-.93/# k%88BoBy)))))))))))))))))))] #%*(06*8=BH#PUcPkox4y~ lFJLSk%%m,3 888BBK R\fno*yByր4+HPY#%*%06&8=BH PUbMkow0y~i_ #%*)06,8=BH$PUcQk ox6y~ mW%$8Bo.y ,EY`r3Pb{#*506=H0PUc]kx~ͅy)#Io^ ֞R35mi[W_sODHT @m B%~4sLIx@M-Ւ}܌Thh[}O Zeм Wh!xҔ \c:YvqDYJb="[b~{O"b6B^ ֞R35ﲌ$pDZǦN#ne`e{9e&W2mӖiLrM*qV# 9fg'84k9b=J` o1s׆WR121;P|2ŨQ܅o9d*'Fku,Z%1cw"' 9~%9_o9d*'E./external/rust/android-crates-io/crates/static_assertions/src/lib.rs ]f|<)Vͅ4a>^ Dn \ ONJKQ! P0  9$N**8QaL OOL-w +o HY8?LCh  'ϒhg8GDL./external/rust/android-crates-io/crates/static_assertions/src/assert_cfg.rs K86}68 1/Q@?3KQ@!R17FFOO-@),9*N  Bx L1Q./external/rust/android-crates-io/crates/static_assertions/src/assert_eq_align.rs %R|g++ -/OP:@1M@%L'@%'D$O.I MoQP./external/rust/android-crates-io/crates/static_assertions/src/assert_eq_size.rs RC=7u?{*OP PQQM@/Q @B>>$B 6Q:@1#L"3 !'"(M+*G +@37$K3$D$"(-70@9-` O./external/rust/android-crates-io/crates/static_assertions/src/assert_fields.rs fgD frwH0NI3+0@ *c@(C-86#4 "8& 3z `ZM./external/rust/android-crates-io/crates/static_assertions/src/assert_impl.rs 92UGDddE Q;/>;/C;/99==%M.L"OF@$LPMP.B @DPA@'*Q@@'=CCx,Q<( @DM@0P@5QN @-=CC%4+P2*NQM*O-(DE9KQD5%7 MM=/X18QLO!K LJNKGDP@7M @*Q@12@+CC=Bx#%J'L"9B) GPM;; LJNNQL<N)@60@1M<@5CC=x#%J'L"9QQ0$ GPM?; O;sC hQ./external/rust/android-crates-io/crates/static_assertions/src/assert_obj_safe.rs Isǘr~ox-L45~JMOOQN@4:@ &)O@#DP@%6@1%t*|"J=dBN./external/rust/android-crates-io/crates/static_assertions/src/assert_trait.rs 0ޛ fT DiB "@@(O@;N@+CIIELDK$-*/4K%: C N5)<@$$N5,?C$&-1 p4>bqאM./external/rust/android-crates-io/crates/static_assertions/src/assert_type.rs {Cؘ 6e@QQ<@'N 36M@&H@&HB"$!#+"*.->N@+O@+H<"#'-1 2UpaN./external/rust/android-crates-io/crates/static_assertions/src/const_assert.rs K짨İ|xm:LQCJKO$@ )@C @#(M@M'O/;@,N@$$"!7;@%R@$$"!1u8ea^( 9.׹wiF=/aarch64-linux-android'eC& 9static_assertions֞R35 ׃    `W   @ @ @@: @ @:W rust-end-filePQ>(/`>#%@M1\1 7U+ldY[DD!!2\ W:Z[ggC S3fn'ij(AX(E(EԊxr# C` X;OZk![7?A<y|˪:QUp4**,F,Ic[m%hC^(/` z ZK&3%C튢7)]3 ߸2.f&|QFG^IA~yiu { UQ1; ! *1 $KL  K , GAbionic/libc/arch-common/crtbrand.SHBend_so.S#NUggWj7 *3 Y 1em4*^1WZy(/ y}D8IfL,y&#c\>Qu2fȿx,Hj={Ka>i*-; HKN`cfi,lorux{~ ` 5I,  ` `hj<X.note.android.ident.note.gnu.build-id.dynsym.gnu.version.gnu.version_r.gnu.hash.hash.dynstr.rela.dyn.relr.dyn.rela.plt.eh_frame_hdr.eh_frame.text.plt.data.rel.ro.fini_array.dynamic.got.plt.relro_padding.comment.rustc.debug_loclists.debug_abbrev.debug_info.debug_rnglists.debug_str_offsets.debug_str.debug_addr.debug_line.debug_line_str.symtab.shstrtab.strtabstatic_assertions.351233de52bd9ed6-cgu.0$dcrtbegin_so.c__on_dlclose$x$x__on_dlclose_late$x$x$x$x$d$d$d$d$d$d$d$d$d$d$d$d$d$dabitag$d$d__FRAME_END__$d$drust_metadata_static_assertions_351233de52bd9ed6__dso_handle__cxa_finalize__emutls_unregister_key__atexit_handler_wrapperatexit__cxa_atexitpthread_atfork__register_atfork_DYNAMIC ( 88x0o =o Lo V0\00d`noxBH  <``D @@Pp0H0k<Y > H#)kP<0NG VS_B_0po"&ws