📄 libbyteorder_lite-b23754f5d3aa0269.rmeta
/home/palash/git/iron_learn/target/debug/deps/libbyteorder_lite-b23754f5d3aa0269.rmeta
Language: rmeta • Lines: 3831
rust
��#rustc 1.92.0 (ded5c06cf 2025-12-08)���	ⷄ�ۆ��p��-225863f279df55c4��١�	�T�6a��D�
-5080178c80bf7a93��uӰ]����d��!�-06039bcfba61f665��**�٭T��HО�9�-3e2e950d4bac10b5��	�t�#3Ҵη��Ǣ-d25e598578fbf080�rustc_std_workspace_core������Nm��gmY���-327ea4f353b4eb8c���y.:i���gy"1�r-94fdfaf0af91a65d�miniz_oxide�M�^�yTLm�L�d=B-5312b588e5cfab93�adler2��;~�7�ɴ,P?���-1e0b0d62df36c85c�	hashbrown�L�ϫ	2݆y��q-2ed6a8f06fc51a9d�rustc_std_workspace_alloc�a���p��H����6Z�-05b02707a5b2a256�
std_detect�	c�LN����=1�ʶӐ-5978f0713dd5442d�rustc_demangle�X�Fq��UՃ�>7z
��-43b2ff22c18e1125�cfg_if�֦<����ɐ¬�-6a40188dd7d989d2�	addr2line���,2�!xb�"6�!�	-11d54e777384a9e5�gimli��2��I.�ġ�����-35018e994bad7042�object��T �f��Y�
hQec-2dc10b344e05b569�memchr��xZT9�C��I�Mg�-09f2ab7e0d97e07a��~ݤ	����h���-932f22f820d1e5ec�NativeEndian�d���l��big�,ύ����$���$��stdtests�D���$���io�					ReadBytesExt�read_u8�read_i8�read_u16��read_i16��read_u24��read_i24��read_u32��read_i32�"�"read_u48�%�%read_i48�(�(read_u64�+�+read_i64�.�.	read_u128�1�1	read_i128�4�4	read_uint�7�7read_int�:�:read_uint128�=�=read_int128�@�@read_f32�C�Cread_f64�F�F	IR�	
WriteBytesExt�Kwrite_u8�Kwrite_i8�K	write_u16�N�NK	write_i16�Q�QK	write_u24�T�TK	write_i24�W�WK	write_u32�Z�ZK	write_i32�]�]K	write_u48�`�`K	write_i48�c�cK	write_u64�f�fK	write_i64�i�iK
write_u128�l�lK
write_i128�o�oK
write_uint�r�rK	write_int�u�uK
write_uint128�x�xKwrite_int128�{�{K	write_f32�~�~K	write_f64����	�W�extend_sign�extend_sign128�
unextend_sign�unextend_sign128�	pack_size�pack_size128�private��Sealed���	ByteOrder���	��	��
��
��
��������
��
��������������	��	��
��
��������������
�������������������
read_u16_into��
read_u32_into��
read_u64_into��read_u128_into��
read_i16_into��
read_i32_into��
read_i64_into��read_i128_into��
read_f32_into��read_f32_into_unchecked��
read_f64_into��read_f64_into_unchecked��write_u16_into��write_u32_into��write_u64_into��write_u128_into��
write_i8_into��write_i16_into��write_i32_into��write_i64_into��write_i128_into��write_f32_into��write_f64_into��from_slice_u16��from_slice_u32��from_slice_u64��from_slice_u128��from_slice_i16��from_slice_i32��from_slice_i64��from_slice_i128��from_slice_f32��from_slice_f64��>BE��>LE�
NetworkEndian��
read_slice�write_slice���	��
��
����������
������������������������������������������������������������������������	��
��
����������
����������������������������������������������������������������������	BigEndian�����������	��
����LittleEndian�
�����������������SIZE���"��"��"��"��"��"��"��"��"��"��"��"��"��"��"��"��"��"��"��"��"��"��"��"��"��"��"��"��"��"��"��"��"��"��"��"��"��"��"8888888"8%8(8+8.8184878:8=8@8C8F8L8M8N8Q8T8W8Z8]8`8c8f8i8l8o8r8u8x8{8~8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8K���
K��������=�����ᑍ'q���6��6�_�6��6�`�6��6���6��6�6��6�6��6��5��5�_�5��5�`�5��5���5��5�5��5�5��5��6��5I��������������������������������������������������K����_��`��������

+�:6=1��
�:+�:6=1��
�:+�:6=2��"
�:+�:6=2��(
�:+�:6=3��.
�:+�:6=3��4
�:!+�:6=4��;
�:$+�:6=4��A
�:'+�:6=6��H
�:*+�:6=6��N
�:-+�:6=8��U
�:0+�:6=8��\
�:3+�:6=16��c
�:6+�:6=16��i
�:9+�:6=8��o
�:<+�:6=8��r
�:?+�:6=16��t
�:B+�:6=16��|
�:E+�:6=4����:H,�:7>8����:P,�:7>2����:S,�:7>2�«�:V,�:7>3����:Y,�:7>3���:\,�:7>4����:_,�:7>4����:b,�:7>6����:e,�:7>6����:h,�:7>8����:k,�:7>8����:n,�:7>16����:q,�:7>16����:t,�:7>8����:w,�:7>8����:z,�:7>16����:},�:7>16����:�-�:8?4����:�-�:8?8����:�-�:8?8���:�-�:8?16��*��
�*��
�(�*��0��:(*��)_��,��
�,��
�(�,��0��:(,��)_��.��
�.��
�(�.��0��:(.��)_��0��
�0��
�(�0��0��:(0��)_��2��
�2��
�(�2��0��:(2��)_��4��
�4��
�(�4��0��:(4��)_��6��
�6��
�(�6��0��:(6��)_��8��
�8��
�(�8��0��:(8��)_��:��
�:��
�(�:��0��:(:��)_��<��
�<��
�(�<��0��:(<��)_��>��
�>���S"�>��0��:(>��)_��@��
�@���T"�@��0��:(@��)_��B��
�B���U"�B��0��:(B��)_��D��
�D���V"�D��0��:(D��)_��F��
�F���W"�F��0��:(F��)_��H��
�H���W"�H��0��:(H��)_��J��
�J���X"�J��0��:(J��)_��L��
�L���Y"�L��0��:(L��)_��N��
�N���Z"�N��0��:(N��)_��P��
�P���["�P��0��:(P��)_����:�-�:8?8����:�-�:8?16��h��
�h���S"�h��0��:(h��)_��j��
�j���T"�j��0��:(j��)_��l��
�l���U"�l��0��:(l��)_��n��
�n���V"�n��0��:(n��)_��p��
�p���W"�p��0��:(p��)_��r��
�r���W"�r��0��:(r��)_��t��
�t���X"�t��0��:(t��)_��v��
�v���Y"�v��0��:(v��)_��x��
�x���Z"�x��0��:(x��)_��z��
�z���["�z��0��:(z��)_��|��
�|���S"�|��0��:(|��)_��~��
�~���T"�~��0��:(~��)_�؀��
Ȁ���U$����0��:(���+_�؂��
Ȃ���V$����0��:(���+_�؄��
Ȅ���W$����0��:(���+_�؆��
Ȇ���W$����0��:(���+_�؈��
Ȉ���X$����0��:(���+_�؊��
Ȋ���Y$����0��:(���+_�،��
Ȍ���Z$����0��:(���+_�؎��
Ȏ���[$����0��:(���+_�	����������������,��_��_�$��`��`�d��
l�K������

This crate is a fork of the [`byteorder`] crate which sets
`#![forbid(unsafe_code)]`. It includes all traits and most methods from the
original crate, but the `ReadBytesExt::read_*_into` family of methods had to be
removed because they currently cannot be implemented without unsafe code.

The organization of the crate is pretty simple. A trait, [`ByteOrder`], specifies
byte conversion methods for each type of number in Rust (sans numbers that have
a platform dependent size like `usize` and `isize`). Two types, [`BigEndian`]
and [`LittleEndian`] implement these methods. Finally, [`ReadBytesExt`] and
[`WriteBytesExt`] provide convenience methods available to all types that
implement [`Read`] and [`Write`].

An alias, [`NetworkEndian`], for [`BigEndian`] is provided to help improve
code clarity.

An additional alias, [`NativeEndian`], is provided for the endianness of the
local platform. This is convenient when serializing data for use and
conversions are not desired.

# Examples

Read unsigned 16 bit big-endian integers from a [`Read`] type:

```rust
use std::io::Cursor;
use byteorder_lite::{BigEndian, ReadBytesExt};

let mut rdr = Cursor::new(vec![2, 5, 3, 0]);
// Note that we use type parameters to indicate which kind of byte order
// we want!
assert_eq!(517, rdr.read_u16::<BigEndian>().unwrap());
assert_eq!(768, rdr.read_u16::<BigEndian>().unwrap());
```

Write unsigned 16 bit little-endian integers to a [`Write`] type:

```rust
use byteorder_lite::{LittleEndian, WriteBytesExt};

let mut wtr = vec![];
wtr.write_u16::<LittleEndian>(517).unwrap();
wtr.write_u16::<LittleEndian>(768).unwrap();
assert_eq!(wtr, vec![5, 2, 0, 3]);
```

# Optional Features

This crate can also be used without the standard library.

# Alternatives

The standard numeric types provide built-in methods like `to_le_bytes` and
`from_le_bytes`, which support some of the same use cases.

[`byteorder`]: https://crates.io/crates/byteorder
[`ByteOrder`]: trait.ByteOrder.html
[`BigEndian`]: enum.BigEndian.html
[`LittleEndian`]: enum.LittleEndian.html
[`ReadBytesExt`]: trait.ReadBytesExt.html
[`WriteBytesExt`]: trait.WriteBytesExt.html
[`NetworkEndian`]: type.NetworkEndian.html
[`NativeEndian`]: type.NativeEndian.html
[`Read`]: https://doc.rust-lang.org/std/io/trait.Read.html
[`Write`]: https://doc.rust-lang.org/std/io/trait.Write.html
�	����������������	��	�_��	�_��	�`��	�`��	�
�	KJ
M
P
��T�K
T�-
��(


	
4��K�$�	�4�	�L)�	
�6	)+�"�� �5GD Extends [`Read`] with methods for reading numbers. (For `std::io`.)�}���NK Most of the methods defined here have an unconstrained type parameter that���NK must be explicitly instantiated. Typically, it is instantiated with either���FC the [`BigEndian`] or [`LittleEndian`] types defined in this crate.���t� # Examples�����=: Read unsigned 16 bit big-endian integers from a [`Read`]:���\� ```rust��� use std::io::Cursor;���2/ use byteorder_lite::{BigEndian, ReadBytesExt};�����0- let mut rdr = Cursor::new(vec![2, 5, 3, 0]);���:7 assert_eq!(517, rdr.read_u16::<BigEndian>().unwrap());���:7 assert_eq!(768, rdr.read_u16::<BigEndian>().unwrap());�<� ```�����&# [`BigEndian`]: enum.BigEndian.html���,) [`LittleEndian`]: enum.LittleEndian.html���>; [`Read`]: https://doc.rust-lang.org/std/io/trait.Read.html�d������}���D��)���5��)"%(+.147:=@CF"%(+.147:=@CF7:=@"C%F(+.14��
#��?< Reads an unsigned 8 bit integer from the underlying reader.�����GD Note that since this reads a single byte, no byte order conversions���.+ are used. It is included for completeness.���d�	 # Errors�����@= This method returns the same errors as [`Read::read_exact`].��	���	\Y [`Read::read_exact`]: https://doc.rust-lang.org/std/io/trait.Read.html#method.read_exact��
�t�
��
���
/, Read unsigned 8 bit integers from a `Read`:��
�\�ݍđ����%" use byteorder_lite::ReadBytesExt;�����*' let mut rdr = Cursor::new(vec![2, 5]);���*' assert_eq!(2, rdr.read_u8().unwrap());���*' assert_eq!(5, rdr.read_u8().unwrap());�<���<�
������������������������q�aX�����
�"�f+�c�

��$�
~�:��#��<9 Reads a signed 8 bit integer from the underlying reader.�����G����.���d�������@Õ����\����t������-* Read signed 8 bit integers from a `Read`:���\�ݍđ����%������0- let mut rdr = Cursor::new(vec![0x02, 0xfb]);���*' assert_eq!(2, rdr.read_i8().unwrap());���+( assert_eq!(-5, rdr.read_i8().unwrap());�<���<�������������������������q�aXɛ�
��$���:��3��@= Reads an unsigned 16 bit integer from the underlying reader.���d�������@Õ����\����t������;8 Read unsigned 16 bit big-endian integers from a `Read`:���\�ݍĩ����2������0׎��:����:ӏ<���D�������������������������q�aX�Sɛ��������L�
���$�') �:��!3��=: Reads a signed 16 bit integer from the underlying reader.���d�������@Õ����\����t������96 Read signed 16 bit big-endian integers from a `Read`:���\�ݍ������2������<9 let mut rdr = Cursor::new(vec![0x00, 0xc1, 0xff, 0x7c]);��� :7 assert_eq!(193, rdr.read_i16::<BigEndian>().unwrap());��� ;8 assert_eq!(-132, rdr.read_i16::<BigEndian>().unwrap());�<�!��D�!������������������������q�aX�Wɛ��!ۥ�!�L�!
���$�!!q�:��'3��"@= Reads an unsigned 24 bit integer from the underlying reader.��#�d�#���#���#@Õ�#���$\���$�t�$��%���%;8 Read unsigned 24 bit big-endian integers from a `Read`:��%�\�%ݍ��%����&2���&���&63 let mut rdr = Cursor::new(vec![0x00, 0x01, 0x0b]);���&:7 assert_eq!(267, rdr.read_u24::<BigEndian>().unwrap());�<�'��D�'������������������������q�aX�Tɛ��'ۥ�'�L�'
���$�'!��:��-3��(=: Reads a signed 24 bit integer from the underlying reader.��)�d�)���)���)@Õ�*���*\���+�t�+��+���+96 Read signed 24 bit big-endian integers from a `Read`:��+�\�+ݍ��+����,2���,���,63 let mut rdr = Cursor::new(vec![0xff, 0x7a, 0x33]);���-=: assert_eq!(-34253, rdr.read_i24::<BigEndian>().unwrap());�<�-��D�-������������������������q�aX�Wɛ��.ۥ�-�L�.
���$�.!�:��43��/@= Reads an unsigned 32 bit integer from the underlying reader.��/�d�/���/���/@Õ�0���0\���1�t�1��1���1;8 Read unsigned 32 bit big-endian integers from a `Read`:��2�\�2ݍġ2����22���2���2<9 let mut rdr = Cursor::new(vec![0x00, 0x00, 0x01, 0x0b]);���3:7 assert_eq!(267, rdr.read_u32::<BigEndian>().unwrap());�<�3��D�4�������  �4ۥ�4�L�4
���$�4!d�:��:3��5=: Reads a signed 32 bit integer from the underlying reader.��5�d�6���6���6@Õ�6���6\���7�t�7��7���796 Read signed 32 bit big-endian integers from a `Read`:��8�\�8ݍ��8����82���9���9<9 let mut rdr = Cursor::new(vec![0xff, 0xff, 0x7a, 0x33]);���9=: assert_eq!(-34253, rdr.read_i32::<BigEndian>().unwrap());�<�:��D�:�������##�:ۥ�:�L�:
"���$�:!�""�:��@3��;@= Reads an unsigned 48 bit integer from the underlying reader.��<�d�<���<���<@Õ�=���=\���=�t�=��>���>;8 Read unsigned 48 bit big-endian integers from a `Read`:��>�\�>ݍ��>����?2���?���?HE let mut rdr = Cursor::new(vec![0xb6, 0x71, 0x6b, 0xdc, 0x2b, 0x31]);���@FC assert_eq!(200598257150769, rdr.read_u48::<BigEndian>().unwrap());�<�@��D�@������������������������q�aX�Uɛ�&&�Aۥ�A�L�A
%���$�A!%%�:��G3��B=: Reads a signed 48 bit integer from the underlying reader.��B�d�B���B���B@Õ�C���C\���D�t�D��D���D96 Read signed 48 bit big-endian integers from a `Read`:��E�\�EݍĤE����E2���E���FHE let mut rdr = Cursor::new(vec![0x9d, 0x71, 0xab, 0xe7, 0x97, 0x8f]);���FGD assert_eq!(-108363435763825, rdr.read_i48::<BigEndian>().unwrap());�<�G��D�G������������������������q�aX�Xɛ�))�Gۥ�G�L�G
(���$�G!W((�:��M3��H@= Reads an unsigned 64 bit integer from the underlying reader.��I�d�I���I���I@Õ�I���J\���J�t�J��K���K=: Read an unsigned 64 bit big-endian integer from a `Read`:��K�\�Kݍ��K����L2���L���LTQ let mut rdr = Cursor::new(vec![0x00, 0x03, 0x43, 0x95, 0x4d, 0x60, 0x86, 0x83]);���MFC assert_eq!(918733457491587, rdr.read_u64::<BigEndian>().unwrap());�<�M��D�N�������,,�Nۥ�N�L�N
+���$�N!�++�:��T3��O=: Reads a signed 64 bit integer from the underlying reader.��O�d�O���O���P@Õ�P���P\���Q�t�Q��Q���Q:7 Read a signed 64 bit big-endian integer from a `Read`:��R�\�RݍīR����R2���R���S?< let mut rdr = Cursor::new(vec![0x80, 0, 0, 0, 0, 0, 0, 0]);���SGD assert_eq!(i64::min_value(), rdr.read_i64::<BigEndian>().unwrap());�<�T��D�T�������//�Tۥ�T�L�T
.���$�T!�..�:��[5��UA> Reads an unsigned 128 bit integer from the underlying reader.��V�d�V���V���V@Õ�V���W\���W�t�W��X���X>; Read an unsigned 128 bit big-endian integer from a `Read`:��X�\�Xݍ��X����Y2���Y���Y#  let mut rdr = Cursor::new(vec![���Y74     0x00, 0x03, 0x43, 0x95, 0x4d, 0x60, 0x86, 0x83,���Z63     0x00, 0x03, 0x43, 0x95, 0x4d, 0x60, 0x86, 0x83�<�Z ]);���Z[X assert_eq!(16947640962301618749969007319746179, rdr.read_u128::<BigEndian>().unwrap());�<�[��L�[������������������������q�aX�Vɛ�22�\ۥ�[�L�[
1���$�\!J 11�:��b5��]>; Reads a signed 128 bit integer from the underlying reader.��]�d�]���]���]@Õ�^���^\���_�t�_��_���_;8 Read a signed 128 bit big-endian integer from a `Read`:��`�\�`ݍĘ`����`2���`���`WT let mut rdr = Cursor::new(vec![0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]);���aIF assert_eq!(i128::min_value(), rdr.read_i128::<BigEndian>().unwrap());�<�b��L�b������������������������q�aX�Yɛ�55�bۥ�b�L�b
4���$�b!� 44�:��hC��cA> Reads an unsigned n-bytes integer from the underlying reader.��d�d�d���d���d@Õ�e���e\���e�t�e��f���f=: Read an unsigned n-byte big-endian integer from a `Read`:��f�\�fݍ��f����g2���g���g63 let mut rdr = Cursor::new(vec![0x80, 0x74, 0xfa]);���h@= assert_eq!(8418554, rdr.read_uint::<BigEndian>(3).unwrap());�L�h�����:���88�hۥ�h�L�h
7���$�hnbytes�4�h-/� 77�:��oB��j>; Reads a signed n-bytes integer from the underlying reader.��j�d�j���k���k@Õ�k���k\���l�t�l��l���l=���m�\�mݍĶm����m2���n���n63 let mut rdr = Cursor::new(vec![0xc1, 0xff, 0x7c]);���n@= assert_eq!(-4063364, rdr.read_int::<BigEndian>(3).unwrap());�D�o�����:���;;�oۥ�o�L�o
:���$�o��4�o(*?!::�:��qG��pA��d�q�����:���>>�qۥ�q�L�q
=���$�q��4�q(*�!==�:��sF��s>��\�s�����:���AA�tۥ�s�L�s
@���$�t��4�t(*�!@@�:��{3��uIF Reads a IEEE754 single-precision (4 bytes) floating point number from�ԉv the underlying reader.��v�d�v���v���v@Õ�w���w\���w�t�w��x���xKH Read a big-endian single-precision floating point number from a `Read`:��x�\�xݍ��y use std::f32;�Ęy���y���y2���y���y#����z     0x40, 0x49, 0x0f, 0xdb,�<�z����zFC assert_eq!(f32::consts::PI, rdr.read_f32::<BigEndian>().unwrap());�<�{��D�{������������������������q�aX�Zɛ�DD�{ۥ�{�L�{
C���$�{!4"CC�:���3��|IF Reads a IEEE754 double-precision (8 bytes) floating point number from�Ԩ}���}�d�}���}���}@Õ�~���~\����t������KH Read a big-endian double-precision floating point number from a `Read`:����\��ݍ��� use std::f64;�ķ���Ԁ��܀2��������#���Á74     0x40, 0x09, 0x21, 0xfb, 0x54, 0x44, 0x2d, 0x18,�<�������FC assert_eq!(f64::consts::PI, rdr.read_f64::<BigEndian>().unwrap());�<ւ��D�������������������������q�aX�[ɛ�GG��ۥ���L��
F���$��"$�"FF�:��-���IF All types that implement `Read` get methods defined in `ReadBytesExt`�lل
 for free.��
JJ���5���5D��5���"���HE Extends [`Write`] with methods for writing numbers. (For `std::io`.)�����N����N�����F��ˇ�tχ�އ���=: Write unsigned 16 bit big-endian integers to a [`Write`]:����\��ݍ���30 use byteorder_lite::{BigEndian, WriteBytesExt};����� let mut wtr = vec![];����-* wtr.write_u16::<BigEndian>(517).unwrap();����-* wtr.write_u16::<BigEndian>(768).unwrap();��މ&# assert_eq!(wtr, vec![2, 5, 3, 0]);�<����������&�����,ߐ��@= [`Write`]: https://doc.rust-lang.org/std/io/trait.Write.html�l��KK�����{���L��K�+���7��*LMNQTWZ]`cfilorux{~�LMNQTWZ]`cfilorux{~��McfilNoQrTuLWxZ{]~`���+�ϋ>; Writes an unsigned 8 bit integer to the underlying writer.�������HE Note that since this writes a single byte, no byte order conversions���.����d����������@= This method returns the same errors as [`Write::write_all`].�������\Y [`Write::write_all`]: https://doc.rust-lang.org/std/io/trait.Write.html#method.write_all���t��������/, Write unsigned 8 bit integers to a `Write`:����\ȏݍ�؏&# use byteorder_lite::WriteBytesExt;����싐 let mut wtr = Vec::new();�쭐 wtr.write_u8(2).unwrap();��ϐ wtr.write_u8(5).unwrap();���! assert_eq!(wtr, b"\x02\x05");�<����D��������������������������q�aXɛK��K
L��$‘n�ȑ��+���;8 Writes a signed 8 bit integer to the underlying writer.�ǒ��ϒHɁ���.�ϓ�dד������@΂������\�����t���������-* Write signed 8 bit integers to a `Write`:���\��ݍ���&�����쾖����� wtr.write_i8(2).unwrap();�� wtr.write_i8(-5).unwrap();����! assert_eq!(wtr, b"\x02\xfb");�<˗��D�������K�K
M��$�������ݝ;���?< Writes an unsigned 16 bit integer to the underlying writer.����d����������@΂����\��Ԛ�tܚ������;8 Write unsigned 16 bit big-endian integers to a `Write`:����\��ݍ�ϛ3�����쏜�����-����-�����)& assert_eq!(wtr, b"\x02\x05\x03\x00");�<Ý��L�������S��K�OO��Kۥ��L�
N���$������,.�"NN�:���;���<9 Writes a signed 16 bit integer to the underlying writer.�ş�d͟��ޟ���@΂������\�����t���������96 Write signed 16 bit big-endian integers to a `Write`:����\��ݍ���3��Ţ��͢����-* wtr.write_i16::<BigEndian>(193).unwrap();����.+ wtr.write_i16::<BigEndian>(-132).unwrap();��ԣ)& assert_eq!(wtr, b"\x00\xc1\xff\x7c");�<����L�������W��K�RR��Kۥ���L��
Q���$����¤,.)#QQ�:��;�å?< Writes an unsigned 24 bit integer to the underlying writer.����d����������@΂������\��֧�tާ������;8 Write unsigned 24 bit big-endian integers to a `Write`:����\��ݍ�Ѩ3�����쑩�����-* wtr.write_u24::<BigEndian>(267).unwrap();���0- wtr.write_u24::<BigEndian>(120111).unwrap();����1. assert_eq!(wtr, b"\x00\x01\x0b\x01\xd5\x2f");�<Ъ��L�������T��K�UU��Kۥ���L��
T���$������,.{#TT�:���;���<9 Writes a signed 24 bit integer to the underlying writer.�Ҭ�dڬ������@΂������\�����t�������Į96 Write signed 24 bit big-endian integers to a `Write`:����\��ݍ���3��ү��گ�����0- wtr.write_i24::<BigEndian>(-34253).unwrap();����0- wtr.write_i24::<BigEndian>(120111).unwrap();���1. assert_eq!(wtr, b"\xff\x7a\x33\x01\xd5\x2f");�<����L�������W��K�XXѱKۥñ�LƱ
W���$ֱ��ܱ,.�#WW�:���;�ݲ?< Writes an unsigned 32 bit integer to the underlying writer.����d��������³@΂������\����t���������;8 Write unsigned 32 bit big-endian integers to a `Write`:�ӵ�\۵ݍ��3�����쫶���Ͷ-* wtr.write_u32::<BigEndian>(267).unwrap();����41 wtr.write_u32::<BigEndian>(1205419366).unwrap();����96 assert_eq!(wtr, b"\x00\x00\x01\x0b\x47\xd9\x3d\x66");�<����L�������T��K�[[��Kۥ���L��
Z���$������,.$ZZ�:��;���<9 Writes a signed 32 bit integer to the underlying writer.����d����������@΂޺���\��ǻ�tϻ�����96 Write signed 32 bit big-endian integers to a `Write`:����\��ݍ���3�����쀽�����0- wtr.write_i32::<BigEndian>(-34253).unwrap();��׽41 wtr.write_i32::<BigEndian>(1205419366).unwrap();����96 assert_eq!(wtr, b"\xff\xff\x7a\x33\x47\xd9\x3d\x66");�<ξ��L������W��K�^^��Kۥ���L��
]���$������,.q$]]�:���;���?< Writes an unsigned 48 bit integer to the underlying writer.����d����������@΂������\�����t���������;8 Write unsigned 48 bit big-endian integers to a `Write`:����\��ݍ���3�������������85 wtr.write_u48::<BigEndian>(52360336390828).unwrap();����-* wtr.write_u48::<BigEndian>(541).unwrap();����IF assert_eq!(wtr, b"\x2f\x9f\x17\x40\x3a\xac\x00\x00\x00\x00\x02\x1d");�<����L�������U��K�aa��Kۥ���L��
`���$������,.�$``�:���;���<9 Writes a signed 48 bit integer to the underlying writer.����d����������@΂������\�����t���������96 Write signed 48 bit big-endian integers to a `Write`:����\��ݍ���3�������������:7 wtr.write_i48::<BigEndian>(-108363435763825).unwrap();����,) wtr.write_i48::<BigEndian>(77).unwrap();����IF assert_eq!(wtr, b"\x9d\x71\xab\xe7\x97\x8f\x00\x00\x00\x00\x00\x4d");�<����L�������X��K�dd��Kۥ���L��
c���$������,.%cc�:���;���?< Writes an unsigned 64 bit integer to the underlying writer.����d����������@΂������\�����t���������;8 Write unsigned 64 bit big-endian integers to a `Write`:����\��ݍ���3������������96 wtr.write_u64::<BigEndian>(918733457491587).unwrap();����-* wtr.write_u64::<BigEndian>(143).unwrap();����YV assert_eq!(wtr, b"\x00\x03\x43\x95\x4d\x60\x86\x83\x00\x00\x00\x00\x00\x00\x00\x8f");�<����L�������U��K�gg��Kۥ���L��
f���$������,.g%ff�:���;���<9 Writes a signed 64 bit integer to the underlying writer.����d����������@΂������\�����t���������96 Write signed 64 bit big-endian integers to a `Write`:����\��ݍ���3������������:7 wtr.write_i64::<BigEndian>(i64::min_value()).unwrap();����:7 wtr.write_i64::<BigEndian>(i64::max_value()).unwrap();����YV assert_eq!(wtr, b"\x80\x00\x00\x00\x00\x00\x00\x00\x7f\xff\xff\xff\xff\xff\xff\xff");�<����L�������X��K�jj��Kۥ���L��
i���$������,.�%ii�:���=���@= Writes an unsigned 128 bit integer to the underlying writer.�T�������V��K�mm��Kۥ���L��
l���$������,.&ll�:���=���=: Writes a signed 128 bit integer to the underlying writer.�T�������Y��K�pp��Kۥ���L��
o���$������,.^&oo�:���j���@= Writes an unsigned n-bytes integer to the underlying writer.����d����������@΂������\�����d��	 # Panics�������KH If the given integer is not representable in the given number of bytes,����<9 this method panics. If `nbytes > 8`, this method panics.����t���������;8 Write unsigned 40 bit big-endian integers to a `Write`:����\��ݍ���3�������������:7 wtr.write_uint::<BigEndian>(312550384361, 5).unwrap();����0- wtr.write_uint::<BigEndian>(43, 5).unwrap();����A> assert_eq!(wtr, b"\x48\xc5\x74\x62\xe9\x00\x00\x00\x00\x2b");�<����T�������U�:��K�ss��Kۥ���L��
r���$��������4��68�&rr�:���i���=: Writes a signed n-bytes integer to the underlying writer.����d����������@΂������\�����d����������K�����<�����t���������96 Write signed 56 bit big-endian integers to a `Write`:����\��ݍ���3�������������>; wtr.write_int::<BigEndian>(-3548172039376767, 7).unwrap();����/, wtr.write_int::<BigEndian>(43, 7).unwrap();����QN assert_eq!(wtr, b"\xf3\x64\xf4\xd1\xfd\xb0\x81\x00\x00\x00\x00\x00\x00\x2b");�<����L�������X�:��K�vv��Kۥ���L��
u���$��������4��68'uu�:���n���@��������K�����=: this method panics. If `nbytes > 16`, this method panics.�l�������V�:��K�yy��Kۥ���L��
x���$��������4��68U'xx�:���m���=��������K�����=��d�������Y�:��K�||��Kۥ���L��
{���$��������4��68�'{{�:���;���HE Writes a IEEE754 single-precision (4 bytes) floating point number to�Ի� the underlying writer.����d����������@΂������\�����t���������KH Write a big-endian single-precision floating point number to a `Write`:����\��ݍ�����������3������������96 wtr.write_f32::<BigEndian>(f32::consts::PI).unwrap();����)& assert_eq!(wtr, b"\x40\x49\x0f\xdb");�<����L�������Z��K���Kۥ���L��
~���$������,.�'~~�:���;���HE Writes a IEEE754 double-precision (8 bytes) floating point number to�Ԯ���̀�dՀ������@΂������\�����t���������KH Write a big-endian double-precision floating point number to a `Write`:����\��ݍ���������Ń3�����셄�����96 wtr.write_f64::<BigEndian>(f64::consts::PI).unwrap();���96 assert_eq!(wtr, b"\x40\x09\x21\xfb\x54\x44\x2d\x18");�<����L�������[��K���؅Kۥʅ�Lͅ
����$݅���-/N(���:���/��KH All types that implement `Write` get methods defined in `WriteBytesExt`�l����������5����5Lć�5��.\��U�:�X
�����4���3t��V�:�Y
�����4���0l��X�:�U
�����4���5���Y�:�V
�����4��L��U�:
������!d��V�:
����\�<����4�����������#�5�� �6��&���EB `ByteOrder` describes types that can serialize integers as bytes.�����IF Note that `Self` does not appear anywhere in this trait's definition!���A> Therefore, in order to use it, you'll need to use syntax like���<9 `T::read_u16(&[0, 1])` where `T` implements `ByteOrder`.�����KH This crate provides two types that implement `ByteOrder`: [`BigEndian`]��� and [`LittleEndian`].��� GD This trait is sealed and cannot be implemented for callers to avoid��� DA breaking backwards compatibility when adding new derived traits.��!�t�!��!���!85 Write and read `u32` numbers in little endian order:��!�\�!ݍ��"2/ use byteorder_lite::{ByteOrder, LittleEndian};��"�̹" let mut buf = [0; 4];���"1. LittleEndian::write_u32(&mut buf, 1_000_000);���#85 assert_eq!(1_000_000, LittleEndian::read_u32(&buf));�<�#���#���#52 Write and read `i16` numbers in big endian order:��$�\�$ݍ��$/, use byteorder_lite::{ByteOrder, BigEndian};��$���$ let mut buf = [0; 2];���$+( BigEndian::write_i16(&mut buf, -5_000);���%2/ assert_eq!(-5_000, BigEndian::read_i16(&buf));�<�%���%���%&����%,ߐL�&�����&�����,�&���$�&�_��,�&���<�&����&�`��$�&����&�����L�'�����T�'���|�'�����������������������z��l��^��T�������������������������������������������������������������������������������������������������������������������������������������������������������������������������E�����������������������������������������������������������������������(��'0- Reads an unsigned 16 bit integer from `buf`.��'�d�'���(���(  Panics when `buf.len() < 2`.�D�(��
�S��(�
���buf��(��,��(?< Reads an unsigned 24 bit integer from `buf`, stored in u32.��)�d�)���)���)  Panics when `buf.len() < 3`.��)�t�)��*���*?< Write and read 24 bit `u32` numbers in little endian order:��*�\�*ݍ��*2���+�̤+ let mut buf = [0; 3];���+1. LittleEndian::write_u24(&mut buf, 1_000_000);���+85 assert_eq!(1_000_000, LittleEndian::read_u24(&buf));�<�,��D�,�����T��,�
������,��0��-0- Reads an unsigned 32 bit integer from `buf`.��-�d�-���-���-  Panics when `buf.len() < 4`.��.�t�.��.���.8���.�\�.ݍ��/2���/���/����/1����08��<�0��D�0�����T��0�
������0��4��1?< Reads an unsigned 48 bit integer from `buf`, stored in u64.��1�d�1���1���1  Panics when `buf.len() < 6`.��2�t�2��2���2?< Write and read 48 bit `u64` numbers in little endian order:��2�\�3ݍ��32���3���3 let mut buf = [0; 6];���396 LittleEndian::write_u48(&mut buf, 1_000_000_000_000);���4@= assert_eq!(1_000_000_000_000, LittleEndian::read_u48(&buf));�<�4��D�5�����U��5�
������5��9��50- Reads an unsigned 64 bit integer from `buf`.��6�d�6���6���6  Panics when `buf.len() < 8`.��6�t�6��6���685 Write and read `u64` numbers in little endian order:��7�\�7ݍ��72���7�̂8 let mut buf = [0; 8];���81. LittleEndian::write_u64(&mut buf, 1_000_000);���885 assert_eq!(1_000_000, LittleEndian::read_u64(&buf));�<�9��D�9�����U��9�
������9��=!��91. Reads an unsigned 128 bit integer from `buf`.��9�d�:���:���:! Panics when `buf.len() < 16`.��:�t�:��:���:96 Write and read `u128` numbers in little endian order:��;�\�;ݍ��;2���;���; let mut buf = [0; 16];���<2/ LittleEndian::write_u128(&mut buf, 1_000_000);���<96 assert_eq!(1_000_000, LittleEndian::read_u128(&buf));�<�=��L�=�����V��=�
������=��A/��=1. Reads an unsigned n-bytes integer from `buf`.��=�d�=���>���>/, Panics when `nbytes < 1` or `nbytes > 8` or���> `buf.len() < nbytes`��>�t�>��?���?;8 Write and read an n-byte number in little endian order:��?�\�?ݍ��?2���@�̢@����@52 LittleEndian::write_uint(&mut buf, 1_000_000, 3);���@<9 assert_eq!(1_000_000, LittleEndian::read_uint(&buf, 3));�<�A��L�A�����:�U��A�
������A��4�A��F3��A1���B�d�B���B���B0- Panics when `nbytes < 1` or `nbytes > 16` or�ĈC���C�t�C��C���C;���D�\�Dݍ��D2���D���D����D85 LittleEndian::write_uint128(&mut buf, 1_000_000, 3);���E?< assert_eq!(1_000_000, LittleEndian::read_uint128(&buf, 3));�<�E��d�F�����:�V��F�
������F��4�F��J%��F30 Writes an unsigned 16 bit integer `n` to `buf`.��F�d�G���G���G ���G�t�G��G���G85 Write and read `u16` numbers in little endian order:��H�\�Hݍ��H2���H���H����I-* LittleEndian::write_u16(&mut buf, 1_000);���I41 assert_eq!(1_000, LittleEndian::read_u16(&buf));�<�J��L�J�����S��J�
������J���J��N$��JB? Writes an unsigned 24 bit integer `n` to `buf`, stored in u32.��J�d�K���K���K ���K�t�K��K���K?���L�\�Lݍ��L2���L�̃M����M1����M8��<�N��L�N�����T��N�
������N���N��R%��N30 Writes an unsigned 32 bit integer `n` to `buf`.��O�d�O���O���O ���O�t�P��P���P8���P�\�Pݍ��P2���Q�̲Q����Q1����R8��<�R��L�R�����T��R�
������R���R��V$��RB? Writes an unsigned 48 bit integer `n` to `buf`, stored in u64.��S�d�S���S���S ���T�t�T��T���T?��T�\�Tݍ��U2���U���U߄��U9����V@Å<�V��L�V�����U��W�
������V���W��[%��W30 Writes an unsigned 64 bit integer `n` to `buf`.��X�d�X���X���X ̇�X�t�X��X���X8���Y�\�Yݍ��Y2���Y�̄Z����Z1����Z8�<�[��L�[�����U��[�
������[���[��_'��[41 Writes an unsigned 128 bit integer `n` to `buf`.��\�d�\���\���\!��\�t�\��\���\9���]�\�]ݍ��]2���]�Ԅ^����^2Í��^9��<�_��T�_�����V��_�
������_���_��d5��_@= Writes an unsigned integer `n` to `buf` using only `nbytes`.��`�d�`���`���`JG If `n` is not representable in `nbytes`, or if `nbytes` is `> 8`, then���a this method panics.��a�t�a��a���a;���b�\�bݍ��b2���b���b����b5����c<��<�c��T�d�����U�:��d�
������d���d��4�d��h9��d@���e�d�e���e���eKH If `n` is not representable in `nbytes`, or if `nbytes` is `> 16`, then���e��f�t�f��f���f;���f�\�fݍ��g2���g���g����g8˕��h?��<�h��l�h�����V�:��i�
������i���i��4�i�m��i-* Reads a signed 16 bit integer from `buf`.��i�d�i���i���j ���j�t�j��j���j85 Write and read `i16` numbers in little endian order:��k�\�kݍ��k2���k���k����k.+ LittleEndian::write_i16(&mut buf, -1_000);���l52 assert_eq!(-1_000, LittleEndian::read_i16(&buf));�<�l��D�m�����W��m�
������m��q��m<9 Reads a signed 24 bit integer from `buf`, stored in i32.��n�d�n���n���n ���n�t�n��n���n?< Write and read 24 bit `i32` numbers in little endian order:��o�\�oݍ��o2���p�̚p����p2/ LittleEndian::write_i24(&mut buf, -1_000_000);���p96 assert_eq!(-1_000_000, LittleEndian::read_i24(&buf));�<�q��D�q�����W��q�
������q��u��r-* Reads a signed 32 bit integer from `buf`.��r�d�r���r���r ���s�t�s��s���s85 Write and read `i32` numbers in little endian order:��s�\�sݍ��t2���t���t����t2/ LittleEndian::write_i32(&mut buf, -1_000_000);���u96 assert_eq!(-1_000_000, LittleEndian::read_i32(&buf));�<�u��D�u�����W��v�
������v��z��v<9 Reads a signed 48 bit integer from `buf`, stored in i64.��w�d�w���w���w ���w�t�w��w���w?< Write and read 48 bit `i64` numbers in little endian order:��x�\�xݍ��x2���y�̉y߄��y:7 LittleEndian::write_i48(&mut buf, -1_000_000_000_000);���yA> assert_eq!(-1_000_000_000_000, LittleEndian::read_i48(&buf));�<�z��D�z�����X��z�
������z��~��{-* Reads a signed 64 bit integer from `buf`.��{�d�{���{���{ ̇�|�t�|��|���|85 Write and read `i64` numbers in little endian order:��|�\�|ݍ��}2���}���}����}63 LittleEndian::write_i64(&mut buf, -1_000_000_000);���~=: assert_eq!(-1_000_000_000, LittleEndian::read_i64(&buf));�<�~��D�~�����X���
��������� ��.+ Reads a signed 128 bit integer from `buf`.���d����������!�ŀ�t̀������96 Write and read `i128` numbers in little endian order:����\��ݍ���2�������������74 LittleEndian::write_i128(&mut buf, -1_000_000_000);��؂>; assert_eq!(-1_000_000_000, LittleEndian::read_i128(&buf));�<����L�������Y�ǃ�
�����ƒ���-���.+ Reads a signed n-bytes integer from `buf`.����dÄ��Ԅ��܄/��Đ������t���ȅ��ЅB? Write and read n-length signed numbers in little endian order:����\��ݍ���2�����������1. LittleEndian::write_int(&mut buf, -1_000, 3);��‡85 assert_eq!(-1_000, LittleEndian::read_int(&buf, 3));�<����D�������:�X����
���������4�����1���.�����dɉ��ډ���0��ė������t���ϊ��׊B�����\��ݍ���2������������41 LittleEndian::write_int128(&mut buf, -1_000, 3);��̌;8 assert_eq!(-1_000, LittleEndian::read_int128(&buf, 3));�<����\�������:�Y����
���������4��������EB Reads a IEEE754 single-precision (4 bytes) floating point number.���d���������� �����t���Џ��؏85 Write and read `f32` numbers in little endian order:����\��ݍ���2������ let e = 2.71828;�̅������)& LittleEndian::write_f32(&mut buf, e);��ё0- assert_eq!(e, LittleEndian::read_f32(&buf));�<����D�������Z����
�������������EB Reads a IEEE754 double-precision (8 bytes) floating point number.�“�dʓ��ۓ��� ̇���t���������85 Write and read `f64` numbers in little endian order:���\�ݍ���2�����ܿ� let phi = 1.6180339887;��ߕ�����+( LittleEndian::write_f64(&mut buf, phi);����2/ assert_eq!(phi, LittleEndian::read_f64(&buf));�<���D�������[����
����������$�֗0- Writes a signed 16 bit integer `n` to `buf`.����d���������� ��ј�t٘������8�����\��ݍ�ə2�����̈������.���ٚ5Ͳ<����L�������W����
���������ʛ���$���?< Writes a signed 24 bit integer `n` to `buf`, stored in i32.�ʜ�dҜ������ �����t���������?�����\��ݍ���2��ƞ��Ξ����2�����9ö<���L�������W����
��������������$�נ0- Writes a signed 32 bit integer `n` to `buf`.����d���������� ��ҡ�tڡ�������8����\��ݍ�ʢ2�����̉������2��ޣ9��<����L�������W�Ȥ�
�����ä��Ӥ���$���?< Writes a signed 48 bit integer `n` to `buf`, stored in i64.�ӥ�dۥ������� �����t���������?����\��ݍ���2��ϧ��ק߄���:����A��<����L�������X����
������������׭$��0- Writes a signed 64 bit integer `n` to `buf`.����d��������ƪ ̇��t��������8��˫�\ӫݍ��2�����̢������6�����=��<����Lڭ�����X���
�������������&���1. Writes a signed 128 bit integer `n` to `buf`.���d���������!����t���ȯ��Я@= Write and read n-byte `i128` numbers in little endian order:����\��ݍ���2�����������7���DZ>��<����T�������Y����
���������²���3���=: Writes a signed integer `n` to `buf` using only `nbytes`.�ó�d˳��ܳ���J������ϴ�t״�����;�����\��ݍ�ʵ2�����̉������1���ݶ8��<����L�������X�:�Ʒ�
���������ѷ��4ٷ���7���=�����d����������K��������t���������B����\��ݍ���2������Ż����4�����;��<ܼ��d�������Y�:����
�������������4�����$���FC Writes a IEEE754 single-precision (4 bytes) floating point number.�̾�dԾ������� �����t���������8����\��ݍ���2������������������)�����0��<����L�������Z����
��������������$���FC Writes a IEEE754 double-precision (8 bytes) floating point number.����d���������� ̇���t���������8�����\��ݍ���2�����ܡ�����������+�����2��<����L�������[����
��������������.���96 Reads unsigned 16 bit integers from `src` into `dst`.����d����������+( Panics when `src.len() != 2*dst.len()`.����t���������8ј���\��ݍ���2�����܂� let mut bytes = [0; 8];����/, let numbers_given = [1, 2, 0xf00f, 0xffee];����=: LittleEndian::write_u16_into(&numbers_given, &mut bytes);�������! let mut numbers_got = [0; 4];����:7 LittleEndian::read_u16_into(&bytes, &mut numbers_got);����+( assert_eq!(numbers_given, numbers_got);�<����l��������
�S����
���src���dst������.���96 Reads unsigned 32 bit integers from `src` into `dst`.����d����������+( Panics when `src.len() != 4*dst.len()`.����t���������8�����\��ݍ���2������� let mut bytes = [0; 16];����/�����=: LittleEndian::write_u32_into(&numbers_given, &mut bytes);�������!�����:7 LittleEndian::read_u32_into(&bytes, &mut numbers_got);����+��<����l��������
�T����
��������������.���96 Reads unsigned 64 bit integers from `src` into `dst`.����d����������+( Panics when `src.len() != 8*dst.len()`.����t���������8�����\��ݍ���2�������� let mut bytes = [0; 32];����/�����=: LittleEndian::write_u64_into(&numbers_given, &mut bytes);�������!�����:7 LittleEndian::read_u64_into(&bytes, &mut numbers_got);����+��<����l��������
�U����
��������������0���:7 Reads unsigned 128 bit integers from `src` into `dst`.����d����������,) Panics when `src.len() != 16*dst.len()`.����t���������9�����\��ݍ���2������� let mut bytes = [0; 64];����/�����>; LittleEndian::write_u128_into(&numbers_given, &mut bytes);�������!�����;8 LittleEndian::read_u128_into(&bytes, &mut numbers_got);����+��<����t��������
�V����
��������������.���52 Reads signed 16 bit integers from `src` to `dst`.����d����������+( Panics when `buf.len() != 2*dst.len()`.����t���������8�����\��ݍ���2�������������+( let numbers_given = [1, 2, 0x0f, 0xee];����=: LittleEndian::write_i16_into(&numbers_given, &mut bytes);�������!�����:7 LittleEndian::read_i16_into(&bytes, &mut numbers_got);����+��<����l��������
�W����
��������������.���74 Reads signed 32 bit integers from `src` into `dst`.����d����������+�����t���������8����\��ݍ���2������������/�����=: LittleEndian::write_i32_into(&numbers_given, &mut bytes);�������!�����:7 LittleEndian::read_i32_into(&bytes, &mut numbers_got);����+��<����l��������
�W����
��������������.���74 Reads signed 64 bit integers from `src` into `dst`.����d����������+Á���t���������8�����\��ݍ���2��������݂���/�����=: LittleEndian::write_i64_into(&numbers_given, &mut bytes);�������!�����:7 LittleEndian::read_i64_into(&bytes, &mut numbers_got);����+��<����l��������
�X����
��������������0���85 Reads signed 128 bit integers from `src` into `dst`.����d����������,�����t���������9�����\��ݍ���2�������·���/�����>; LittleEndian::write_i128_into(&numbers_given, &mut bytes);�������!�����;8 LittleEndian::read_i128_into(&bytes, &mut numbers_got);����+��<����t��������
�Y����
��������������.���HE Reads IEEE754 single-precision (4 bytes) floating point numbers from���� `src` into `dst`.����d����������+�����t���������8�����\��ݍ���2�������������96 let numbers_given = [1.0, 2.0, 31.312e31, -11.32e19];����=: LittleEndian::write_f32_into(&numbers_given, &mut bytes);�������#  let mut numbers_got = [0.0; 4];����:7 LittleEndian::read_f32_into(&bytes, &mut numbers_got);����+��<����l��������
�Z����
��������������7��� **DEPRECATED**.�������;8 This method is deprecated. Use `read_f32_into` instead.����HĜ��������d����������+�����t���������8�����\��ݍ���2�������������9ڞ���=��������#����DA LittleEndian::read_f32_into_unchecked(&bytes, &mut numbers_got);����+��<����1.3.0�"please use `read_f32_into` instead����K�����ĥ������������
��������������.��HĜ�����ρ�dׁ�������+Á���t�������Â8�����\��ݍ���2��σ��׃݂���:7 let numbers_given = [1.0, 2.0, 31.312e211, -11.32e91];����=: LittleEndian::write_f64_into(&numbers_given, &mut bytes);�������#����:7 LittleEndian::read_f64_into(&bytes, &mut numbers_got);���+��<����l��������
�[����
�������������7�؆��������;8 This method is deprecated. Use `read_f64_into` instead.�������HĜ��������d��������Ȉ+Á���t���������8��؉�\��ݍ���2�����䯊݂�Њ:�����=��ы��ً#����DA LittleEndian::read_f64_into_unchecked(&bytes, &mut numbers_got);��ʌ+��<������"please use `read_f64_into` instead����K�����������������
������������֓/�Ў:7 Writes unsigned 16 bit integers from `src` into `dst`.����d����������+( Panics when `dst.len() != 2*src.len()`.����t��������8ј���\Ȑݍ�ؐ2�����ܗ������/����=��������!���ے:�����+��<ʓ��tٓ�����������
�������������/���:7 Writes unsigned 32 bit integers from `src` into `dst`.�ʔ�dҔ������+( Panics when `dst.len() != 4*src.len()`.����t���������8�����\��ݍ���2��ʖ��Җ����/�����=������!�����:���֘+��<����t��������������
������������Ξ/�Ǚ:7 Writes unsigned 64 bit integers from `src` into `dst`.����d����������+( Panics when `dst.len() != 8*src.len()`.�ך�tߚ������8�����\��ݍ�ϛ2�����䎜݂���/����=��������!���ӝ:����+��<ž��tў�����������
�������������1���;8 Writes unsigned 128 bit integers from `src` into `dst`.�ß�d˟��ܟ���,) Panics when `dst.len() != 16*src.len()`.����t���������9�����\��ݍ���2��š��͡·��/�����>�������!�����;��ӣ+��<����|�������������
��������������,�Ƥ74 Writes signed 8 bit integers from `src` into `dst`.�������IF Note that since each `i8` is a single byte, no byte order conversions��إHE are used. This method is included because it provides a safe, simple����DA way for the caller to write from a `&[i8]` buffer. (Without this���HE method, the caller would have to either use `unsafe` code or convert����$! each byte to `u8` individually.)���d���������)& Panics when `buf.len() != src.len()`.����t���Ψ��֨74 Write and read `i8` numbers in little endian order:����\��ݍ���@= use byteorder_lite::{ByteOrder, LittleEndian, ReadBytesExt};������ let mut bytes = [0; 4];����)& let numbers_given = [1, 2, 0xf, 0xe];��Ū<9 LittleEndian::write_i8_into(&numbers_given, &mut bytes);�<����l�����
�������
������������ұ/�Ҭ85 Writes signed 16 bit integers from `src` into `dst`.����d����������+( Panics when `buf.len() != 2*src.len()`.���t��������8�����\Ȯݍ�خ2�����ܗ������+Ɍ��=��������!���װ:ߍ���+��<Ʊ��tձ����������
������������/���85 Writes signed 32 bit integers from `src` into `dst`.�IJ�d̲��ݲ���+�����t���������8����\��ݍ���2��Ĵ��̴�����/�����=������!�����:���ж+��<����t��������������
������������Ƽ/���85 Writes signed 64 bit integers from `src` into `dst`.����d����������+��ϸ�t׸�����8�����\��ݍ�ǹ2�����䆺݂���/���ۺ=ڕ������!���˻:�����+��<����tɼ���ɘ����ݼ�
�����ؼ������1���96 Writes signed 128 bit integers from `src` into `dst`.����d����ҽ��ڽ,����t���������9����\��ݍ���2������ÿ·��/�����>��������!�����;����+��<����|��������������
��������������/���IF Writes IEEE754 single-precision (4 bytes) floating point numbers from���������d����������+�����t���������8�����\��ݍ���2������������9ڞ���=��������#����:�����+��<����t��������������
��������������/���IF Writes IEEE754 double-precision (8 bytes) floating point numbers from���������d����������+Á���t���������8�����\��ݍ���2�������݂���:�����=��������#����:����+��<����t�������������
��������������'���HE Converts the given slice of unsigned 16 bit integers to a particular�|�� endianness.�������GD If the endianness matches the endianness of the host platform, then���� this is a no-op.����t���������96 Convert the host platform's endianness to big-endian:����\��ݍ���/��������! let mut numbers = [5, 65000];����,) BigEndian::from_slice_u16(&mut numbers);����:7 assert_eq!(numbers, [5u16.to_be(), 65000u16.to_be()]);�<����t����������
���numbers�<�����'���HE Converts the given slice of unsigned 32 bit integers to a particular�|����������G����������t���������9�����\��ݍ���/��������!�����,) BigEndian::from_slice_u32(&mut numbers);����:7 assert_eq!(numbers, [5u32.to_be(), 65000u32.to_be()]);�<����t����������
�����<�����'���HE Converts the given slice of unsigned 64 bit integers to a particular�|����������G����������t���������9�����\��ݍ���/��������!�����,) BigEndian::from_slice_u64(&mut numbers);����:7 assert_eq!(numbers, [5u64.to_be(), 65000u64.to_be()]);�<����t����������
�����<�����)���IF Converts the given slice of unsigned 128 bit integers to a particular�|����������G����������t���������9�����\��ݍ���/��������!�����-* BigEndian::from_slice_u128(&mut numbers);����<9 assert_eq!(numbers, [5u128.to_be(), 65000u128.to_be()]);�<����|���������
�����<�����#���FC Converts the given slice of signed 16 bit integers to a particular�|����������G����������t���������9�����\��ݍ���/��������  let mut numbers = [5, 6500];����,) BigEndian::from_slice_i16(&mut numbers);����96 assert_eq!(numbers, [5i16.to_be(), 6500i16.to_be()]);�<����t���������
����������#���FC Converts the given slice of signed 32 bit integers to a particular�|����������G����������t���������9�����\��ݍ���/��������!�����,) BigEndian::from_slice_i32(&mut numbers);����:7 assert_eq!(numbers, [5i32.to_be(), 65000i32.to_be()]);�<����t����������
����������#���FC Converts the given slice of signed 64 bit integers to a particular�|����������G����������t���������9�����\��ݍ���/��������!�����,) BigEndian::from_slice_i64(&mut numbers);����:7 assert_eq!(numbers, [5i64.to_be(), 65000i64.to_be()]);�<����t����ɘ����
����������%���GD Converts the given slice of signed 128 bit integers to a particular�|����������G����������t���������9�����\��ݍ���/��������!�����-* BigEndian::from_slice_i128(&mut numbers);����<9 assert_eq!(numbers, [5i128.to_be(), 65000i128.to_be()]);�<����|����������
����������'���KH Converts the given slice of IEEE754 single-precision (4 bytes) floating����-* point numbers to a particular endianness.�������G�������t����������
�����<�����'���KH Converts the given slice of IEEE754 double-precision (8 bytes) floating����-��������G�������t���������
�����<������6������<���6��
�\�����#  A type alias for [`BigEndian`].�������&�����6쬁�5����Ё<Ӂ�5��
�\�����&# A type alias for [`LittleEndian`].�Ƃ��ʂ,ߐ���5�ӈ���-* Defines network byte order serialization.�ƒ��ƃKH Network byte order is defined by [RFC 1700][1] to be big-endian, and is����MJ referred to in several protocol specifications.  This type is an alias of���� [`BigEndian`].������,) [1]: https://tools.ietf.org/html/rfc1700�������JG Note that this type has no value constructor. It is used purely at the�|� type level.����t���������5��І�\Ԇݍ���>; use byteorder_lite::{ByteOrder, NetworkEndian, BigEndian};����̣������+����63 assert_eq!(-5_000, NetworkEndian::read_i16(&buf));�<����������&��l܈�6������/, Defines system native-endian serialization.�������JȆ|����������<9 On this platform, this is an alias for [`LittleEndian`].�Ȋ��̊,ߐd���5�ƏTӏޏ�����,�8���&�8�$�$�,��8���&�8�$��$��,��8���&��8���$��,��8
from_bytes�T��&��8�,��*����������38,��8�"$��&��8�,����8�$��'��8mem���'��8�<Ð'ʐ̐,͐8�ΐАѐҐ%Ӑ8��8����&��������8�����,��8����%��8��8����&����8������,��8�����,��8����%��8�L��	��‘ޑ8��Ñ Ƒ8�	Ǒʑˑ$̑8��Α ё8�	ґՑ֑
ؑ8�"$ڑ%ߑ8
����8���$�8���8��8���� ��8chunks_exact�d������8�"$�� ��8zip�������8���� ��8�	D���������
��8��������,��8�����'��,’8��TÒ͒�8��Β ђ8�DҒڒے ܒ8�4ݒ��%�%���Ȕ\Ք�����,�8���&�8�$�$�,�8����&��8�$��$��,��8���&��8���$��,��8to_bytes�D��&��8�,��*��������38,��8�"$��&��8�,����8�$��'��8����'•8�<ĕ'˕͕,Ε8�ϕѕҕӕ%ԕ8��8����&��������,��8�����,��8����%��8��8����&����8������8�����,��8����%��8�L��	–Öߖ8��Ė ǖ8�	Ȗ˖̖
Ζ8�"$Ж$Ԗ8��֖ ٖ8�	ږݖޖ%��8
����8���$�8����8��8���� ��8�	$������ ��8��������8���� ��8chunks_exact_mut��������8�"$�����8���� ��8copy_from_slice�|��ȗٗɗ8��ʗ ͗,Η8��Dϗחؗ%ڗ%����6������������������������������������������������������������������������������������*���������������������������������������������D�������S����
��������D�������T����
������D�������U����
�������� L�������V����
�������.L�������:�U����
�������4���(���:���2d�������:�V����
�������4���(���:�ܠ$Lߠ�����S���
���������С$Lӡ�����T���
���ݡ�����Ģ$LǢ�����U�֢�
���Ѣ������&T�������V�ˣ�
���ƣ��֣���4T�������U�:�¤�
�������ͤ��4դ���8l�������V�:����
�������Ȧ��4Ѧ���-l��������������
�������Ũ���-l��������������
������������-l��������������
������������/t�������������
������������-l�������������
������������-l��������������
������������-l��������ɘ����
������������/t��������������
������������-l��������������
������������-l�������������
������������.t��������������
������������.t��������������
������������.t��������������
������������0|�������������
������������.t�������������
������������.t��������������
�����������.t�����ɘ�������
������������0|�������������
�����������.t�������������
�����������.t������������
�����������&t���������
���<�����&t�������Ľ�
���<����&t���������
���<�����(|���������
���<�����&t���������
���<�����&t����������
���<�����&t����ɘ����
���<�����(|����������
���<�����&t����������
���<�����&t���������
���<������5������������������������������������������������������������������������������������*���������������������������������������������D�������S����
��������D�������T����
��������D�������U����
�������� L�������V����
��������.L�������:�U����
�������4��h1���:���2d�������:�V����
�������4���1���:���$L�������S����
������������$L�������T����
������������$L�������U����
������������&T�������V����
������������4T�������U�:����
�����������4�����8l�������V�:����
�����������4�����-l��������������
������������-l��������������
������������-l��������������
������������/t�������������
������������-l�������������
������������-l��������������
������������-l��������ɘ����
������������/t��������������
������������-l��������������
������������-l�������������
������������.t��������������
������������.t��������������
������������.t��������������
������������0|�������������
������������.t�������������
������������.t��������������
������������.t�����ɘ�������
������������0|��������������
������������.t��������������
������������.t�������������
������������&t����������
���<�����&t����������
���<�����&t����������
���<�����(|���������
���<�����&t���������
���<�����&t����������
���<�����&t����ɘ����
���<�����(|����������
���<�����&t����������
���<�����&t���������
���<��������%" Defines big-endian serialization.�������JȆ|�������t���������52 Write and read `u32` numbers in big endian order:����\��ݍ���/�������������.+ BigEndian::write_u32(&mut buf, 1_000_000);����52 assert_eq!(1_000_000, BigEndian::read_u32(&buf));�<����L���6��ᑍ'q�(��O�6���"$���6�6����
�,�� ��P�6(��Q�6��_�"$�����6��^�^��^��[�^���[����e�S����������������������q�aXÅÅą��:��������
�,���A��R�6���"�)+.08�:>@���6����
��� 	��S�6��`�"$����6������	���������`���
���$������
��T�6���"$����6��6���Less��������Greater��ji�/޾�
���
�����H��U�6U�6���57����6��6����
�L����P��V�6���"$����6��6����������������;t���������
�T���ˬ�����(% Defines little-endian serialization.�������JȆ|�������t���������8�����\��ݍ���2�������������1�����8��<ƀ��d���5�����=�(׀Y�5���"$���5�5�׀�
�,׀ ހZ�5(�[�5��_�"$�����5��^�^��^��[�^���[����e�S�������
�,����\�5���"�)+.08�:>@���5���
�� �]�5��`�"$����5���������������
���$�������^�5���"$����5��5������
�����H��_�5_�5���57����5��5����
�L����P��`�5���"$����5��5������
�T�����*�� *���:�,�� ,���:�.�� .���:�0�� 0���:�2�� 2���:�4�� 4���:�6�� 6���:�8�� 8���:�:�� :���:�<�� <���:�>�� >���:�@�� @���:�B�� B���:�D�� D���:�F�� F���:�H�� H���:�J�� J���:�L�� L���:�N�� N���:�P�� P���:�h�� h���:�j�� j���:�l�� l���:�n�� n���:�p�� p���:�r�� r���:�t�� t���:�v�� v���:�x�� x���:�z�� z���:�|�� |���:�~�� ~���:���� ����:���� ����:���� ����:���� ����:���� ����:���� ����:���� ����:���� ����:�M(PRR	PU�W�Z�\N_"b'�d,Sg1�i6m;�o@(rENtJ�tO�uT�xY�{^�c)�h8�mʊrk�w
�|���b��#�������������n�������4���������p�������G�����u��;��i����������V������	հM�e�q�!��'��-��3��9��?�E͝K��QJ�WϘ]c�c�i|�oӒuK�{��Y��ʌ������������-�����Ȃ����\�����<~����|�����y����Vw���t���rƆ'7p-��5\n;��C�lI��Q�jW�_�he��m�ds��{�b����<a�����_����]����\����7Z�����W��U��S�R�*P�TN�~L��J��I�Hq7 7�6}6#)6)�5/E55�4;�4A+4G�3Ma3S�2Yʨa�2gƩo2uª}�1����Q1�����0�����0����0�����/����S/�����.�����.����!.��	�-��U-��%�,+��3�,9��A#,G��O�+U��]W+c��k+q�*w_*}
*��)�i)�)��(�s(�!(��%��%�M%��$��$�5$��#�e#�#��"�I"��!�g!����!��� ��5 ��'�-��5i;��CI��Q�W��_7e��m�s��{k�������������9���������m�������������;���������
/��9%�+�1C7�=�C�IBOHUs[�a1g7m's-y�������S�z
��
�6���l�r�����D�J��
��
�?type.NetworkEndian.html�type.NativeEndian.html��
Write�"https://crates.io/crates/byteorder�enum.BigEndian.html�enum.LittleEndian.html�RFC 1700��"��1https://doc.rust-lang.org/std/io/trait.Write.html��������
	byteorder������0https://doc.rust-lang.org/std/io/trait.Read.html���������
K����trait.WriteBytesExt.html���������trait.ReadBytesExt.html����!��#https://tools.ietf.org/html/rfc1700�Read������ʝ�"�!�����������������ʝ�"�!���������Read::read_exact�������"���!����Write::write_all���������"�!����������������"�!���������K��������H���������������I�I�I�H�J��������3a��1��;K �4�1�SS<�oy�:*o(�Q�^O(kl�x�ܩ=,�:�(��/徣��HAT�nӣtf��po\���@_]s0V�#�g�
%��@K/ՈEo����j-���z���w�;2+��òH�/��6��<��K����Wi���IQK��BQ��E���C����'���V��ChS�f~�H'��=�����@l��C��WkNL�����l�ܻ��]S0C^P>d8�ّT��$�9�z!E�҇,7>2}���
�\.����U9������z5�}أ1|H�E2:�_��9�������E��o�>(��
>��!��ϑ0T��-���t1G{QX��`����qǚ�s�|_�#�t�Mo眎E9
� ��ݛe��h;<�s�7]gh�Uz��Y��bf����08�׶��s�h)���k:�}��>�(�Y�#�D�2Dw3���@��X�h�x����8mj�Im\�ޙ�@~'�[�ƒ���`��w\[)���x��٫&��h�,+2C��[Z-B�H���������<�Q�ozq"�����SM\�N�sc�]_U����G�s���3�?��Ϫ���B���'�K`��L+��P�����ݵ4Jv2���+u��P�!��n�&�j��^�:g*��u�yLF�S�E��L�Z��̄\��M�}�u�Z��?���5�_�8X6Fġ�нHcL�~O������
�[V��3��Ԡ4����e<�c���]Y��ҹ[�?�'M5�g��Õd4"l���:�H��E�<-j�0`W��!�q�kı��l6�L��D�Y�V�E�֕sz�����ȩ�vx���~e�b[�W|h���ב&�Pwc�F��w �!s�~�����r���ψ�"��~��m�m�#ф�a@�Q����a/��L�-���RL�+t��l�����$:�E��6t%;���U�k|��@2�eӐ!D�/�Iǝ�KF�P�y F���ġ�᝙{luJw�i��FV/�Yf�u��C���5�Dj.�~���9yH����:�t,�3]��~^r�*ȃ�&���0�k�#�ȫ+���:Ӣ�|}�-��y����!l	�B0���a�|3N(7��N_��h,h�1&<"�3�	]�H��޴U!�����S�&���{�ڃ�u����ed+3P�
Ff@0���S�~�^�פO��^�c�����YiB���į��]�W���>�����87G��)�k$*^�ts���<�v��L��zS�a����7��i62L���v}\���:C9Sy���]"��N�7�j����Я���N�0G��;��G���h�2���`��t�O��c� =���;jei5�X��B�x��_���s5���L]b��(�t�a��{��,�����Y
>C�!=2E4t��h_�N��;��u�5����`����ao��.@�:\�MB)n�B,� o�o"7#{�|n�wT�j{��)�LH<N�&��]YZ�mJ���*0g-N��B>��9^��.hOz�=r�[�,+9w�X�RO��4�v��,[�ꩼ��?;��'N�^� q�
Vε{!��`��&v�Þ�)����^��
ٿ^��)�"8J�z�q�\�� �v��S��>��������hTo�SD�L���}�4��f�⤂P�~U��.�q�t/b��1�&���4t�4���o�A]	H[��!�k��v��̷%mL�����������i�nI�^�h37z�,������tD`��<=���������t_�d� �&�:�D�T���K�v#�/�s3�m���O��lF]�b�Z,*O4gy�)��AcO�E1����w��eq��j���oj�O�,�j�?���EXA�-�;M
�Y����ML���,���T��q~>��
E���E�e�2�i����&i� �/����OF"���x�hE؄I��M�h�$�t�ã�U�KY����J�%�����G.F�f����nd���W(y�R�K�H�xv��"�Ub‚�O^F:Ï����,��/����F�O@ٚ+�}�^��*Çp�Y�����9�^�)eo��9ϴ@�h�w�u���B�$�Sh$.I�
(q��.���~٥JuGL���Պ4�<B�Q���u2|�ٹ^���'(���R�n�O�m�9���^k"�2��P;Ql��a���4���iQ�{�؋Dmupc!:�5}]�W��F�Q��я�����r,~�7�=�1T���U�M��l�7�3�$�tE!���HZD���Y	ѕ�=�:�EHbZ��S8Ξ��D�N�]�\?�Ph�
X�7�Z�u����t
pZ�Ǿ��*��<y�|B'�4��Jp�!t��/�@����.���]�W��K�:sm�x�23�9�ATL8%ֺ��=X�u��I�������[�������C��rh	�P�A�#��ĶP&Aӆ����I\q���F�|��x�]ғ�υ���
�Ot�	�|>�]�W�*w
>^�<}'�ұپ�w�{ŇxiY�1ؤ��DŽ��<�S�n��l^���(i����
��$y��y��x�u92+0`m/�8y4�/m�Uq��g���d��ɤ���,h�xI�`�*�6�d��5� �|�ʽ.��&I(9�gJ��T�i��c�]T,کw�<�[�@�)n���7�HP���R����ݕ5�����!w��휳�]k�m��<�)!a��+A������rc�)�u���a5��G��"g�[��ؘ2B�:�f�g�O�_��5��	��j:6|��"��������kC*>�><�^1O�;zC\
ZBT!o��
�FEqM9(W���'D�,勐z���tAM���2�
+ h��SR����i9,���-�Ox��B�|� ��,�D����u�\�(p�ݐ6:5t	��EgwK��Ǎ������ޱ�����a�Sގ�Z3�j�6g�0�v�h$oHl�T��8䣆t���;,��λ�N��ry4|���q��p\�Uw>F�1�6���T�Ɛ&:r~~,���0�H�Z
�2�y����z��~���2X�?��#�`�n��3GC[W@՜�T�.�IX��Ƌ��(wp�^'��
	�0Q�@����T#�J�+�G���\!F�(�S��w�
��ڳJM��c�s����T�C�����`�-W�&�����5���(��:+��1�T�{��#0{�D����CP�6WQuʙ
�`�d�M>!�j��c@�-�y��G8B~5k[V�����غ��K�@���d�6p5Uto��xR�D��~R��M��"ϼnXHk�2	�H6����0����2� c ���x�-�K�����N��tO�77�[8ʺ��2�4+�����G����=h�0ge�g���K�"=���6��A�{)C1�O?v�����]����ͭ-)>�$���ilTn��p�:�gM]G���a�����
5.c,�\5��^�O�J��� S�[�	5��|SǴ������xtG7`�3ـY�IS����Iǘ>�T��g%n�R��IX���f��n�#m��P�#����F��5i��C�ǹ+�z�B��⃧&��S����Tv��F�n8b'�;ˤ���/�J������Ԑ�����p2��^��m��.D[��	}r�N�h��vP��X����V���1�Y�S�1���Q&��MP��r��͝(QaK'�w5Jh��+�<�����f���F�c=�-�lNHfn{u0^���]��J5����9���e���}��c}cr��M�3<����X�rf�^f
�Q4&�{��#�
dk}�s�\Sb�gd	��6�ٛ.$3VTы	H�.�8������.N�zp
8W�h�r%�5��w�ʲ�Q�~<�;�����Em��'�Q�J�ӁcTp|2���~���7C[�C�w��ķ��O��ցʚ�o��Q���p3��K��QPG9YD��d�SiR�wf��k�^��]M�~���3�+��Oldyj����]���|7l5�cT�63�u�N
5��ZP�R9JYe�������z�|��d���إ���y"�\sy+w
{9������V|N�Y_�b.Hf�|2��f2rﰏ�0��eفO���/9T����,GV������]���AP	���0\��dq��z+�K����:E��ϳJ���J�JL�/���4bbל��v�A��T8���M��a{���f*�j:.Ӛ�xo���3~W�
��]�O��#�����^1�.m[�h�����$�!�eš��]��E����`z�i�*�u{[͍��^�׈K�_`��63`5���0Qw���Y�b<���;�9�Ē�?��;ړۢ��-$��N�f;��禕6�e�ozDu�MJ�
t� "�����x�X�xq��Q������x��E6'p���M�-G���q_^H|��ue<N��p�<J��/�J��;F��db!�W�<|�ݕ�c|�JEm2Y������f]��ʵ�YNL05n�&��URw�<�wR��ӭ{,hnVY�mZ&;4r7LfY�,1G��W�6����1�����P����^��A�dP��1�)���M��3>����D�[s*"��8@�`:ܠc�bs;���53���/i��@Z�oEpT�.��Z�g��Ɖ���ғ�iz\���S��|&خ.�@Lc������v������Y�\�>Z΁���F��95O���śV�y��
�d�RPx��֜�64��L��Ɗڂ��!��7�%����@/v�;�Q�������3	������K�J������x�/�9��Ke�Q��S☿@����I��5��G�ӵ�߈\)H��H��8!�s^*��jk�bB��[1kE�U41�<d>ᘙ��EE���؈�2��r�q���.*Tlb��ۣ��0Fy�|/��p�,�A=��!ʼTs����â�&�9�����+�|%�I%#;Nԙ4�^������e�/%�]���gb�~�
?D+L���R7�g�9d�A���o֬���.ʯF��.���p��b�hb�Pߙ�E������Ɲ��
�?�� _�>���8��c�c�B�q!�+F�Ѡ �����Ԩ�)?ś��Bf�M ���
�KͿ����=n�-��l�SB��0�{�� ��hעi��=������y|-�|��%���B�̖��j��㶝�>	��0f`�@�K�����b4%�]����eO}+���R��8�?�� ��ԑ�=�H
��dA��~����P���ymF�I�����+I�����D�D�:�DE�I�MVP�R�UEX�ZD]�_ab!e�g	jOm#p�r�tTuvy=|�|j��R���(���h������>��������_�y�����F������@������>�L������#�������*�g�~����������s���@���|�	���������������������J���=���0���w���k����P�2��	9�s�3���#�%�'P)+�,�.a1?35�6�8�:�<�>�?�@�@�@3APA�A�A�D�E�J�OwQ�Q%R}R�RMS�S)T�T�TUU�U5V�VW�WXyX�XaY�YIZ�Z1[�[\�\]u]�]]^�^E_�_�_M`�`�`Ua�ab]b�b�d�dCe�e�ekf�fGg�ghsh�hSi�i;j�j#k�kll�lgm�mOn�n7o�op�pq{q�qcr�rsks�stst�t#u{u�uvw�w�w�wxBy`y�y�y�z�z�{�{�{|8|�|~~r~�~�~Wu������#�6�T�����F�^�v�������������6�N�f�~������������&�>�V�n��������������.�G�a�{������������C�D7I�F���@E�pw�}KI�|����������E��@?A�*O�*b�w�wxRy�y�z�{�{*|~�~�~g���3�F���))







































�C�D�H�L�O�Q�TsWZ�\_�aOd!g�i}lQo�qt�tvuCxf{�r�����7�֏��.����~�Y�K�:���ۨ�����n�˱�U���޲�D�R��L�z���#�:�W���k�W���$�����Q�"�����������v�x���B�j�����x���k������w����z���\�Iw	��
�N����v�#m%-'�(�*�,j.1�2�4�6�8�:g<G>W?>@�@#AfA�A�D�E�E�J�Q�Q;R�R�RcS�S?T�TUkU�UKV�V3W�WX�XYwY�Y_Z�ZG[�[/\�\]�]�]s^�^[_�_`c`�`aka�absb�deYe�e	f�f�f]g�g%h�h�hii�iQj�j9k�k!l�l	m}m�men�nMo�o5p�pq�qryr�r)s�s�s1t�t�t9u�uWw�w/x�yz�z�{K|�}2~�~��ˀg��L�d�|�����Ă܂��$�<�T�l�������̃����,�D�\�t�������Ԅ���4�N�h�������Ѕ���:{D�D�D�D�D�D�D�D�D�D�D�D�D�D�I�M�M?PQP�R�R�R{U�U�U!X.X@X�Z�Z�Z ]-]?]y_�_�_=bJb\b�d
ee~g�g�g�i�ij+m8mJm�opparnr�r�t�t�t0u=uOu�u�u�u�x�xy|%|7|�|�|d��L�q�~�����"�����ÍC�P�b�����������\�i�{��&�8����
�ƠӠ���šס����Ƣ:�G�Y�T�a�s�w�����a�n���!�.�@�ް���������;���Ų��:�H�������������&�b�y����������n���;���w����������������������D���7���*���q���e�����J�,��	3�m�-����#�%�'J)+�,�.[1935�6�8�:�<�>�?@�@�@.AKA�A�A�D�E�J�OrQ�Q RwR�R3SGS�S�S#T�T�TOU�U/V�VW�W�WsX�X[Y�YCZ�Z+[�[\�\�\o]�]W^�^?_�_�_G`�`�`Oa�a�aWb�b�d�d>e�e�eQfef�f�fAg�g	hmh�hMi�i5j�jk�klyl�lam�mIn�n1o�op�pquq�q]r�r
ses�stmt�tuuu�upw�w�w�wx<y^y�y�y�z�z�zz{�{�{|6|�|�}~l~�~�~Qs���������4�R���ف@�X�p�������Ђ���0�H�`�x�������؃��� �8�P�h�������Ȅ�����(�@�Z�t�����…܅������#�(�-�2�7�<�A�F�K�P�U�Z�_�d�i�n�s�x�}���������������������������ÆȆ͆҆׆܆������������	�����%�+�1�7�=�C�I�O�U�[�a�g�m�s�y����������������������Ň͇Ӈۇ�����������!�'�/�5�=�C�K�Q�Y�_�g�m�u�{���������������������Ɉψ׈݈��������	����!�'�-�3�9�?�E�K�Q�W�]�c�i�o�w�}�������������������Éˉщى߉�������	����%�-�3�;�A�I�O�W�]�e�k�s�y�����������������������ÊɊϊՊۊ������������!�'�/�5�=�C�K�Q�Y�_�g�m�u�{���������������������ɋϋ׋݋����������#�)�/�5�;�A�G�M�S�Y�_�e�k�q�w�}�����������������������Ōˌь׌݌���~D�D�D�D�D�D�D�D�D�H�L�O�Q�R�T}U^W#XZ�Z�\"]_{_za?b:d�dg�gsi�ihl-m<op�qcrt�t�t2uau�u.x�xP{|�|�\���s����!�����E�m�����ٗ^����h��C�Ƞ5���$�����<�ŨV��y�Ҫc���#�X��������@���ɲ�@�N�ݸ7�e����%�B��V�B����}���<�
�������k�u�a�b�r�,�T�{���b���U���v��a����d���F�3a	��
q�8���u`p#W%'�(�*v,T.�0�2�4�6�8u:Q<1>A?(@�@APA�A�D�E�E�JwQ�Q%R}R�RMS�S)T�T�TUU�U5V�VW�WXyX�XaY�YIZ�Z1[�[\�\]u]�]]^�^E_�_�_M`�`�`Ua�ab]b�d�dCe�e�ekf�fGg�ghsh�hSi�i;j�j#k�kll�lgm�mOn�n7o�op�pq{q�qcr�rsks�stst�t#u{uRw�wx|y�y�z�z�{8|�}~�~������T�ہF�^�v�������ւ���6�N�f�~�����ƃރ���&�>�V�n�������΄����.�G�a�{�����Ʌ������!�&�+�0�5�:�?�D�I�N�S�X�]�b�g�l�q�v�{�����������������������������ƆˆІՆچ߆��������������"�(�.�4�:�@�F�L�R�X�^�d�j�p�v�|���������������������‡ʇЇ؇އ����������$�,�2�:�@�H�N�V�\�d�j�r�x���������������������ƈ̈Ԉڈ������������$�*�0�6�<�B�H�N�T�Z�`�f�l�t�z���������������������ȉΉ։܉����������"�*�0�8�>�F�L�T�Z�b�h�p�v�~�����������������������Ɗ̊Ҋ؊ފ�������������$�,�2�:�@�H�N�V�\�d�j�r�x���������������������Ƌ̋ԋڋ������������ �&�,�2�8�>�D�J�P�V�\�b�h�n�t�z�����������������������ŒȌΌԌڌ�������H�M�M,PJPVR�R�RTU�U�U�W+X9X�Z�Z�Z�\*]8]R_�_�_bGbUb�deeWg�g�g�i�i�im5mCm�o	pp,rkryrRt�t�tu:uHu�u�u�u�x�x	y�{"|0|�|�|��.�=�{���ϊ
��p������M�[������g�����(�f�t��#�1��������Рޠ��¡Сs�������D�R��^�l�9�����#�k�y���+�9������~���ޱ#�h����*�g�������t����K�b����������N����{�N�����������������m�����"���������E���C�����(�
��	��K������#�%h'()�*�,�.=1!3�4�6�8�:�<p>�?g@�@�@*A;AwA�A�D�E�O�QRcR�RS?S�S�STiT�T1U�UV�V�VmW�WUX�X=Y�Y%Z�Z
[�[�[i\�\Q]�]9^�^!_�_�_3`�`�`;a�a�aCb�b�b�d*e�e�e3f]f�f�f#g�g�gOh�h%i�ij�j�jsk�k[l�lCm�m+n�no�o�oop�pWq�q?r�r�rQs�stYt�t	uau�u^w�w�w�w
x#yNy�y�yLz�z�zb{�{�{�{&|�|�}
~Z~~~�~9c��_������/�B���Ɂ(�T�l�������̂����,�D�\�t�������ԃ���4�L�d�|�����Ą܄��$�<�V�p�������؅���HxM�M PBP=R�R�R;UU�U�W%X1X�Z�Z�Z�\$]0]9_}_�_�aAbMb�de
e>g�g�g�i�i�i�l/m;m�opprerqr9t�t�t�t4u@u�u�u�u�x�xy�{|(|�|�|��!�#�u�������V�������G�S������M������`�l�˚�)������x�ʠ֠j���ȡY������>�J���X�d��{���	�e�q�ӭ%�1�����i���ر�b����$�S������g����>�U�r�����t���A����n�A�����������������_���������������7���5�������v�	��={������#�%Z')�*�,�./13�4�6�8�:�<b>r?Y@�@�@$A5AnA�A�D�E�O�Q�QUR�RS6SS�S�S[T�T#U�U�UwV�V_W�WGX�X/Y�YZ�Z�Zs[�[[\�\C]�]+^�^_u_�_%`}`�`-a�a�a5b�b�b�dese�e%fTf�f�fgyg�gAh�hi�i	j}j�jek�kMl�l5m�mn�noyo�oap�pIq�q1r�r�rCs�s�sKt�t�tSu�uXw|w�w�wxyHy�y�y.z�z�zS{�{�{�{ |�|�}~K~x~�~*]��A�������)�<���Á�N�f�~�����Ƃނ���&�>�V�n�������΃����.�F�^�v�������ք���6�P�j�������҅���M�M0PNP}R�RhU�UX=X�Z�Z
]<]f_�_*bYb�dekg�g�ijmGm�op@r}rft�tuLu�u�u�x
y|4|�|�2�S���������%�_�Ғ�}���>�x���5�͝������ԡ��â�V�,�p�O���9�}��=��������%�j����,�����y����P�g�����������S��� ���S�����������������r�����'������
���J���H�����-���	��P������#�%m'-)�*�,�.B1&35�6�8�:�<u>�?l@�@�@,A=A|A�A�D�E�O�QRhR�RSDS�S�S
TnT�T6U�UV�V�VrW�WZX�XBY�Y*Z�Z[�[�[n\�\V]�]>^�^&_�_�_8`�`�`@a�a�aHb�b�b�d/e�e�e8fbf�f�f(g�g�gTh�h*i�ij�jkxk�k`l�lHm�m0n�no�optp�p\q�qDr�r�rVs�st^t�tufu�u`w�w�w�wx(yPy�y�ynz�zg{�{�{|(|�|�}~_~�~�~>e��p���
�1�D���ˁ-�V�n�������΂����.�F�^�v�������փ���6�N�f�~�����Ƅބ���&�>�X�r�������څ���L�O�Q�TtWZ�\_�aPd"g�i~lRo�qt�twuDxg{s�����8�����/������Z�L�;�����������o����W������M�{���$�;�X���l�X���%�����R�#�����������w�y���C�k�����y���l������x����{���]�Jx	��
�O����w�#n%.'�(�*�,k.1�2�4�6�8�:h<H>X??@�@gA�Q�Q<R�R�RdS�S@T�TUlU�ULV�V4W�WX�XYxY�Y`Z�ZH[�[0\�\]�]^t^�^\_�_`d`�`ala�abtb�deZe�e
f�f�f^g�g&h�h�hji�iRj�j:k�k"l�l
m~m�mfn�nNo�o6p�pq�qrzr�r*s�s�s2t�t�t:u�uXw�w0x�yz�z�{L|�}3~�~����h����L�O�Q�TvWZ�\_�aRd$g�i�lTo�qt�tyuFxi{t�����:�ُ��1������\�N�=�ĥި����q�ͱ�W�����N�|���%�<�Y���m�Y���&�����S�$�����������x�z���D�l�����z���m������y����|���^�Ky	��
�P����x�#o%/'�(�*�,l.1�2�4�6�8�:i<I>Y?@@�@gA�Q�Q<R�R�RdS�S@T�TUlU�ULV�V4W�WX�XYxY�Y`Z�ZH[�[0\�\]�]^t^�^\_�_`d`�`ala�abtb�deZe�e
f�f�f^g�g&h�h�hji�iRj�j:k�k"l�l
m~m�mfn�nNo�o6p�pq�qrzr�r*s�s�s2t�t�t:u�u�w0x�yz�z�{L|3~�~��̀h���L�O�Q�TbWZ�\_~a>dgwill@o�q	t�teu2xU{a�����&�ŏr��ޗ��m�H�:�)���ʨ��ת��]�����D���Ͳ�;�i����)�F���Z�F��������@��������o�y�e�g�w�1�Y�����g���Z���{��f����i���K�8f	��
v�=���zeu#\%'�(�*{,Y.1�2�4�6�8z:V<6>F?-@�@UA|Q�Q*R�R�RRS�S.T�T�TZU�U:V�V"W�W
X~X�XfY�YNZ�Z6[�[\�\]z]�]b^�^J_�_�_R`�`aZa�a
bbb�d�dHe�e�epf�fLg�ghxh�hXi�i@j�j(k�kl�l�llm�mTn�n<o�o$p�pq�q�qhr�rsps�s txt�t(u�u�wx~y�y�z�{:|!~�~����V�݁O[g�ku���������
(2<FQ^�R�U-X�Z,]�_Ib	e�g�i7mpmr�t<u�u�x$|�|}����O�����h�%���Ҡġ��F�`���m�-�����z��|�o�b�U��H � � =!�!�!2"�"�"'#y#�#$o$�$%e%�%	&\&�&'S'�'�'L(�(�(f1�1F)�)*�*�*]+�+3,�,	-t-�->.�./m/�/70�01
2r2�2<3�34k4�455�5�5d6�627�78m8�8?9�9�n�a�T��G � � <!�!�!1"�"�"&#x#�#$n$�$%d%�%&[&�&'R'�'�'K(�(�(E)�12�)*�*�*\+�+2,�,-s-�-=.�./l/�/60�01e1q2�2;3�34j4�445�5�5c6�617�78l8�8>9�9:�g�	Z��M��@ � � 5!�!�!)"{"�"#q#�#$g$�$%]%�%&S&�&�&K'�'�'D(�(�(=)�12�)**�*U+�++,�,-l-�-6.�./e/�//0�0�0^1j2�243�3�3c4�4-5�5�5\6�6*7�7�7e8�879�9	:�k�
^�Q��D � � 9!�!�!-""�"##u#�#$k$�$%a%�%&W&�&�&O'�'�'H(�(�(A)�12�)*�*�*Y+�+/,�,-p-�-:.�./i/�/30�0�0b1n2�283�34g4�415�5�5`6�6.7�78i8�8;9�9
:�M8P�RtUX�Z]r_6b�dwg�i$m�oLrrt u�u�x|��:�_�����1�����J�����������8�[�E������*�o�����1������Y�p�����������\���)���\�����������������{�����0���#������S���Q�����6���	��Y�����#�%v'6)�*�,�.K1/3
5�6�8�:�<~>�?u@�@�A�QRmR�RS�STsT�T;U�UV�VWwW�W_X�XGY�Y/Z�Z[�[�[s\�\[]�]C^�^+_�_�_=`�`�`Ea�a�aMb�b�d4e�e�e=f�f-g�g�gYh�h/i�i!j�j	k}k�kel�lMm�m5n�no�opyp�paq�qIr�rs[s�stct�tuku�u�w-y�ywzl{|�|d~C�y����2�I�q����C�D�H�|�g�>�L�����۸�@3A�O�bPwzw�wxFy�y�z�{�{|�}~v~�~[���'�:���nw�}bw�}*-48<@DHLPY]aei|��������������"18<KRVelp��������������")-?FJY`dsz~�����������	
$(8?CSZ^nuy��������������.59MTXkrv�����������
		0	>	L	Q	V	f	n	v	~	�	�	�	�	�	�	�	�	�	�	�	�	�	�	�	�	



&
.
6
>
F
N
V
^
f
n
v
~
�
�
�
�
�
�
0Edy�����2H_u������
&
=
S
i
m
t
}
�
�
�
�
�
�
�
�
�
�
�
�
�

%-5=EMU]emu}����������������
%-19AIQY^fks{����������������#+3;CKS[cks{��������������������"&.2:>FNRZ^bjnv����������������
"*2:BJRZbjrz������������������� &,28>DJPV\bhntz��������������������
")07>ELSZahov}������������������	%,3:AHOV]dkry�������������������!(/6=DKRY`gnu|������������������$+29@GNU\cjqx������������������ '.5<CJQX_fmt{������������������#*18?FMT[bipw~������������������
&-4;B_I`IaIbIcIdIeIfIgIhIiIjIkIlImInIoIpIqIrI�������������� �!�"�#�$�%�T�U�V�W�X�Y�Z�[�\�]�^�_�`�a�b�c�d�e�f�g�h�i�j�k�l�m�n�o�p�q�r�s�t�u�v�w�x�y�z�{�|�}�~�����������������������������������������������������@AA�O�OPPPPPPP$P)P.P3P8P=PBPGPLPQPVP[P`PePjPoPtPyP~P�P�P�P�P�P�P�P�P�P�P�P�P�P�Pccc$c)c.c3c8c=cBcGcLcQcVc[c`cecjcoctcyc~c�c�c�c�c�c�c�c�c�c�c�c�c�c�c�c�c�c�c�c�c�wxTy�y�z�{,|~�~i���H�ρ�E�J�����#��MPP�R�U?X�Z>]�_[be�gjImpr�tNu�uy6|��!�a����z�7�	��֡ŢX�r����?���FS�Sdf�fsI�|&������������@FA�P�c�w�wxYy�y�z�{�{1|~�~�~n���3�M�ԁ?`PBVY2_5O8U ;
>^ATD1]47S:=\@RC[36Q9<Z������(�Ȕ��a��1��;?#u�|S�����)�Ə��a��1��;�s�a�+��q�m��\core_intrinsics���a��1��;���Z��nI����(��a��1��;�t��m
�	����*��a��1��;/��B2M���}����fmt_helpers_for_derive��_�_a��1��;F�S
F4��ϭ)�a��1��;x��R�"�����){�a��1��;%~�B�4������(��a��1��;�
��������(��a��1��;������p���΀C���Z��a��1��;>I>Ϫ������)�a��1��;y�
����V��u�=����`�`a��1��;Ƅ_�N����)��a��1��;���G';~e����)��a��1��;�����q0�~$��u�����derive_clone_copy���a��1��;�JA��@��Ӭ)
�a��1��;SU-���I����(m�a��1��;�s�
̍�e�����\����a��1��;Ũ/]�t����(��a��1��;q�Ž4I5����(��a��1��;�Y�\pW ��q�e�f\��	derive_eq�����a��1��;G-j��>�����(p�a��1��;IY,T%������)l�a��1��;��H�g��Pt�}�J�������a��1��;�r���>���֫*��a��1��;R��	3������(1�a��1��;)����U�u���O\�����a��1��;1�����
��±)c�a��1��;�&����0����)��a��1��;�8�g�'����C���a��1��;�ql�� d��� �����_�_a��1��;o�O��N����(U�a��1��;#˛b�dui����)Q�a��1��;\z��l
�?��ت)�a��1��;5F�B������(��a��1��;%*F�:�����������a��1��;4�������ư)�a��1��;nu
`�'������(l�a��1��;�an̑:�~$ހ�������a��1��;��o^?�}����(��a��1��;��A�p����*��a��1��;6J���q-��������a��1��;�2�V$�����ܩ)+�a��1��;��n��p+����)Y�a��1��;
�w�&��^�T���`�`a��1��;e�K)��dc��ɯ*��a��1��;^;?��:w�����(	�a��1��;ׁU4�Z2�O�S��a��1��;�X��W��t$��������a��1��;r���u�%����)�	�a��1��;^�6��3.����)�	�a��1��;?��2��$�p�������a��1��;��_��{�����(1
�a��1��;�8$V�����)-
�a��1��;��I+Q�����)[
�a��1��;��jՓ�W.�����������a��1��;�өzzd���ˮ)�
�a��1��;u�f���{����($�a��1��;j�p����ajA�5H55�5�5�5t5T5(505�5�5�5�5h5<55`55�5l5 5�5x5,5�5�545�5�5@5�5�5L5�5�5X5�585�5�5D5�5�5P5�5�5\5�5�5d55�5p5$5�5|5�5^?	<8w@u>�<;W9e7A?V=�;�9�76�?�=m<�:�8�6I@O8J6�?>�<�:�8�6�@�>�<I;�9�7<A0?�=�;:�7�:
97�@�>%=w;�9�?�=8<C:}8|6@D>6u?(<?8�@�>�<9;u9�7,A ?t=�;:�7:6�?>�<�:�8�6g@m8l6@4>�<�:�87�@�>=g;�9�7ZAN?�=�;3:
8;G9U7�@�>F=�;�9�?�=]<x:�8�69@e>�hODHT ����~���7C��D�T�����������v��S�]�W��F�>(��
'�Im\;63�u����HA�Em���� q�
V���#�
dk}�P	���0�MJ�
t� -~>��
�4�v��,[�4+�����^��m���fn{u0^����B�|� nƝ��
�?��E1����إ���yE���
+ h��k��8!�s^iÕd4"l��`�{��#0{˖�|B'�4)�<�)!aY�:�t,�3]���,����
�\.���!����.��,~���2X����p2������5�D�	�H6���xtG7`�3�&;4r7LfA
Ff@0���l	�B0����;zC\
Ze��,�D���o�!=2E4t��P�y F��{�87G�����9yH���q���F�|�:��Jp�*f���F������K�J�aQ&��MP��*0g-N��B���t�O��c�^��]M�~��*o(�Q�^OZ��S8Ξ"�(�S��w�����TÐ'���V��C��.*TlbpU�KY�������HZD���.m[�h�q�\�� ���YN<�j��^�:gP�p��b�hb�l5�cT��|��d�����ue<N4;F��db!7:�f�g�O_�^�h3����]k�m�X$oHl�T�x̷%mL����:sm�x.�.�q�t/�\��dq��z���tD`��`��w\[)>|n�wT�j��-�y�̛�.hOz�=�hS�f~�H'��E�<-jb�p�,�s�U9�����"rﰏ�0��	��y��x�uG]�\?�Ph$ S�[�	5�SR����i9l.�IX��Ƌ����Ԑ������X��������]���A
�Q��я���(���&��h�,+2@zq"����Dp
8W�h�r�E���؈�n3��Ԡ4��["�2��P;L�Z��̄\S�w��eq�L���,���	�P�6�,h�xIL��
	�0Q�� =���;�)H��Hh��Ϫ��I�ʽ.��&O��]���|7�Dw3���@�8<������;ˤ���/���ۣ��q8�?�� ���J5����9����C�����]��E� +�K����:�l�ܻ��:�HaiB���į����������d��5� �|N��`����+C�������d��ɤ��K&خ.�@LcS��s�h)4����@/v^ts���<�v�K�����b��E��6tv|_�#�t�M-0Fy�|/�r?��#�`�n�G���\!F������$�B�x��_��-$��N*�<�[�@�)S@�`:ܠc�KSy���]"�ϳJ���Jbs;���53L��]����W�<|�8�n��l^D�B�q!�A�#���7��a/��rc=�-�lNH�������x�0{��)�LH<��
��ڎjei5�X��R�wf��k��3�$�tE!%;���U�wW�6���C�ޙ�@~'<☿@����e�d�Si�K`��L+K�?���5V��<�Q�oC����D�I�f��n�������vT���
�K�u���a5�\4���iQ�>�������y|-�|��23�9�/$���ilT��z5�}أ#S�&���{��O��^��c�����Y�sc�]_UF�M��"�� c ����[s*"��8J+�|%�I%w*ȃ�&���e�/%�]z��>�(�Y�6���(i��E0T��-���)�Sh$.I�

�(��/徣�JL�/��V���1�Y��7>2}�� ����3	��`�4t�4�����ݕ5��V�i62���N�7�j����08�׶3���8mj:�ݐ6:5t	qURw�<�wR>㶝�>	����K�@�����v�A��5i��C���{�؋Dmup����E��o&o眎E9
.E���E�e�Y�,1G��B���IQK�'�Q�J�Ӂ�P�R9JYe��/�J��6�;M
�Y�I��M�h���FEqM9(Wgλ�N��r{ʲ�Q�~<�eفO��
�P�~U������W(����EXA�-����Y
>C�C��[Z-B�AR��IX����SM\�N�E�u�\�(pp92+0`m/H���gb�{��rc�)�[b�gd	���!�eš�4��f���h�0ge�g�h,h�1&���i�nI���x�hE؄�ŇxiY�A�-��l�SB�S<�oy�:��(wp�^'�d�6p5U��E6'p��1"�\sy+wRL�+t��t�ڃ�u���H�xv��"����!w���W�@Z�oEpTN���ymF���+�}�^�j.�~��G8B~5k[��[�ƒ��=��]Y��]�����
5.��o�A]	��8䣆t�yVTы	H��7]gh�Uz�1�t�a��{�N�&��]YZ���z���ti���*��<y(K �4�1�S:+��1�T�������z�D�L���}���r��͝(��_��5��`BT!o��
f�ցʚ�o���2�i�����f�|2��f2>ᘙ��Em��=X�11ؤ���B��=����������xb^��A�F>��!��ϑ(AM���2j�ޱ����t��6��A�{�I��5��G�f��
��$yF�Pߙ�E�L�-���sS�1����ԑ�=�H��]�W����O���śVXy�)��AcO��a����7���`�*�6�M�BQ��E���>������H[��!���q�kı��d;��u�5Ӵc!:�5}�s�\S���F��95W4%�]��6WQuʙ
��u��I��2�ġ�᝙|�Y	ѕ�= ���N��tO��N�h��vP�)eo��9ϴ�J����� ��ݛe/2|�ٹ^�T8���M���9d�A��~3�m����������t_�to��x��,GV����j-���z�.�8�������p\�Uw>}ķ��O��|��"���b��Ԩ�)?ŊK�_`��6$nVY�mZ@��a@�Q��q�Ǎ�����s.D[��	}r��/9T���3`5���0Q%~����P�M�3<�����u���B�$	a{������U�M���e���}��y��
�d�Y���������Tv�����`����	��j:6a`�d�M�y�R�K��{luJw�}cTp|2�����;,��z�~O����YF��w �!sl�B,� o�A=��!ʼTt)�k$*^��J�%���ATL8%ֺ�0��g%n���ͭ-)>��c�]T,کwR�,��/��dP��1�)G��ؘ2B�^�a�|3N(��ݵ4Jv2M���s5�ȭc,�\5��^�
�Q4&�{��)�"8J�z�>��9^╿���k:�}5�F�n8b'����h;<�s�0~�7�=�1Tf*�j:.Ӛ��p�<J�5k|��@2�ex
��dA���~�
?D+L|1|H�E2:�$���G.F��Iǝ�KF�z��'N�^����OF"��Ke�Q��Sd�]�W��K-�_�8X6F�W3~W�
�\�>Z΁�V��
�[V��Z�77�[8ʩ���^�׈#�q_^H|3���`z�!Ql��a�����c}cr������Bf�M ���T�i��Q�ғ�iz\�Q0�k�#��O��lF]���!��n�&O/ՈEo���
�*Çp�Y��xo���6�e�ozDu,*��u�yLQ��&v�Þ�(kl�x���	�|>�]=���V|N����~^r���t
pZ��'WkNL�����O�,�j�?��Ub‚�O^F�1�6��~����I\9��+A����Z��D�N�#�T�Ɛ&:r�����r, ����g�
%��@KʯF��.�݀P���R��U��Iǘ>�T���ȩ�vxh�~�����m`�-W�&�ђ�6�ٛ.$3�ȫ+���:Ӈl6�L��De"�����x�.������4�+�z�B���b��1�&���⃧&��S���B���'�J��j���oj��C��rh53�j�6g�v��Y_�b.H�o֬���.�S�~�^�ו���x��٫?Jh��+��P>d8��m2Y�����:�ao��.@ݶF:Ï������;�'���M��3>H�.��Z�gO�^������y\���:C9���òH�L���v}��mJ��н>�><�^1OdR�D��~R���Q���p3����K�"=��Ϳ����=n�L���Պ4�
<B�Q���uy4|���q|� _�>�ۅ���R����Ɗڂ�\�;ړۢ�)H�Z
�2�%�5��w��<"�3�	��a�Sގ�ZuH�������B]�H��޴U��
X�7�%(q��.���T��q��d� �&�:���1�����DL05n�&��=�z!E�҇,#����F���N
5��Z�n��p�:��y����z����Y��bf�2~~,���0��̖��j�Ӕ��L��zS��/�9��cҹ[�?�^U41�<dl�X�h�x�9�l�7�RPx��֜Z0�v�hw�M�-G��2f����nd�����
�Ot<m�m�#�p��S��|R����䊃�#m��P����@_]s
t1G{QX*�X�RO������/i�M�8��c�c���=�������P����L�4bbל��]S0C^P����Eӵ�߈\g�G��"g�[]�o"7#{��T��$�9b�Z,*O4g��ed+3PǓr�[�,+9w�7z�,�����W�*w
>!t��/�@+��N�0G���,���-�Oxm���2ᤪ���3�?H�8y4�/mI���5�B��[1kE�k����9�^���w�;2+���<�SC�P&Aӆ8:\�MB)n�#�D�27F�S�E��R�:�EHb!����G�sG��нHcLX;��G����~٥JuG���'D�,�h��3GC[�ϼnXHk�2�7��N_����h_�N��ב&�Pwc�k�n�O�m�)C1�O?v��ـY�IS������hTo�S���.N�z�i��FV/�Y~�0`W��!cG9YD��w���Y�b<&u�Z�U���R7�g}�+F�Ѡ�����]�����f]���;�0f`�@Ӗ���~e�b[iX�rf�^f�'M5�g��_�W|h���j ��hעi�Oldyj���*��jk�bj���eO}+�T�nӣtf��po\�	X�xq��Q/���+u��PNk��v�����EgwK�ri�*�u{[�"��0�{���ݕ�c|�JE9>^�<}'�?�"��~��of�u��C�O�J������|SǴ�����M���Ɖ��P������Y�Uqǚ�s�,Ӑ!D�/�ygM]G���a���F�O@�I(9�gJP9�Ē�?�(>!�j��c@���3�+���#;Nԙ4xε{!��`���K��QP�n���7�HT�=,�:��|}�-������kC*c#�J�+��;�Q���_s����â�u��ӭ{,h?h�2���`���e<�c�\ұپ�w�{@W@՜�TÆ��M�}�T@�h�w���%���B����'(���R[�C�w���!������a��1��;0V�#�֕sz���g�f;��禕+K�v#�/�s��64��L�[������[3�!��7�%]&i� �/���x�]ғ��;V�����غ�/��6��<�_��9���%�ꩼ��?;��L]b��(���
ٿ^���$�t�ã��x�-�K�̧QaK'�w5�D����CP�9���^k�Y�V�E�f��y����!�@l��C��r���ψn�]�O��#�)����^��Z�u���&2��r�q�o�Uq��g��J�JM��c�s���@����T�
{9���l�����$:u��<=���������^1�;������G����=�&�9�����v�K����Wi��0����2�!K��U)�#b 	>-_Qp�[���<
�r/Se����0��.Df��^B�T�������K�O-n{fJqxcox@!1p'�O;a!�xP4'3���1YL'��PEk<��=�0��5f���5E�b���{:�4���EI�H ���G9[���Q.8@Xxr
FtIC��GZ���E�������~>ZU1�;;1�:&���\�7#/h%�h�V�/���b$QmwF������Y�sk��7W7;����%e��\U>�*�Q=[,�*�B���t.\e���^QKJEax5[5�)�E�W�c872`@NK,u+9z��L�!`Gc8���mLVR3$BQ!��*;Qwv*z���Ev-���o?T���`q�-:<)*aiA�pu"�����}cL<f��H�=W<D��H]$
+���'zv�_F�dGi>)
U�sL�����'(�Z^2Hnq��/��<�i��J�|�P��b����-s{9(g�����	R�>�My��m~�&w��s���P��K�9
*�sqsD���;���d/==J>QH*M2[��&_�O�����/Z�)�����%b@Rbe�D>B�_����mkTV�a^n:��&O�n���.wWc��/y.�����}��9��%n�[*<hi"}�da����{�RM5v$kU�Tlv�n|]3d����O��>�h'~M7�������K:8mL[lvP
-\*S�|��8j����w-��X��R�OOi�)�~2�M
N4�Z���2:h>ET9,e]1�|`Y/y��.��-q
�����3c;W
 C<R6$u��^�)����
7�P19v#r-FwsOPI)=,Q3Pse�i����-3d{4b1��A(���(cf��"qG!XZ�������&TK]�0��l%I�� S���0(���$	���w`�40F�=aNrP����)|�����GW]J���9B��-���Yg��]��QoXRfx����5��a{�p`@9*Q��4!K��U)�#b 	>a/home/palash/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/byteorder-lite-0.1.0/src/lib.rs� \Nq��n�si��8e!���;LPJRPNLJ"KME?/-I77B3--#:K;2$#)*,+);=+J@4$2
1"#
6#$
3"#
8#$
 2
$3N+(FJB=LHE932960,3'-
	
5%$D%D76=%'5%=76=$D%D7>E%'5%=76=$6&>77>&64@7:A465@7=D88%=729*G%D76=++8%=76=*G%D7>E++8%=76=*9&>77>,EO@7:A:EP@7=D>2%=73:%#A%D77>%&2%=77>%#A%D7?F%&2%=7;B%#3&>7<C'%34G76=4:35G79@8@J%=7.5%,J%=7 07%,5%=73:+'D%D77>+*5%=77>+'D%D7?F+*5%=7;B+'6&E7<C-)BO@76=:@BPG79@>FK%=7.5+*K%=7 07+*>0=7 4B&?03>0=7!4B&?03>0=7!4B&?03?1>7!4C&@05:0=7 0B&?03<0=7!4B&?03<0=7!4B&?03=1>7!4C&@05M0=7!>B(?03@M0=7!>B(I0P>'M0=7!?B(?03@M0=7!?B(I0P>'?0=7 4B&?04?0=7!4B&?04?0=7!4B&?04@1>7!4C&@06<NMIM).<E .A3*7
=0=7 0B&?04=0=7!4B&?04=0=7!4B&?04>1>7!4C&@06N0=7!>B(?04N0=7!?B(?04ML>4&1?,ML>4&1?,ML>4&1?,NL>4&2A.KL>4%1>(KL>4&1?(KL>4&1?(LL>4&2A*P2L,P2L,&K60/6D $$')K9329D #''-.LN-K6?,7'$0K=-!&0K:'#KA;<9$1G@
KA;:9 #1G3
%9%9%9';5L(6 9L(6!+4+4+4-5;8&I?<&J4343436443434364434352525273525252735252-, 
-, 
-, 
/, 
-, 
-, 
-, 
/, 
-,:
-,:
"%9%9%9';5L7 9L7!+4+4+4-5;8&C?<&C4343436443434364434352525273525252735252-) 
-) 
-) 
/) 
-) 
-) 
-) 
/) 
-):
-):

D!)(22/6&'65 #
3*
%;D46&
%;D46&
4;!-6).F"2/HFA%2/KIA%2/KIA-)).F("2:/NBE%2:/L@E%2:/L@E
!
!
%
%
!
!
%
%
!
!
!
!KK
&
&
&
&
&
&
&
&
&
&
&
&
&
&
&
&I!L9)F '5, *5/ *5/ (98 +9; +9;?F '5B *5E *5E66666688::,,,,,,,222222222444444*******000000000222222F!1.F '10< *10? *10? (5,= +5,@ +5,@!!!!!!" " .G'$9***+***+---.---.
: '0&- -6)4I#%"2.E9GEA%2.H8HA%2.HF/!GHAM)4I#%"2.E8?E%2.H8BE%2.H8BE
 
 
 
 
 
 
 
 NN
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,1N')(F("=.NN<AB<'7%=.NN<DB?'7%=.NN<DB?'7FFFFFF

HH��A�hB
b�Rs�,{`/home/palash/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/byteorder-lite-0.1.0/src/io.rs� �	A���oV|�8��A��HOOG>31;;'-?#DL3Ea4*///*$AL3Ea2*5/0*$EEa@75??:$BEa>7A?@:$EEa@7;?:$BEa>7;B:$EEa@7A?:$BEa>7AB:$EEa@7MK:$BEa>7ML:$EEaB7YK:$BEa?7DL:$FEaC7(<;`<$CEa@7\N<$FEaB7;EJ.1CEaB7;EI.0FN.4CM.3NEaP7($K:$NEaP7(<K:$J1IOOG>4..''-A%CM3Ea4+"""&2@M3Ea2+""#&2#DEa@8"22.B#AEa>8"23.B#DEa@8"256B#AEa>8"556B#DEa@8"29>B#AEa>8"59>B#DEa@8"=2NB#AEa>8"?1NB#DEa@8">2^B#AEa>8"??^B#ED$BD$EEaPA@8"?5F!,(BEaPA>8"C4V +(EPB$/(BPB#.(MEaP8">.B#MEaP8">>B#L����2�}����q�e�y‰x86_64-unknown-linux-gnu��FS����{Ԍڰ|%byteorder_lite�-b23754f5d3aa0269�a��1��;ܜ
��-���������*����
�����
��
���	���������	��	��	��
�����������������������
����������
����

2����� a�a����rust-end-file