meetingroom-netscreen/anti_lockscreen_rust/target/release/deps/libmemoffset-13446141f1759c2a.rlib

!<arch>
/               0           0     0     0       8         `
//                                              68        `
memoffset-13446141f1759c2a.memoffset.be4897c6294cc1ad-cgu.0.rcgu.o/
lib.rmeta/      0           0     0     644     25066     `
d<EFBFBD>
<00>a
.rmeta<00>a<rust
`Brustc 1.91.1 (ed61e7d7e 2025-11-07) (Rev1, Built by MSYS2 project)<29><02>0<>#`a<><61>i<EFBFBD>+<2B>F<EFBFBD>T8<-0a5677bcdbf6ca93<39><02>1<>-<2D>3<EFBFBD><33>%<25>:<3A><>R<>-0a51333fad0e7ace<63>
<01>doc_comment<6E>\<5C><02><<3C>_memoffset__addr_of<6F><66><EFBFBD>
raw_ref_macros<6F>t<EFBFBD>

<05><>

_memoffset__field_check<63><6B><EFBFBD>
allow_clippy<70>d<EFBFBD>
t<>
_memoffset__field_check_tuple<6C><65><EFBFBD>

<01>d<>
t<>
_memoffset__field_check_union<6F><6E><EFBFBD>"

<01>d<>"
t<>"
_memoffset__let_base_ptr<74><72><EFBFBD><02>	d<>t<>_memoffset_offset_from_unsafe<66><65><EFBFBD><02><<3C>
unstable_const<73><74><EFBFBD>Եtests<74>,<2C>/<02>$<24>/
<01>,<2C>.<02>$<24>.
<02>

__priv<69>



size_of_pointee<65>
<02>
	raw_field<6C>

<01>


<01>

<01>

<01>

<01>
raw_field_tuple<6C>
raw_field_union<6F>
<02>

<01>

<01>
<02>
offset_of_tuple<6C>
offset_of_union<6F>
span_of<6F>
_memoffset__compile_error<6F>

<01>

<01><>_f

<02>
<04>
<02><>V<00><>_Ef



<01>

<01><08><>
,<2C><0B>$<24>

_ptr<74>


I


<02>




<01>
<01><>	

	

<01><02><>




<01><02><>



<01><02><>



