meetingroom-netscreen/push_screen_rust/target/x86_64-pc-windows-gnu/debug/deps/libmemoffset-49e9c6105127798a.rmeta

rust
e_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><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>z




<01>
<13>
	

<01><13>



<01><13>


<01><13>


<01><13>



<01><13>


<01><13>


<01><13>


<01>


<02>


<01>


<01>.


<01>=


<01>L


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>

<02>



<01><>

<01><0C>


<01>
_ptr<74>$<24>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<>	
<13><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<>
<13><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<>
<13><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<>
<13><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><>'#
<13><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>/$<24>)
<0C>)
,<0C>)
8
<01>/$<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>/$<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><>.#
<13><0C>.
<0C>2


<0C>.
<0C>/

,<0C>.
8
<01>/$<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>/$<24>/
<0C>/
,<0C>/
8
<01>/$<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>/$<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>3<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
f Due to macro_rules limitations, this check will accept structs with a single field as well as unions.<2E><00><>6P
M This is not a stable guarantee, and future versions of this crate might fail<69><00><>7B
? on any use of this macro with a struct, without a semver bump.<2E>

<02>	d<>7

<0C>7
<0C>7

8<02>	<00><>7
<00><>7#
<13><0C>8
<0C><


<0C>8
<0C>8

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

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

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

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

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

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

<0C>8
<0C><




<0C>8
<0C><

8
<01><00><>8

	<0C>8

<0C>8
<0C>8


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

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

%<0C>9
+<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>/$<24>;
8<14>;

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

,<0C>;
8<02>,<2C>;
%<0C><
l<>L<>
<00><>
%<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<>	<13><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>D4<>

<0C>
<0C>

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

&<0C>

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

 <0C>
8<02>4<>

<0C>
<0C>

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

<02>	d<>|<7C>

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

<0C><0C>
	,<0C>8<02>,<2C>
&<0C>8<02>$<24>
$<0C>,<0C>8
<01>/$<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>/$<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><>#<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>RD<> 
$<0C> ,<0C> 8
<01>04<> 
$<0C> ,<0C> 8<02>,<2C> %<0C> 8
<01><00><>!
	<0C>!
<0C>!<0C>!8
<01>SL<>!
$<0C>!8
<01>RD<>!%<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><>##<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>RD<>%
$<0C>%,<0C>%8
<01>04<>%%<0C>%8<1C>&8
<01>SL<>&<0C>&8
<01>|<7C>&
	<0C>&
<0C>&<0C>&
8
<01>RD<>&
$<0C>&,<0C>&8
<01>04<>&
$<0C>&,<0C>&8<02>,<2C>&%<0C>&8
<01><00><>&
	<0C>'
<0C>'<0C>'8
<01>SL<>'
$<0C>'8
<01>RD<>'%<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>9<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><>+#.<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>RD<>-
$<0C>-,<0C>-8
<01>04<>-%<0C>-8<1C>.8
<01>SL<>.<0C>.8
<01>|<7C>.
	<0C>.
<0C>.<0C>.
8
<01>RD<>.
$<0C>.,<0C>.8
<01>04<>.
$<0C>.,<0C>.8<02>,<2C>.%<0C>.8
<01><00><>.
	<0C>/
<0C>/<0C>/8
<01>SL<>/
$<0C>/8
<01>RD<>/%<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>
=<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>d,<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>r<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><>#L<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>x4<>,<0C>8
<01>x$<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>x4<>,<0C>8
<01>x$<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>x$<24>8<14>8<02>,<2C>
$<0C>,<0C>8
<01>x$<24>8<14>8<02>,<2C><0C>,<0C>8,<2C>
'<14>8
<01>4<>
'<14>8
<01>|<7C>
<0C><0C>
,<0C>8
<01>x$<24>%<0C>
<0C><0C>
<0C>8
<01>x4<>,<0C>8
<01>x$<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>x$<24>
$<0C>,<0C>8
<01>04<>
$<0C>,<0C>8<02><1C>%<0C>
<0C><0C>
,<0C>8
<01>x$<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>x4<>,<0C>8
<01>x$<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>x$<24>8<14>8<02>,<2C>
$<0C>8
<01>L<>
	<0C> 
