📄 libadler2-77815029477dd201.rlib
/home/palash/git/iron_learn/target/release/deps/libadler2-77815029477dd201.rlib
Language: rlib • Lines: 579
!<arch>
/               0           0     0     0       200       `
N�N�N�_ZN54_$LT$adler2..Adler32$u20$as$u20$core..hash..Hasher$GT$5write17h75ed4f73d9a2f654E_ZN6adler27Adler3211write_slice17he07c19a0e7999b3cE_ZN6adler213adler32_slice17h1cf0618a0056caa7E//                                              62        `
adler2-77815029477dd201.adler2.9ab8658d855d1a92-cgu.0.rcgu.o/
lib.rmeta/      0           0     0     644     19712     `
ELF>�K@@GNU�rust
CI#rustc 1.92.0 (ded5c06cf 2025-12-08)��١�	�T�6a��D�
-5080178c80bf7a93��**�٭T��HО�9�-3e2e950d4bac10b5��$��<��,�|�BufRead�<��%�#!#adler32�<�)�<�)�,�)|�)tests�,�,�$�,��algo�
compute�MOD�
CHUNK_SIZE����
�
�

from_checksum�checksum�write_slice�>finish�write�
adler32_slice�U32X4�#
#�%(�)Adler32�+a�+b�.�1�888888888 8!8!8"8)8/8/8/828�##$�%��FJ}�G���������������_++�,�-�|�~�u`�������`�'#0+(#1+###.+++�2�
�
�����_��`,�
�������#65521�D�$����	5	8��	6�	j�	��#
�	,��	�._��
�	+�	6=4��"
�	&+�	6=4�(�"�")!&�2�<EO���	�*��	��4�T�&��	��&���&T�&���&���&T�&���&���&T�'���&���'�'��%��%�L�%�,�%�d�����2�6d��'�	�7�
���(	��
���(	��
���(	��
��(��'���'�L�'�D�'Lquotient�'R��)����)����*����*���*��)���)�L�)��)rhs�F0�	�_0�	� ,�(�
�_&
������P�	�/{��������������������q�aX�ÅÅą��:�������^�^��^��[�^buf��[����e�S�L���������������������(��2!&�2�9BL������4��;|��$�(
T����\��,����Q
+������$���������sum�$F��������
��@�
+��
�����������>a̱��4��iI���B�����4��^����-
 ���[�I�L���������,��������1s������$��|� ��������������������
��iK�� �  �� B�T� �������J�K�L��Ԭ �$� �,� �K����������;�d�"
#$#�.�5<J
#_$k�v�}�"+����4��`��=�%" Adler-32 checksum implementation.�&��*! This implementation features:�L��P=: - Permissively licensed (0BSD) clean-room implementation.�Ď - Zero dependencies.��� - Zero `unsafe`.���$! - Decent performance (3-4 GB/s).���=: - `#![no_std]` support (with `default-features = false`).�����8�l��7https://docs.rs/adler2/2.0.0�����7����8�$���8�$���8�$���8�t�$�8unused_must_use�|���:"+�������`���ė�D�$�#$�<+	AddAssign�L#�	MulAssign�L.��	RemAssign�L9��	te�+QS9;!#dF��Y.<g343�4
�
o

$tbytes�,zt�����T��	�	T�"��#$�#55�.��#
�-,�#��$�����%%T�%66����%
$�%���'�����''T�'77����'
$�'�\	��(�����)"T�)88����)
$�)�Z
���d������74 Creates a new Adler-32 instance with default state.���
��,��GD Creates an `Adler32` instance from a precomputed Adler-32 checksum.�����[X This allows resuming checksum calculation without having to keep the `Adler32` instance�\� around.���l�
 # Example���<� ```�Զ # use adler2::Adler32;��� let parts = [�|�     "rust",���
     "acean",�4� ];���41 let whole = adler2::adler32_slice(b"rustacean");�����! let mut sum = Adler32::new();���)& sum.write_slice(parts[0].as_bytes());���! let partial = sum.checksum();���|� // ...later�����2/ let mut sum = Adler32::from_checksum(partial);���)& sum.write_slice(parts[1].as_bytes());���&# assert_eq!(sum.checksum(), whole);�<��5l���
�#���:7 Returns the calculated checksum at this point in time.�D�99���
$���+��-* Adds `bytes` to the checksum calculation.�����]Z If efficiency matters, this should be called with Byte slices that contain at least a few��� thousand Bytes.�\�:;:�;�.��
$��-,�������<��
��� !�`�`! �� 4� <<��$� 
 $� �� !,� =>=�>�.�� 
!$� �-,� ��"(��!52 Calculates the Adler-32 checksum of a byte slice.��!���!?< This is a convenience function around the [`Adler32`] type.��"���"$! [`Adler32`]: struct.Adler32.html�l�"??�.��"
"data�$�",�"��FJ}�G��$%��S2��##
$D�"##�p�	 �"����)�)��@@��(�"(
),�"p�	����! Adler-32 checksum calculator.�����da An instance of this type is equivalent to an Adler-32 checksum: It can be created in the default���\Y state via [`new`] (or the provided `Default` impl), or from a precalculated checksum via���YV [`from_checksum`], and the currently stored checksum can be fetched via [`checksum`].�����b_ This type also implements `Hasher`, which makes it easy to calculate Adler-32 checksums of any���	da type that implements or derives `Hash`. This also allows using Adler-32 in a `HashMap`, although���
`] that is not recommended (while every checksum is a hash function, they are not necessarily a�t�
 good one).���t� # Examples�����*' Basic, piecewise checksum calculation:���<��5�� use adler2::Adler32;�����#  let mut adler = Adler32::new();�����" adler.write_slice(&[0, 1, 2]);���" adler.write_slice(&[3, 4, 5]);�����-* assert_eq!(adler.checksum(), 0x00290010);�<�
�5�
���
'$ Using `Hash` to process structures:��
�<�
�5��
 use std::hash::Hash;���
�J���� #[derive(Hash)]��� struct Data {���     byte: u8,���     word: u16,���     big: u64,�,� }�����#�J����:7 let data = Data { byte: 0x1F, word: 0xABCD, big: !0 };��� data.hash(&mut adler);�����41 // hash value depends on architecture endianness���'$ if cfg!(target_endian = "little") {���1.     assert_eq!(adler.checksum(), 0x33410990);�,��N��$! if cfg!(target_endian = "big") {���1.     assert_eq!(adler.checksum(), 0x331F0990);�,��N��<��5���� [`new`]: #method.new���,) [`from_checksum`]: #method.from_checksum���" [`checksum`]: #method.checksum�<��|�~�u`,-4��++�4��++��/�_/ABCA�B�^�^��^��[�^��[����e�S�C�.�.
/,�� �����2�2��DD��1�1
2,�>��D�p�
��"�� �
�	��{
��struct.Adler32.html��
���+�W���
���W�
���Adler32ab�X�X�X�X�]��e���%�Do�dP)�r+��^s��]�A
7:/	H�rvm|"w�P�M�C�I~b��Uؿ�i��JW*#�j�a�%h���
m���}.�>�e��Z*��ۋ����1�$�9�ezl��
"��}5�Aק �^“Ew%�F-���IS�m�g�݄���gTa�����pL/:u�찇u0T�*�t�n��~�+�SBL����XK��cg+cs��I�o���F�K)���Bʘo��8�i��NSb�1ā�戁�k?��2�V��4��3�(��/�(X5vY�%
*�����X<�!����]����t�J�}�(��⽳�,��f]L��Q������W�����-'؛<x��:<z�����B��T�W�E;�[bl
����<J'���1�w��ƽB�X��V@�`��[��#C��d>�Z3
��+A-��t���
d�4����`��ţ!1F˼~�Vy�u�tkp�j*,Y?�:�)�.�Q���qcr�܈T�]#�H�:y6�;�Y �8�FfG6c�R�+�+�v��AT��-�����t���R�� 1!V!j!�!�9!�)�)�)*�*�*�*��M����� f!{!�)�)�*�*

%��i�B�f�=K�g� � !3!�!�)�)�)*�*q���w|�����+=P��
(}���
~�o���M�� � -!C!Q!g!�!�!�!�)�)�)*�*�*�*$+*+1+7+=+C+I+O+U+\+b+h+o+u+{+�+�+�+�
z����T�-��Q�(6�R~ � � 1!�!�)�)�)*�*'+.+4+:+@+F+L+R+Y+_+e+l+r+x+}+�+�+�+��'6I���g��v�`}���>�� � #!=!L!b!w!�!�!�)�)�)�)�*�*�*+��
!.C���[���n�Tq���2�� � !5!F!\!q!�!�!�)�)�)�)�*�*�*+��):K���k��z�d����B�� � )!A!N!d!y!�!�!�)�)�)�)�*�*�*+�k�C�g�>L�h� � !�!�)*�*�k�C�g�>L�h� � !�!*�*�X�1�U�,:�
V� � �!
*�*"0>���L��l�	
y
x����
�`]�n�	�
w
\�
���
_m�	�
x
w��6�k�
�'!Tf�dXj�h���o�~�h��F�� �!�*+��A������ Z!o!�)�)�*�*� �)� �)
#'+/37;ISdhlsw~���������������#*.26=AOW_cjnry����������������� �)�N��	
���|!�)�*7779999999999799�+<P!�!�O�$���f!�!*�*�*!"���~$�u���core_intrinsics�derive_clone_copy����]��e�����
�G�������Z���]��e���c�����o�}���zfmt_helpers_for_derive��_�_�]��e�����KG����"|���]��e��p�>ZO"tJ}�J��z�z���]��e��������n��]��e���X��W��tQ\�z�z���]��e��#'��8s��~$�"��z�z���]��e��*A�2pݱ,�>�<�<�<�<�<�<�<�<�<D>�=g=�>>�==k>=[>�=�=�>4>�=W=�>�
ODHT E���܈T�]#�AB�X��V@5�Y �8�CVy�u�tk=^“Ew�]��e��I~b��UW�E;�[b1�#C��d>7)�r+��^�:�)�.�Q?-��t���9��`��ţ!;�݄����w��ƽ4��Bʘo�-'؛<x�.�I�o������X<�'}.�>�e�t�n��~�l��
"��}�JW*#�j	�a�%h�
vY�%
*�&��/�(X5%P�M�C�p�j*,Y?>s��]�A
7:/	HgTa����4��3�($���k?"
d�4��:�8�i��NS �Q������,�$�9�ez�pL/:u��}�(��⽳*1F˼~�<�Z3
��+A8b�1ā��!%�F-����F�K)�+�SBL��W�����-!����](��u0T�*��2�V��#5�Aק ��`��[�6��Z*���
J'���13l
����<2���qcr�@��B��T�0FfG6c�RD�,��f]L�+ؿ�i���
m��������1�%�Do�dP+cs�����t�J�)��XK��cgH�:y6�;B�:<z���/�rvm|"w���IS�m�g�x� �R5�����M*1/(i[^���H��
F2]>
�v����$��{d)[�=vY	�� ����s�s�������e��.�lP���
m��
��fT)H��
���G(���rF3���N�{3���x� �R5�����M*1Y/home/palash/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/adler2-2.0.1/src/lib.rs� k�5������ER��SH�=�&">%>8T;'(+
"e]Zcea+$##.($;5(2%2-#<L`9&.&7.+3#
?$62b2#(!6@%+ @_b
F;))#/? * ) 
+69:;B>E69EI=(*(78@a98@ .T07,
&-0?�$��bR�g—ͬ�RZ/home/palash/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/adler2-2.0.1/src/algo.rs� ������x�q?���c��*�153"eZ8e`Pe_?,Z1cdYE>X@N0SXgTdL ,'''P*96"41 (
P:-
/9(..$
$
:("
##
$!!!!!,P!!!! . )��������!
xP��C�P�H�z�AF�Gx86_64-unknown-linux-gnu���BE��x��i�jadler2�-77815029477dd201��]��e����R��PE�,�333�2E�3E.fE.E��33f3f3f3�3f2fd3+f3Vf3f3%33J3++VV333�2d,,XEX�,3Xf3�+2VdL�	�	�rust-end-file.note.gnu.property.shstrtab.strtab.symtab.rmeta@ .�`�J&0KHKIK5/0              0           0     0     644     3048      `
ELF>(@@�%PH��H���D$H�|$��D$Y�q��q��q��q����������UAWAVAUATSH��D�H�|$�D�WH��H�����H��H���c���yH���H��Li��VH��L)�E1�I���VD�D$�s E1�1�1�E1�E1�E1�1�H�����Ai��Vf��fofoA�q��L��I��f��f���I��@���f�fCn�>�Vf`�fa�f��f��fCn�>�Vf`�fa�f��f��fCn�>�Vf`�fa�f��f��fCn�>�Vf`�fa�f��f��I��u�I���VH��@���A�fo�f��fp��fp��f��fp��fb�fr�fp��f��fp��f��fp��fb�f��fo�f��fp��fp��f��fp��fb�fr�fp��f��fp��f��fp��fb�f��M��M��I��/Ei���E)�H���V�����fp��f~�fp��fA~�fp�UfA~�fA~�fp��f~�fp��fA~�fp�UfA~�f~�H����ffff.�F�D�F�DE�F�DE�F�DD�A�E�E��I��L9�u�A��A�q��M��I��/Ei���D)�E��M��I��/Ei���E)�E��M��I��/Ei���E)�A��M��I��/Ei���D)�E��M��I��/Ei���E)�E��M��I��/Ei���E)�E��M��I��/Ei���E)�A��M��I��/Ei���D)�E�D�A���A)�G�@D�\$�A��A¸q��M��L��I��/Ei���E)�G��E�G�|E)�E��A����D�D��D�H��t+D�D�Aу�tD�DD�Aу�t
�L�Aщ�H��H��/i���)�H�t$�f�D��H��H��/i���A)�fD�N[A\A]A^A_]�rustc version 1.92.0 (ded5c06cf 2025-12-08)zRx�0 A^@H�ABB B(B0A8�������0B(B BBA8��/&�J�� 	��������	�������������������������� 4L.text.comment.note.GNU-stack.rela.eh_frame.strtab.symtab.rela.text._ZN6adler27Adler3211write_slice17he07c19a0e7999b3cE.rela.text._ZN6adler213adler32_slice17h1cf0618a0056caa7E.rela.text._ZN54_$LT$adler2..Adler32$u20$as$u20$core..hash..Hasher$GT$5write17h75ed4f73d9a2f654E.rodata.cst16.LCPI2_1.LCPI2_0adler2.9ab8658d855d1a92-cgu.0/�V@�@�@(�P ~@@p D��?@X00�-�%p�� @�H78