<01>L<>(




<01>|<7C>.



<01>|<7C>7



<01>Đ



<01><03><>

<02>L<>


<01>|<7C>$


<01>|<7C>,


<01>̡



<01><<3C>

<04><><08>
<00><>KH A crate used for calculating offsets of struct members and their spans.<2E>
<1C>	<02>
<00><>	pm This functionality currently can not be used in compile time code such as `const` or `const fn` definitions.<2E>
<1C>
<02>
|<7C>
 ## Examples<65>
<<3C>
 ```<60>
<00><>
(% use memoffset::{offset_of, span_of};<3B>
<1C>
<02>
<00><>
 #[repr(C, packed)]<5D>
<00><>
-* struct HelpMeIAmTrappedInAStructFactory {<7B>
<00><>'$     help_me_before_they_: [u8; 15],<2C>
t<>     a: u32<33>
,<2C> }<7D>
<1C><02>
|<7C> fn main() {<7B>
<00><>HE     assert_eq!(offset_of!(HelpMeIAmTrappedInAStructFactory, a), 15);<3B>
<00><>JG     assert_eq!(span_of!(HelpMeIAmTrappedInAStructFactory, a), 15..19);<3B>
<00><>
a^     assert_eq!(span_of!(HelpMeIAmTrappedInAStructFactory, help_me_before_they_ .. a), 0..15);<3B>
,<2C>

<01>

<<3C>

<01>
<1C>
<02>
<00><>
MJ This functionality can be useful, for example, for checksum calculations:<3A>
<1C><02>
l<>
 ```ignore<72>
<00><>
<01>
<00><> struct Message {<7B>
<00><>     header: MessageHeader,<2C>
<00><>     fragment_index: u32,<2C>
<00><>     fragment_count: u32,<2C>
<00><>     payload: [u8; 1024],<2C>
<00><>     checksum: u16<31>
,<2C>
<01>

<1C><02>
<00><>C@ let checksum_range = &raw[span_of!(Message, header..checksum)];<3B>
<00><>)& let checksum = crc16(checksum_range);<3B>
<<3C>
<01><02><13>




<01>


	

<01>



<01>


<01>.


<01>=



<01>L


<01>[


<01>j


<01>y

<02><13>


<01><13>


<01><13>


<01><13>


<01><13>


t<><00><>74 Hidden module for things the macros need to access.<2E>

<02><1C>
<0C><0C>
8<02>4<>t<>4<>mem<65><1C>
<01>
<02><1C>
<01>
L<>#L<><18><>2<00><>^[ Use type inference to obtain the size of the pointee (without actually using the pointer).<2E>

<02><1C>
<0C><0C>
8<02>4<>t<>|<7C><02><08>

<02>



<01><>

<01><0C>


<01>

<01><13>l<>L<>
<00><>	 
<00><>A
> `addr_of!`, or just ref-then-cast when that is not available.<2E>

<02>	d<>	
|<7C>	


<02><1C>	

<0C>	
<0C>	

8<02>4<>	
t<>	

<0C>	
<0C>



<0C>

<0C>


,<0C>

8<02>$<24>


&<0C>

8<02>$<24>

*<14>


<0C>

<0C>





<0C>

<0C>



,<0C>

8,<2C>


'<14>

8
<01>4<>


'<14>

8<02><1C>


'<14>

8addr_of<6F><<3C>


	<0C>


<0C>

<0C>


,<0C>

8<02>$<24>

%<0C>

<00><>$
<00><>
$
! Deref-coercion protection macro.<2E><1C>

<02><00><>
J
G Prevents complilation if the specified field name is not a part of the<68><00><>

 struct definition.<2E><1C>
<02><00><>
 ```compile_fail<69><00><>+
( use memoffset::_memoffset__field_check;<3B><1C>
<02><00><>

 struct Foo {<7B><00><>
     foo: i32,<2C>,<2C>

<01>
<1C>
<02><00><>
 type BoxedFoo = Box<Foo>;<3B><1C>
<02><00><>,
) _memoffset__field_check!(BoxedFoo, foo);<3B><<3C>

<01>

<02>	d<>
|<7C>


<02><1C>

<0C>
<0C>

8<02>4<>
t<>
<0C>
<0C>


<0C>
<0C>

	,<0C>
8!$<24>

&<0C>
8<02>$<24>

$<0C>
,<0C>
8<02>,<2C>

&<0C>
8<02><14>
*<14>

<0C>
<0C>


+<0C>

<0C>
<0C>
8<02>,<2C>

<0C>
<0C>
8<02>4<>

'<14>
8unneeded_field_pattern<72><00><>
8<1C>
,<0C>
8!$<24>

<0C>
<0C>


,<0C>
8<02>,<2C>

&<0C>
8<0C>

$<0C>
!<14>
%<0C>
%<0C>
<00><>*
<00><>$

<01><1C>
<02><00><>?
< Prevents complilation if the specified type is not a tuple.<2E><1C>
<02><00><>

<01><00><>1
. use memoffset::_memoffset__field_check_tuple;<3B><1C>
<02><00><>+
( _memoffset__field_check_tuple!(i32, 0);<3B><<3C>

<01>

<02>	d<>
|<7C>


<02><1C>

<0C>
<0C>

8<02>4<>
t<>
<0C>
<0C>


<0C>
<0C>

	,<0C>
8!$<24>

&<0C>
8<02><14>

$<0C>
,<0C>
8<02>,<2C>

&<0C>
8<02><14>
*<14>

<0C>
<0C>


+<0C>

<0C>
<0C>
8<02>,<2C>

<0C>
<0C>
8<02>4<>

'<14>
8unneeded_wildcard_pattern<72><00><>
8<1C>

<0C>
<0C>

8<0C>

$<0C>
!<14>
&<0C>
,<0C>
8!$<24>

%<0C>
%<0C>
<00><>*
<00><>/
, Deref-coercion protection macro for unions.<2E><00><>K
H Unfortunately accepts single-field structs as well, which is not ideal,<2C><00><>#
  but ultimately pretty harmless.<2E><1C>
<02><00><>

<01><00><>1
. use memoffset::_memoffset__field_check_union;<3B><1C>
<02>|<7C>
 union Foo {<7B><00><>
     variant_a: i32,<2C>,<2C>

<01>
<1C>
<02><00><>

<01><1C>
<02><00><>8
5 _memoffset__field_check_union!(BoxedFoo, variant_a);<3B><<3C>

<01>

<02>	d<>
|<7C>


<02><1C>

<0C>
<0C>

8<02>4<>
t<>
.<0C>
<0C>"


<0C>
<0C>

	,<0C>
8!$<24>

&<0C>
8<02>$<24>

$<0C>
,<0C>
8<02>,<2C>

&<0C>
8<02><14>
*<14>

<0C>
<0C>"


+<0C> 

<0C> 
<0C> 
8<02>,<2C> 

<0C> 
<0C> 
8<02>4<> 

'<14> 
8
<01>&<00><> 
+<0C>!

<0C>!
<0C>!
8<02>,<2C>!

<0C>!
<0C>!

8
unused_unsafe<66>l<>!
8"4<>!

<0C>!
<0C>"

8<1C>"
,<0C>"
8!$<24>"

<0C>"
<0C>"


,<0C>"
8<02>,<2C>"

&<0C>"
8<0C>"
%<0C>"
%<0C>"
<00><>(
<00><>&M
J Computes a const raw pointer to the given field of the given base pointer<65><00><>&
 to the given parent type.<2E><1C>'
<02><00><>'D
A The `base` pointer *must not* be dangling, but it *may* point to<74><00><>'
 uninitialized memory.<2E>

<02>	d<>'

<0C>(
<0C>(

8<02>	<00><>(
<00><>'#
=<0C>(
<0C>,


<0C>(
<0C>(

,<0C>(
8base<73>$<24>(

&<0C>(
8<02>$<24>(

$<0C>(
,<0C>(
8parent<6E>4<>(

&<0C>(
8<02>$<24>(

$<0C>(
,<0C>(
8<02>,<2C>(

&<0C>(
8<02><14>(
*<14>(

<0C>(
<0C>,




<0C>(
<0C>,

8
<01><00><>(

	<0C>)

<0C>)
<0C>)


,<0C>)
8
<01>04<>)

$<0C>)
,<0C>)
8<02>,<2C>)
%<0C>)
8<1C>)
8
<01>0$<24>)
<0C>)
,<0C>)
8
<01>0$<24>)

%<0C>)
+<0C>+

<0C>+
<0C>+
8<02>,<2C>+

<0C>+
<0C>+

8
<01>,l<>+
8"4<>+

<0C>+
<0C>,

8
<01>
<00><>+

	<0C>,

<0C>,
<0C>,

<0C>,
<0C>,



<0C>,

<0C>,
<0C>,
8
<01>0$<24>,
8<14>,

<0C>,
8,<2C>,
,<0C>,
8
<01>04<>,
 <0C>,

,<0C>,
8<02>,<2C>,
%<0C>,
<00><>.
<00><>,M

<01>.<00><>-$
! to the given parent tuple typle.<2E><1C>-
<02><00><>-D

<01>/<00><>-

<01>/

<02>	d<>.

<0C>.
<0C>.

8<02>	<00><>.
<00><>.#
L<0C>.
<0C>2


<0C>.
<0C>/

,<0C>.
8
<01>0$<24>.

&<0C>.
8<02>$<24>.

$<0C>.
,<0C>.
8
<01>04<>.

&<0C>.
8<02><14>.

$<0C>/
,<0C>/
8<02>,<2C>/

&<0C>/
8<02><14>/
*<14>/

<0C>/
<0C>2




<0C>/
<0C>2

8
<01><00><>/

	<0C>/

<0C>/
<0C>/


,<0C>/
8
<01>04<>/

$<0C>/
,<0C>/
8<02>,<2C>/
%<0C>/
8<1C>/
8
<01>0$<24>/
<0C>/
,<0C>/
8
<01>0$<24>/

%<0C>/
+<0C>1

<0C>1
<0C>1
8<02>,<2C>1

<0C>1
<0C>1

8
<01>,l<>1
8"4<>2

<0C>2
<0C>2

8
<01>
<00><>2

	<0C>2

<0C>2
<0C>2

<0C>2
<0C>2



<0C>2

<0C>2
<0C>2
8
<01>0$<24>2
8<14>2

<0C>2
8,<2C>2
,<0C>2
8
<01>04<>2
 <0C>2

,<0C>2
8<02>,<2C>2
%<0C>2
<00><>7
<00><>2M

<01>.<00><>3$

<01>4<1C>3
<02><00><>3D

<01>/̬4

<01>/<1C>4
<02>\<5C>4
 ## Note<74><00><>4[
X This macro is the same as `raw_field`, except for a different Deref-coercion check that<61><00><>5
 supports unions.<2E><00><>5i

%<00><>TQ Macro to create a local `base_ptr` raw pointer of the given type, avoiding UB as<61><00><>	" much as is possible currently.<2E>

<02>	d<>	|<7C>	

<02><1C>	
<0C>	<0C>

8<02>4<>	t<>	j<0C>
<0C>

<0C>
<0C>

	,<0C>
8<02>
$<24>

&<0C>
8<02>,<2C>

$<0C>
,<0C>
8!$<24>

&<0C>
8<02><14>
*<14>

<0C>
<0C>


"8<1C>
8uninit<69>4<>
<0C>
,<0C>
8,<2C>

'<14>
8
<01>4<>

'<14>
8
<01><1C>

'<14>
8MaybeUninit<69>\<5C>

'<14>


<0C>

,<0C>
8!$<24>

<0C>

'<14>
8
<01>E4<>

<0C>
<0C>

%<0C>
8<1C>
,<0C>
8<02>
$<24>

&<0C>

<0C>
8,<2C>
,<0C>
8!$<24>
<0C>
8
<01>E4<>

 <0C>
8<02>4<>

<0C>
<0C>

%<0C>
%<0C>
<00><>*

<02>	d<>|<7C>

<02><1C>
<0C><0C>
8<02>4<>t<>y<0C><0C>

<0C><0C>
	,<0C>8<02>,<2C>
&<0C>8<02>$<24>
$<0C>,<0C>8
<01>0$<24>
&<0C>8<02>$<24>*<14>
<0C><0C>


<0C><0C>
,<0C>8<02>,<2C>8<14>8<02>,<2C><0C>
<0C><0C>
,<0C>8
<01>0$<24>8<14>8<02>,<2C>%<0C><00><><00><>TQ Calculates the offset of the specified field from the start of the named struct.<2E><1C><02>|<7C>
<01><<3C>
<01><00><> use memoffset::offset_of;<3B><1C><02><00><>
<01><00><>
<01>|<7C>     a: u32,<2C>|<7C>     b: u64,<2C><00><>     c: [u8; 5]<5D>,<2C>
<01>
<1C><02>|<7C>
<01>
<00><>*'     assert_eq!(offset_of!(Foo, a), 0);<3B><00><>*'     assert_eq!(offset_of!(Foo, b), 4);<3B>,<2C>
<01>
<<3C>
<01><1C><02>d<>	 ## Notes<65><00><>EB Rust's ABI is unstable, and [type layout can be changed with each<63><00><>GD compilation](https://doc.rust-lang.org/reference/type-layout.html).<2E><1C><02><00><>WT Using `offset_of!` with a `repr(Rust)` struct will return the correct offset of the<68><00><>RO specified `field` for a particular compilation, but the exact value may change<67><00><>VS based on the compiler version, concrete struct type, time of day, or rustc's mood.<2E><1C><02><00><>ZW As a result, the value should not be retained and used between different compilations.<2E>

<02>	d<>
<0C><0C>
8<02>	<00><><00><>#<13><0C><0C>!

<0C><0C>
	,<0C>8
<01>04<>
&<0C>8<02>$<24>
$<0C>,<0C>8<02>,<2C>
&<0C>8<02><14>*<14>
<0C><0C>!



<0C><0C>!
8
<01><00><>
	<0C> 
<0C> <0C> 
8base_ptr<74>D<> 
$<0C> ,<0C> 8
<01>04<> %<0C> 8<1C> 8	field_ptr<74>L<> <0C> 8
<01>L<> 
	<0C> 
<0C> <0C> 
8
<01>SD<> 
$<0C> ,<0C> 8
<01>04<> 
$<0C> ,<0C> 8<02>,<2C> %<0C> 8
<01><00><>!
	<0C>!
<0C>!<0C>!8
<01>TL<>!
$<0C>!8
<01>SD<>!%<0C>!<00><>$<00><>!MJ Calculates the offset of the specified field from the start of the tuple.<2E><1C>"<02>|<7C>"
<01><<3C>"
<01><00><>"#  use memoffset::offset_of_tuple;<3B><1C>"<02>|<7C>"
<01>
<00><>#\Y     assert!(offset_of_tuple!((u8, u32), 1) >= 0, "Tuples do not have a defined layout");<3B>,<2C>#
<01>
<<3C>#
<01>

<02>	d<>#
<0C>$<0C>$
8<02>	<00><>$<00><>##<13><0C>$<0C>'

<0C>$<0C>$
	,<0C>$8
<01>04<>$
&<0C>$8<02><14>$
$<0C>$,<0C>$8<02>,<2C>$
&<0C>$8<02><14>$*<14>$
<0C>$<0C>'



<0C>$<0C>'
8
<01>ķ%
	<0C>%
<0C>%<0C>%
8
<01>SD<>%
$<0C>%,<0C>%8
<01>04<>%%<0C>%8<1C>&8
<01>TL<>&<0C>&8
<01>|<7C>&
	<0C>&
<0C>&<0C>&
8
<01>SD<>&
$<0C>&,<0C>&8
<01>04<>&
$<0C>&,<0C>&8<02>,<2C>&%<0C>&8
<01><00><>&
	<0C>'
<0C>'<0C>'8
<01>TL<>'
$<0C>'8
<01>SD<>'%<0C>'<00><>,<00><>'TQ Calculates the offset of the specified union member from the start of the union.<2E><1C>'<02>|<7C>(
<01><<3C>(
<01><00><>(#  use memoffset::offset_of_union;<3B><1C>(<02><00><>(
<01>|<7C>(
<01>)<00><>(     foo32: i32,<2C><00><>(     foo64: i64,<2C>,<2C>)
<01>
<1C>)<02>|<7C>)
<01>
<00><>)30     assert!(offset_of_union!(Foo, foo64) == 0);<3B>,<2C>)
<01>
<<3C>)
<01><1C>)<02>\<5C>)
<01>:<00><>)if Due to macro_rules limitations, this macro will accept structs with a single field as well as unions.<2E><00><>*P
<01><<00><>+B
<01>=

<02>	d<>+
<0C>,<0C>,
8<02>	<00><>,<00><>+#<13><0C>,<0C>/

<0C>,<0C>,
	,<0C>,8
<01>04<>,
&<0C>,8<02>$<24>,
$<0C>,,<0C>,8<02>,<2C>,
&<0C>,8<02><14>,*<14>,
<0C>,<0C>/



<0C>,<0C>/
8
<01>Ĺ-
	<0C>-
<0C>-<0C>-
8
<01>SD<>-
$<0C>-,<0C>-8
<01>04<>-%<0C>-8<1C>.8
<01>TL<>.<0C>.8
<01>|<7C>.
	<0C>.
<0C>.<0C>.
8
<01>SD<>.
$<0C>.,<0C>.8
<01>04<>.
$<0C>.,<0C>.8<02>,<2C>.%<0C>.8
<01><00><>.
	<0C>/
<0C>/<0C>/8
<01>TL<>/
$<0C>/8
<01>SD<>/%<0C>/\<5C><<3C>
<00><>
&<00><>*' Reexport for `local_inner_macros`; see<65><00><>	ro <https://doc.rust-lang.org/edition-guide/rust-2018/macros/macro-changes.html#macros-using-local_inner_macros>.<2E>

<02><1C>	
<0C>	<0C>

8<02>4<>	t<>	

<02>	d<>
|<7C>
<13><0C>
<0C>

<0C>
<0C>

,<0C>

<0C>
<0C>


,<0C>
8inner<65>,<2C>

&<0C>
8<02><14>

<0C>
*<14>

<0C>
<0C>
8<02>l<>

	<0C>

<0C>
<0C>

,<0C>

<0C>
<0C>


,<0C>
8
<01>e,<2C>

<0C>
<00><><00><>YV Produces a range instance representing the sub-slice containing the specified member.<2E><1C><02><00><>=: This macro provides 2 forms of differing functionalities.<2E><1C><02><00><>LI The first form is identical to the appearance of the `offset_of!` macro.<2E><1C><02>l<>
<01><00><>
 span_of!(Struct, member)<29><<3C>

<01><1C>
<02><00><>
eb The second form of `span_of!` returns a sub-slice which starts at one field, and ends at another.<2E><00><>(% The general pattern of this form is:<3A><1C><02>l<>
<01><00><>
 // Exclusive<76><00><>*' span_of!(Struct, member_a .. member_b)<29><00><>
 // Inclusive<76><00><>+( span_of!(Struct, member_a ..= member_b)<29><1C><02><00><> // Open-ended ranges<65><00><> span_of!(Struct, .. end)<29><00><> span_of!(Struct, start ..)<29><<3C>
<01><1C><02>d<>	 ### Note<74><00><>_\ This macro uses recursion in order to resolve the range expressions, so there is a limit to<74><00><>%" the complexity of the expression.<2E><00><>QN In order to raise the limit, the compiler's recursion limit should be lifted.<2E><1C><02>t<> ### Safety<74><00><>^[ The inter-field form mentioned above assumes that the first field is positioned before the<68>\<5C> second.<2E><00><>2/ This is only guarenteed for `repr(C)` structs.<2E><00><>]Z Usage with `repr(Rust)` structs may yield unexpected results, like downward-going ranges,<2C><00><>he spans that include unexpected fields, empty spans, or spans that include *unexpected* padding bytes.<2E><1C><02>|<7C>
<01><<3C>
<01>ܥ use memoffset::span_of;<3B><1C><02>t<> #[repr(C)]<5D><00><> struct Florp {<7B>t<>
<01>
,<2C>
<01>
<1C><02>t<>
<01>s<00><> struct Blarg {<7B><00><>     x: [u32; 2],<2C><00><>     y: [u8; 56],<2C><00><>     z: Florp,<2C><00><>     egg: [[u8; 4]; 4]<5D>,<2C>
<01>
<1C><02>|<7C>
<01>
<00><>0-     assert_eq!(0..84,  span_of!(Blarg, ..));<3B><00><>2/     assert_eq!(0..8,   span_of!(Blarg, .. y));<3B><00><>30     assert_eq!(0..64,  span_of!(Blarg, ..= y));<3B><00><>/,     assert_eq!(0..8,   span_of!(Blarg, x));<3B><00><>2/     assert_eq!(8..84,  span_of!(Blarg, y ..));<3B><00><>41     assert_eq!(0..8,   span_of!(Blarg, x .. y));<3B><00><>52     assert_eq!(0..64,  span_of!(Blarg, x ..= y));<3B>,<2C>
<01>
<<3C>
<01>

<02>	d<>
<0C><0C>
8<02>	<00><><00><>#<13><0C><0C>.
4
<0C><0C>
	<0C>8helper<65>4<>,<0C>8root<6F>$<24>
&<0C>8<02>,<2C>
$<0C>
<0C><0C>#<1C>*<14>
<0C><0C>

8
<01><00><>
	<0C>
<0C><0C>
7Expected a range, found '..='<27><00><>%<0C>
<0C><0C>
	<0C>8
<01>y4<>,<0C>8
<01>y$<24>
&<0C>8<02>,<2C>
$<0C>
<0C><0C>!<14>*<14>
<0C><0C>

8
<01><00><>
	<0C>
<0C><0C>
7Expected a range, found '..'<27><00><>%<0C>
<0C><0C>
<0C>8
<01>y4<>,<0C>8
<01>y$<24>
&<0C>8<02>,<2C>
$<0C>,<0C>8
<01>04<>
&<0C>8<02>$<24>
$<0C>
<0C><0C>!<14>*<14>
<0C><0C>



<0C><0C>


<0C><0C>
,<0C>8
<01>y$<24>8<14>8<02>,<2C>
$<0C>,<0C>8
<01>y$<24>8<14>8<02>,<2C><0C>,<0C>8,<2C>
'<14>8
<01>4<>
'<14>8
<01>|<7C>
<0C><0C>
,<0C>8
<01>y$<24>%<0C>
<0C><0C>
<0C>8
<01>y4<>,<0C>8
<01>y$<24>
&<0C>8<02>,<2C>
$<0C>,<0C>8
<01>04<>
&<0C>8<02>$<24>
$<0C>
<0C><0C>#<1C>,<0C>8<02><1C>
&<0C>8<02><14>*<14>
<0C><0C>



<0C><0C>
8<1C>8<02><1C><0C>8
<01>L<>
	<0C>
<0C><0C>

,<0C>8
<01>y$<24>
$<0C>,<0C>8
<01>04<>
$<0C>,<0C>8<02><1C>%<0C>
<0C><0C>
,<0C>8
<01>y$<24>8<14>8<02>,<2C>
$<0C>8<02><1C>8<14>8<02>,<2C><0C>,<0C>8,<2C>
'<14>8
<01>4<>
'<14>8
<01>|<7C>
<0C><0C>
8<02><1C>%<0C>
<0C><0C>
<0C>8
<01>y4<>,<0C>8
<01>y$<24>
&<0C>8<02>,<2C>
$<0C>,<0C>8
<01>04<>
&<0C>8<02>$<24>
$<0C>
<0C><0C>!<14>,<0C>8<02><1C>
&<0C>8<02><14>*<14>
<0C><0C> 



<0C><0C> 


<0C><0C> 

,<0C>8
<01>y$<24>8<14>8<02>,<2C>
$<0C>8
<01>L<>
	<0C> 
<0C> <0C> 
,<0C> 8
<01>y$<24> 
$<0C> ,<0C> 8
<01>04<> 
$<0C> ,<0C> 8<02><1C> 8<14> 8<02>,<2C> %<0C> 
<0C> <0C>!
<0C> 8
<01>y4<> ,<0C> 8
<01>y$<24> 
&<0C> 8<02>,<2C> 
$<0C> ,<0C> 8
<01>04<> 
&<0C> 8<02>$<24> 
$<0C>!+<0C>!,<0C>!8begin<69>,<2C>!
&<0C>!8<02><14>!
<0C>!<0C>!#<1C>!,<0C>!8<02><1C>!
&<0C>!8<02><14>!*<14>!
<0C>!<0C>"



<0C>!<0C>"
8<1C>!8
<01><>
,<2C>!<0C>!8
<01>L<>!
	<0C>!
<0C>!<0C>!

,<0C>!8
<01>y$<24>!
$<0C>!,<0C>!8
<01>04<>!
$<0C>!,<0C>!8
<01><>
,<2C>!%<0C>!8<1C>!8<02><1C>!<0C>!8
<01>L<>!
	<0C>!
<0C>!<0C>"

,<0C>!8
<01>y$<24>!
$<0C>!,<0C>"8
<01>04<>"
$<0C>",<0C>"8<02><1C>"%<0C>"
<0C>"<0C>"8
<01><>
,<2C>"8<14>"8<02>,<2C>"
$<0C>"8<02><1C>"8<14>"8<02>,<2C>"<0C>",<0C>"8,<2C>"
'<14>"8
<01>4<>"
'<14>"8
<01>|<7C>"
<0C>"<0C>"
8<02><1C>"%<0C>"
<0C>"<0C>#
<0C>"8
<01>y4<>",<0C>"8
<01>y$<24>"
&<0C>"8<02>,<2C>"
$<0C>",<0C>#8
<01>04<>#
&<0C>#8<02>$<24>#
$<0C>#+<0C>#,<0C>#8
<01><>
,<2C>#
&<0C>#8<02><14>#
<0C>#<0C>#!<14>#,<0C>#8<02><1C>#
&<0C>#8<02><14>#*<14>#
<0C>#<0C>$



<0C>#<0C>$


<0C>#<0C>$8
<01>L<>#
	<0C>#
<0C>#<0C>#
,<0C>#8
<01>y$<24>#
$<0C>#,<0C>#8
<01>04<>#
$<0C>#,<0C>#8
<01><>
,<2C>#8<14>#8<02>,<2C>#
$<0C>#8
<01>L<>#
	<0C>#
<0C>#<0C>$
,<0C>#8
<01>y$<24>#
$<0C>#,<0C>$8
<01>04<>$
$<0C>$,<0C>$8<02><1C>$8<14>$8<02>,<2C>$%<0C>$
<0C>$<0C>$
<0C>$8
<01>y4<>$,<0C>$8
<01>y$<24>$
&<0C>$8<02>,<2C>$
$<0C>$,<0C>$8
<01>04<>$
&<0C>$8<02>$<24>$
$<0C>$+<0C>$,<0C>$8
<01><>
,<2C>$
&<0C>$8<02><14>$
<0C>$<0C>$!<14>$*<14>$
<0C>%<0C>&



<0C>%<0C>&


<0C>%<0C>%8
<01>L<>%
	<0C>%
<0C>%<0C>%
,<0C>%8
<01>y$<24>%
$<0C>%,<0C>%8
<01>04<>%
$<0C>%,<0C>%8
<01><>
,<2C>%8<14>%8<02>,<2C>%
$<0C>%,<0C>%8
<01>y$<24>%8<14>%8<02>,<2C>%<0C>%,<0C>%8,<2C>%
'<14>%8
<01>4<>%
'<14>%8
<01>|<7C>%
<0C>%<0C>%
,<0C>%8
<01>y$<24>%%<0C>&
<0C>&<0C>&
<0C>&8
<01>y4<>&,<0C>&8
<01>y$<24>&
&<0C>&8<02>,<2C>&
$<0C>&,<0C>&8
<01>04<>&
&<0C>&8<02>$<24>&
$<0C>&+<0C>&,<0C>&8
<01><>
,<2C>&
&<0C>&8<02><14>&
<0C>&<0C>&#<1C>&*<14>&
<0C>&<0C>'



<0C>&<0C>'
8
<01><00><>&
	<0C>&
<0C>&<0C>'
7QFound inclusive range to the end of a struct. Did you mean '..' instead of '..='?<3F><00><>&S%<0C>'
<0C>'<0C>(
<0C>'8
<01>y4<>',<0C>'8
<01>y$<24>'
&<0C>'8<02>,<2C>'
$<0C>(,<0C>(8
<01>04<>(
&<0C>(8<02>$<24>(
$<0C>(+<0C>(,<0C>(8<02>,<2C>(
&<0C>(8<02><14>(
<0C>(<0C>(*<14>(
<0C>(<0C>)



<0C>(<0C>)
8<1C>(8<02>,<2C>(<0C>(8
<01>L<>(
	<0C>(
<0C>(<0C>(

,<0C>(8
<01>y$<24>(
$<0C>(,<0C>(8
<01>04<>(
$<0C>(,<0C>(8<02>,<2C>(%<0C>(
<0C>(<0C>)8<02>,<2C>(8<14>(8<02>,<2C>(
$<0C>(8<02>,<2C>(8<14>(8<02>,<2C>)<0C>),<0C>)8,<2C>)
'<14>)8
<01>4<>)
'<14>)8
<01>|<7C>)
<0C>)<0C>)
8<02>,<2C>)%<0C>)
<0C>)<0C>*
<0C>)8
<01>y4<>),<0C>)8
<01>y$<24>)
&<0C>)8<02>,<2C>)
$<0C>),<0C>)8
<01>04<>)
&<0C>)8<02>$<24>)
$<0C>),<0C>)
<0C>)<0C>)

+<0C>),<0C>)8
<01><>
,<2C>)
&<0C>)8<02><14>)<0C>*
<0C>*<0C>*,<0C>*8<02><14>*
&<0C>*8<02><14>*,<0C>*
<0C>*<0C>*

,<0C>*8rest<73>$<24>*
&<0C>*8<02><14>*
<0C>**<14>*
<0C>*<0C>*



<0C>*<0C>*
8
<01><<3C>*
	<0C>*
<0C>*<0C>*
<0C>*8
<01>y4<>*,<0C>*8
<01>y$<24>*
$<0C>*,<0C>*8
<01>04<>*
$<0C>*,<0C>*
<0C>*<0C>*

+<0C>*
,<0C>*8
<01><>
,<2C>*
<0C>*+<0C>*
,<0C>*8<02><14>*
<0C>*<0C>*,<0C>*
<0C>*<0C>*

,<0C>*8
<01><>
$<24>*
<0C>*%<0C>*
<0C>*<0C>+
<0C>*8
<01>y4<>*,<0C>*8
<01>y$<24>*
&<0C>+8<02>,<2C>+
$<0C>+,<0C>+8
<01>04<>+
&<0C>+8<02>$<24>+
$<0C>+
<0C>+<0C>+,<0C>+8<02><14>+
&<0C>+8<02><14>+,<0C>+
<0C>+<0C>+

,<0C>+8
<01><>
$<24>+
&<0C>+8<02><14>+
<0C>+*<14>+
<0C>+<0C>+



<0C>+<0C>+
8
<01><<3C>+
	<0C>+
<0C>+<0C>+
<0C>+8
<01>y4<>+,<0C>+8
<01>y$<24>+
$<0C>+,<0C>+8
<01>04<>+
$<0C>++<0C>+
,<0C>+8<02><14>+
<0C>+<0C>+,<0C>+
<0C>+<0C>+

,<0C>+8
<01><>
$<24>+
<0C>+%<0C>+
<0C>,<0C>,
,<0C>,8sty<74><1C>,
&<0C>,8<02>$<24>,
$<0C>,,<0C>,
<0C>,<0C>,

,<0C>,8exp<78><1C>,
&<0C>,8<02><14>,<0C>,*<14>,
<0C>,<0C>.


<0C>,<0C>.
8
<01><00><>,
	<0C>,
<0C>,<0C>,
8
<01>y$<24>,
$<0C>,,<0C>,8
<01><>
<1C>,%<0C>,8<1C>-8
<01>0$<24>-<0C>-8
<01>y$<24>-8<14>-8<02>,<2C>-
%<0C>-8<1C>-
<0C>-<0C>-
<EFBFBD>u<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>s<EFBFBD><08><><EFBFBD><1A>yub/_<>p<EFBFBD><70><EFBFBD><EFBFBD><EFBFBD>Ƽ<EFBFBD><C6BC>*&<26>})@<40>k<EFBFBD>	<09>Q<EFBFBD>f<EFBFBD><66><EFBFBD>m%<25><><EFBFBD>K<EFBFBD><4B><EFBFBD>^5;<02><>9<EFBFBD><39>T<>
<01>2<EFBFBD>%mx#@}vq]^
<EFBFBD>4<07><><EFBFBD><EFBFBD>G<EFBFBD>@_<><5F><06>6<EFBFBD><36><EFBFBD><EFBFBD>G<EFBFBD>J<EFBFBD>E<><45>5<1B><08>/]<5D><1D><><EFBFBD>]r<>Mm$<24>t<EFBFBD><74><EFBFBD>g<EFBFBD>1<0C>m<><0C>o(_FאM<D790>:<3A><><EFBFBD><05>
R
<01>$<00>
<00>w<0C><0C>
)<11>S<1A>
6!C!<21>#<23>$<24>*<2A>-<2D>1<>1D@3

Q
>!<00>1


)))))))
)))))
))
P(}
<0A>\<12>&<18><!"$)!,<2C>/<2F>1<EFBFBD>2e<<3C><04>
<EFBFBD>
<EFBFBD>
w}<0B>fs<0C>
$<11>O<1A>2!>!<21>#<23>$<24>*<2A>-<2D>1<EFBFBD>1@3<00>
L{<0B>hy
<0A>Y<12>#<18>8!"<22>#),<2C>/<2F>1<EFBFBD>2b<Fp3jX)
*rs<00><00>
_
<0C>	Jw6!<00>1WZaervz<02><02><02><02><02><02><02><02><02><02><02>(>Ll	
<0A>]<12>'<18>"$)",<2C>/<00>2f<<00>`S

<13><13>
<13><13>

<02><00><>L)ƗH<C697><48><EFBFBD>m<>i<>	X<>W<EFBFBD>W<EFBFBD>W<EFBFBD>W<EFBFBD>W<EFBFBD>W<EFBFBD>ODHT
  <02><><00>G<EFBFBD>@_<><5F><00>1<0C>m<><0C>o(_FאM<>:<3A><><EFBFBD><05><00>J<EFBFBD>E<><45>5<00><>L)ƗH<C697><00>p<EFBFBD><70><EFBFBD><EFBFBD><EFBFBD><EFBFBD><00><><EFBFBD><1B><><EFBFBD>
<00><>s<EFBFBD><08><><EFBFBD>^
<EFBFBD>4<07><><EFBFBD><1B><08>/]<5D>
<EFBFBD>u<EFBFBD><EFBFBD><EFBFBD><EFBFBD>T<>
<01>2<EFBFBD>%m
m$<24>t<EFBFBD><74><EFBFBD>g<1A>yub/_<00><><EFBFBD>*&<26>}<00>Tr)7<><37><EFBFBD>x#@}vq];<02><>9<EFBFBD><39>ҳtFZX<5A><58>)@<40>k<EFBFBD>	<09>Q	<06>6<EFBFBD><36><EFBFBD><EFBFBD>G<00><>K<EFBFBD><4B><EFBFBD>^5<00>f<EFBFBD><66><EFBFBD>m%<25>
<1D><><EFBFBD>]r<>MRHX<48>_c
j|<7C><><EFBFBD><EFBFBD>X<EFBFBD><58>?63/>l
s(#W&RHX<48>_c
j|<7C><><EFBFBD><EFBFBD>X]C:\Users\dxzq\.cargo\registry\src\index.crates.io-1949cf8c6b5b557f\memoffset-0.7.1\src\lib.rs<72> Y5RS<52>v<EFBFBD>!<21>i<><69><EFBFBD>ӗ<00>\
#PQPMI<R3NLOJQQ