<0C> <0C> 
,<0C> 8
<01>x$<24> 
$<0C> ,<0C> 8
<01>04<> 
$<0C> ,<0C> 8<02><1C> 8<14> 8<02>,<2C> %<0C> 
<0C> <0C>!
<0C> 8
<01>x4<> ,<0C> 8
<01>x$<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>x$<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>x$<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>x4<>",<0C>"8
<01>x$<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>x$<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>x$<24>#
$<0C>#,<0C>$8
<01>04<>$
$<0C>$,<0C>$8<02><1C>$8<14>$8<02>,<2C>$%<0C>$
<0C>$<0C>$
<0C>$8
<01>x4<>$,<0C>$8
<01>x$<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>x$<24>%
$<0C>%,<0C>%8
<01>04<>%
$<0C>%,<0C>%8
<01><>
,<2C>%8<14>%8<02>,<2C>%
$<0C>%,<0C>%8
<01>x$<24>%8<14>%8<02>,<2C>%<0C>%,<0C>%8,<2C>%
'<14>%8
<01>4<>%
'<14>%8
<01>|<7C>%
<0C>%<0C>%
,<0C>%8
<01>x$<24>%%<0C>&
<0C>&<0C>&
<0C>&8
<01>x4<>&,<0C>&8
<01>x$<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>x4<>',<0C>'8
<01>x$<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>x$<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>x4<>),<0C>)8
<01>x$<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>x4<>*,<0C>*8
<01>x$<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>x4<>*,<0C>*8
<01>x$<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>x4<>+,<0C>+8
<01>x$<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>x$<24>,
$<0C>,,<0C>,8
<01><>
<1C>,%<0C>,8<1C>-8
<01>/$<24>-<0C>-8
<01>x$<24>-8<14>-8<02>,<2C>-
%<0C>-8<1C>-
<0C>-<0C>-
O<EFBFBD>_e:hw<68>{Ma<4D>[l8Ҏ;<3B>h<EFBFBD>\d<>T<EFBFBD>.<2E>>ll<6C>?z<><7A>Yx<59>P<>y<EFBFBD><79>]X'i'<27><>vӜЃ<D39C>3A)R<><18>a<EFBFBD>o+ѥ
<V<><56>|!~<7E>Ct<43>.[ْч<D992>.b_<02>])<29>I<>1,$4<><34><EFBFBD><0E>gz<><7A>'!_*<2A>Tp<54>z<EFBFBD><7A><EFBFBD>	<00>
^$l
	w
<0A>$<13><16><19>
<1C> <20> Z#<23>$U*K-!1.1<>@2<>	<00>

<00> )1


)))))))
)))))
))<29>	<00>
<00><0C>v<0F><15>j<1A><1E> <20>!<21>#<23>(<28>+<2B>/'12<>;Xb
f
h
<EFBFBD>
<0B>r
<0A><13><16><19><1C> <20> U#<23>$Q*G-1)1<>2d
<00>
	<0B><0B><0C>s<0F><15>g<1A><1E> <20>!<21>#<23>(<28>+<2B>/#12<>;<00><00><0B><00><00>
<00><00>
<00>
<0B>	<00>
	<00> !1WZaervz<02><02><02><02><02><02><02><02><02><02><02>(>Ll<00>w<0F> <15>k<1A><00>!<21>#<23>(<28>+<2B>/2<>;<00>R

zz
zz

<02><00>"'<27><1B>㫌<EFBFBD>m<>i<>UWWW
W.WWEW<45>ODHT
  <02><>f(_`<60>$ӜЃ<D39C>3o+ѥ
<V<><00>.b_<02>])P<>y<EFBFBD><79>]X
~K<1B><><00><>
<00>/^&y<>
<00>;<3B>h<EFBFBD>\d<>
'i'<27><>v<00>|!~<7E>Ct<43>*<2A>Tp<54>z<EFBFBD><7A>?z<><7A>Yx<59><00>:<3A>il<69><6C>z<00>$<24>M:<3A><><00>I<>1,$4<><34><EFBFBD><0E>gz<><7A>'!_A)R<><18>a<EFBFBD>.[ْчO<>_e:hw<68>{Ma<4D>[l8<6C>	<00>"'<27><1B><><EFBFBD><03><><EFBFBD>Y`<60>T<>.<2E>>ll<6C><00>P?X<><58><EFBFBD><EFBFBD>c,Of;MG<4D>g=<3D><>}3/<2F><><EFBFBD><EFBFBD>CZiUzuwc,Of;MG<4D>g=<3D><>]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



.*<2A>zN<7A>
<01>}~̼bM<62>&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
<00>q<EFBFBD>Wx~<17><>}<7D><><02>%cC:\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
'&


-ۀ<>/S͑<1C>dp x<>XaC:\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#R<00>A˨\<5C>ϡ<EFBFBD>(<28>-<15><>9Y/Z<>[<5B>]x86_64-pc-windows-gnu<6E>ʛPf<50><19>b<EFBFBD><62>=nP޵	memoffset<65>-49e9c6105127798a<38><61>"'<27><1B><><EFBFBD><02><>

R	
ѥ


<00>
KE
222

.22"W<04>rust-end-file