Lq).(IKbND*

 7


8
c9



<00><><EFBFBD><EFBFBD><EFBFBD><06><><EFBFBD>-<2D><>l<>{cC:\Users\dxzq\.cargo\registry\src\index.crates.io-1949cf8c6b5b557f\memoffset-0.7.1\src\raw_field.rs<72> ?<3F><><EFBFBD><15>_U?"Oz<><00><<3C>

.PQPMI<R3NLOJQQ

B#-#[C
%K,-'!IK1%'!IK%
%@2,-24-2
0L$29-!IK4X %
-!IKX %

NE$03G
"R,QE

N%E$.9G
"R,QE

N%E\jQC$09G
"R,QE
07?#C<><43>N<EFBFBD>(E!4cC:\Users\dxzq\.cargo\registry\src\index.crates.io-1949cf8c6b5b557f\memoffset-0.7.1\src\offset_of.rs<72> Mۃ<4D><DB83><EFBFBD><EFBFBD><EFBFBD><EFBFBD>&^Ӝ6K)<00>R<EFBFBD>
#PQPMI<R3NLOJQQ

U#(!@EDB%J3(!KPN
8#-$JGPdP(-#-
U++
FHXSW[$$N6?<
N$]$"N6E<
U$4jQC$$N6E<



+++
C 

+++

++
U

111


0
!!
/&

(
%$'
.0


$LLL
 $$%
0J0J0J
 

$RRR
'

6
')&

6
'&


-`<03><>U<EFBFBD><55><EFBFBD><1E><><EFBFBD>-M<>jaC:\Users\dxzq\.cargo\registry\src\index.crates.io-1949cf8c6b5b557f\memoffset-0.7.1\src\span_of.rs<72> <20>><3E><><EFBFBD><EFBFBD><EFBFBD>e<EFBFBD><65>g:<3A><><EFBFBD><00>C<EFBFBD>
#PQPMI<R3NLOJQQ

+s)&
Z>Mf)+,
`&R_3^i1340356$(D&C$5B>4N=D)J84NI64"A6BB$a>8RVHF<
#/"F




,,0
C

,,0




$.0G
23




/0/10123C!8!8
!8#:"5#Rd"e<10>2<EFBFBD><04><>B*<2A>K=<3D><00>Y<EFBFBD>Zf\k^x86_64-pc-windows-gnu<6E>"<22><><EFBFBD>s`<60><><EFBFBD>!<21><>)	memoffset<65>-13446141f1759c2a<32><61><EFBFBD>L)ƗH<C697>ſ

R	
<00><>


<00>

KE
222

.22"W<04>rust-end-file@feat.00<00><>/0              0           0     0     644     1980      `
BC<EFBFBD><EFBFBD>5b0$JY<4A><59>]<5D><><EFBFBD>Q<>L
!<00>
!"<07>#<23>A<EFBFBD>I29<32>
<01>%<04>b<EFBFBD>EB<>BD28K
2"<22>H<EFBFBD>d!C<><43>G2B$q<>$)@<40><>K
2d<32><08> #B<><42>B*(*<2A>Q\ #<23>@<40><19><07>"<22><>$2b,9Ȑ#<23><12>:dDG<44>"CF<00> 	"f<10>B<EFBFBD><42>RB<52><42><EFBFBD>q<EFBFBD>PH
	&B<>B"&<08><><EFBFBD>90*|<7C>;<3B>;<3B><>6<EFBFBD><36>qh<71>{Hw <20>w<EFBFBD><77>yh<79>sp<73>z<EFBFBD><7A>
<EFBFBD><EFBFBD><06><><07><><06> wz0r<>s mrpq<>s z0r<><06> w z`t<>v@m<>v@z`t<><06>r<>zr<>m`xzr<>m<>x<>q`z0r<>v@m0q x<><11><><0C><><EFBFBD><EFBFBD>l<EFBFBD><6C><EFBFBD>.q<><71><EFBFBD><EFBFBD><EFBFBD>6Y<36>6<1E><><EFBFBD><EFBFBD><EFBFBD>\w<>$6U
<00>
2<1E>L<><4C>	&G<>C<> <20><00><00>3<08><1C><>f
=<3D>C8<43>ÌB<C38C>yxs<>q<0C><0F><0E><>3B<1E><>Ρf0=<3D>C8<43><38><1B>=<3D>C=<3D>=<3D>x<EFBFBD>tp{yH<79>ppzpvx<76>p <20><19><0E><><0E>0n0<0F><><0E>P3<10><1D>!<1C>!<1D>af0<66>;<3B><>;<3B>C9<43><<3C><><<3C>;<3B><>v`{h7h<37>rh7<><37>p<EFBFBD><70>p`v(v<>vx<76>w<EFBFBD><77>_<08>q<18>r<EFBFBD><72>y<EFBFBD><79>,<2C><><0E><><0E><><0E>0bȡ<1C><>̡<1C><><1C>a<1C>!ā<1D>a֐C9<43>C9<43>C9<43>C9<43><39>8<EFBFBD>C8<43>;<3B><>/<2F><><<3C><>;<3B>;<3B><><0C>i<EFBFBD>pX<70>rp<72>thx`<60>t<18>t<EFBFBD><74><19>S<0F><0F>P<0E><><0E>@<0F> <0E>P3 (<1D><><1E>A<1E>!܁<1E><><1C><><1D>
fQ8<51>C:<3A><>;<3B>P$v`{h7`<60>wxx<>QL<51><4C><0F>P3j<1E>a<1C>!<1D><>~
<1E><><1C>!<1D>aT<><54>8<EFBFBD><38>;<3B>C=<3D>C9<43><39><<3C>C;<3B><>;<3B>Ì<EFBFBD>
<EFBFBD>y<EFBFBD><EFBFBD>w<18>tz(r<><72>\<5C><0E><><0E>P<0E>0#<23><>A<1E><><17><><1D>
fH;<3B><>=<3D><><1B><>8<EFBFBD>C9<43><39><<3C><>9<EFBFBD><39>;<3B><<3C>H<EFBFBD>qv`q<08>qX<71><19><><0E>`<0F><><06> <0F>0<0F> <0F>Pn<0E>0<0E>0<0F><><06><><0E>P<0E>0#<23><>a<1D><><17>!<1D>!<1D>!<1D>!<1D>!f <20>;<3B>C=<3D>9<><39>9<EFBFBD>X<EFBFBD>ppwxzzH<7A>wp<77><19><><0E>0<0F><><0E>@<0F><><0F>0<EFBFBD>
s<>w<18>_<EFBFBD><5F>pp<70>t<EFBFBD><74>tЇr<D087><72><EFBFBD>A9<41><39>8<EFBFBD>C=<3D>C9<43>@Ġʡ<1D>A<1E><>f$c0<0E><><0E>0<0F>@<0F>0C!<21>usH<73>_<EFBFBD><5F>|<7C><>r<EFBFBD><72><EFBFBD>
<<3C><><<3C><>8<EFBFBD>C:<3A><>;<3B>Ì<EFBFBD>H!Ba<1E>!<1D><>R<>fLg0<0E> <0F><><06>P<0F>0<0F>@<0E><><06> <0F><><0E>0<EFBFBD>@<40>vhy<08>R<1A><>;<3B>;<3B>C8̃<1B>9<><39><<3C><<3C><>8<EFBFBD>y .<00>H C<>	dd<64><64> <20><>2FFF<13>B<EFBFBD><42><EFBFBD><EFBFBD><EFBFBD>9B<39><42><EFBFBD>@<40><00>*PIC Levelrustc version 1.91.1 (ed61e7d7e 2025-11-07) (Rev1, Built by MSYS2 project)#
0<>3C@<40>2<12><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>\<5C><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>\<5C><><EFBFBD><EFBFBD><EFBFBD>F	<09>T<EFBFBD><54><EFBFBD><EFBFBD>\<5C><><EFBFBD><EFBFBD><EFBFBD>F	
<00>-
r(<28>w<EFBFBD>zXp<58>C=<3D><>8<EFBFBD>C9<43>Â<EFBFBD>ơ
<0A>A<1E><><1D>!<1D>!<1D><>4<>`<0E>P<0F> <0F>@<0F> <0F>P<0E><><EFBFBD><EFBFBD>y(<28>p`vx<76>qz(rXp<58><70>8<EFBFBD>
;<3B><>=<3D><>k<1C>!<1C><><1C> <1C>a<1C> <1C><><1E>aС<1C>a<1D>a<EFBFBD>
<0F> <0F>P<0F><><0B>usH<73><05>8<EFBFBD><38>;<3B>C9<43><39>9<EFBFBD><39>;<3B>C9<43>=<3D>;<00><07><<3C><>;<3B>;<3B>=<3D><><<3C>C8<43><38>
<00> <00><04>P
q 2"<00>
<EFBFBD>oo|
<0A><><EFBFBD>qv<71><76><EFBFBD><EFBFBD><7F><EFBFBD>Ͽ<EFBFBD><03><>y<EFBFBD>e<03><>/L
XXX/D dX]<03><>21.1.5 9d6fa8947717509929b0a1e24a2234495514302bx86_64-pc-windows-gnumemoffset.be4897c6294cc1ad-cgu.0