sm_dev 0.1.0

Math operations with safety checks that throw on error
Documentation
!<arch>
#1/12           0           0     0     0       244       `
__.SYMDEF p0p`p�p�__ZN9safe_math4math7try_add17hafde3ac4113e4d6fE__ZN9safe_math4math7try_div17h7cc7426f36308204E__ZN9safe_math4math7try_mul17hf7114b09a5f0d6b4E__ZN9safe_math4math7try_sub17h5a769628142721a5E#1/12           0           0     0     644     7420      `
lib.rmeta�����2
����.rmeta__DWARF����rust	�#rustc 1.76.0 (07dca489a 2024-02-04)����&���_$�
���!-4f192af08beaa759���� @����A�}}�-62a9b4d83244cb2b��r����#3JIb�''
@-4010f8e9d1f7f9aa�rustc_std_workspace_core�<�yR�g'f��_�]�-60d6843fd08e9533���d��Q}�•?|g[�-d56621fef414e9f8��҉��8�k����N5-0bfd536a501ea558��
�,����Ѫ�l�η�|A-7254491d238c3b3e�cfg_if�([�No��h'`3St���-9f474e4309122405�miniz_oxide�e�V9@L�����a0)�-06eec439eca0e252�adler��U�Iv~M����7�Qk-023007819562a373�	hashbrown���I/�Y��P��i?k-c5b1930e10569ddd�rustc_std_workspace_alloc���oV���_ِ:���-96bad2fc8f58f610�
std_detect���d���`�"R5A��-f39c850853dd7dfe�rustc_demangle�J�yk�wQ7>?-�]�-fa2288bf7728f91c�	addr2line��)�,S�O)R��%�X-a2e883cf5bcf6347�gimli�$�?�g')�����&�-df8440ef641907f8�object����_�O�����?�#-9e012890a70780c2�memchr�G�	�̇삭�-60338fe528589910�����vt'���FK��j-401344856f0fc3c5�tests�������������������math�try_add�try_sub�try_mul�try_div������	�a This Rust code snippet is defining a module named `math` and a submodule named `tests`. Here's a�d2 breakdown of what each part of the code is doing:�e5��Cb The function `try_add` in Rust attempts to add two `u128` values and returns `Some(result)` if an�e. overflow occurs, otherwise it returns `None`.�j1� Arguments:���a * `left_value`: The `left_value` parameter is a 128-bit unsigned integer (u128) representing the��d( left operand in the addition operation.��+a * `right_value`: The `right_value` parameter in the `try_add` function represents the value that��d- will be added to the `left_value` parameter.��0�	 Returns:���_ The function `try_add` returns an `Option<u128>`. If the sum of `left_value` and `right_value`��bb overflows, it returns `Some(result_add)` with the overflowed value. Otherwise, it returns `None`.��e������������
������
left_value��
right_value���Cc The function `try_sub` in Rust attempts to subtract two `u128` values and returns the result as an��fJ `Option<u128>`, or `None` if the subtraction would result in an overflow.��M�	��	�	e * `left_value`: The `left_value` parameter represents the value from which the `right_value` will be��	h& subtracted in the `try_sub` function.��
)[ * `right_value`: The `right_value` parameter is the value that will be subtracted from the��^2 `left_value` parameter in the `try_sub` function.��5����] The function `try_sub` returns an `Option<u128>`. If the subtraction operation `left_value -��`[ right_value` is successful (i.e., no overflow occurs), it returns `Some(result_sub)` where��
^c `result_sub` is the result of the subtraction. If an overflow occurs (which is incorrectly checked��fE with `if left_value >= left_value` instead of `if result_sub >= left��H������
���Cc The `try_mul` function in Rust attempts to multiply two `u128` values and returns the result as an��fB `Option<u128>`, returning `None` if the multiplication overflows.��E����a * `left_value`: The `left_value` parameter represents the first value to be multiplied. It is of��d< type `u128`, which means it is an unsigned 128-bit integer.��?c * `right_value`: The `right_value` parameter represents the second value to be multiplied with the��f2 `left_value` parameter in the `try_mul` function.��5����W The function `try_mul` returns an `Option<u128>`. It returns `Some(result_mut)` if the��Ze multiplication of `left_value` and `right_value` does not overflow and the division of the result by��hA `left_value` equals `right_value`. Otherwise, it returns `None`.��D������
���"Ca The `try_div` function in Rust attempts to perform division on two `u128` values and returns the��dE result as an `Option<u128>`, or `None` if the division is not exact.��H����b * `left_value`: The `left_value` parameter represents the dividend in a division operation. It is��e" the number that is being divided.��%c * `right_value`: The `right_value` parameter in the `try_div` function represents the divisor in a��f] division operation. It is the value by which the `left_value` (dividend) will be divided. If��`L `right_value` is equal to 0, the function will return `None` since division��O� �� � c The function `try_div` returns an `Option<u128>`. It returns `Some(result_mut)` if the division is�� fb successful and the result is correct, otherwise it returns `None` if the `right_value` is 0 or if��!e" the division result is incorrect.��!%�"�����"
��"�g�T�k@H�K���Q��g�T�k@�`%Z),��g�T�k@���"ֵ��g�T�k@|X�o�A)�g�T�k@�EVɥX�g�T�k@6������g�T�k@�z�j(����g�T�k@#B1�W�Grxt�\(	b
>wQvP�.
<m���U!	[
7��I�
�'�A
O�:
H�C
Q�/
=�/
=� 
�.�G
#UtG

#1?M�.�.�.�	�g�T�k@�]?�',�;+Q�ODHT ���g�T�k@���"ֵ��g�T�k@H�K���Q��g�T�k@6������g�T�k@#B1�W�Gr�g�T�k@�z�j(����g�T�k@�EVɥX�g�T�k@�`%Z),��g�T�k@|X�o�A)��udH��9_i������udH��9_i����V/Users/nguyenductrang/Desktop/Contract/RUST_BLOCKCHAIN_TUTORIAL/library-mod/src/lib.rs� �ԡ��
i��#�[��=_�+e6
ffS;h%=Oh=Ni<Ne%=N^��/^1�-���텰�[/Users/nguyenductrang/Desktop/Contract/RUST_BLOCKCHAIN_TUTORIAL/library-mod/src/math/mod.rs� �_d
AE|]�j�_g7��$ff6i0i5gjJ3A%
kRm.c:eckMJ3&%
kJiDk:_mIJ
34
iMj*keTkj*J
34
�a�(������u�K�}��aarch64-apple-darwin�������$p
���	safe_math�-be0f3eabc6afe72f��g�T�k@�4��#�q�






#1/52           0           0     0     644     7148      `
safe_math-be0f3eabc6afe72f.4zbmvndx2bg7ws9o.rcgu.o����� H���__text__TEXT���__const__TEXT�__const__DATA�`��__debug_loc__DWARF���__debug_abbrev__DWARF���
__debug_info__DWARFk�c�__debug_aranges__DWARFY
0Q�__debug_ranges__DWARF�
0�__debug_str__DWARF�
��__apple_names__DWARF��__apple_objc__DWARF�
$�__apple_namespac__DWARF�
��__apple_types__DWARFV�N__compact_unwind__LD���__eh_frame__TEXT��xh__debug_line__DWARF�82.@0p�P�����#��7�*7�?��'�?���#����_��{�������B���R��?��T�#� �R���_��{�������B�!�R��W���O��{����������������~��)|՛?�@��I��H����~�)$�
|՛S	�5�h7V|�����������T������������{B��OA��Wè�_����B�!�R��W���O��{����H�h�����������~��)|ԛ?��@��I��H����~�( �
|ԛH�)5��7������	|�?�S��������{B��OA��Wè�_����B�!�R�src/math/mod.rsattempt to add with overflowattempt to subtract with overflowattempt to multiply with overflow)Da0P�Q�04�Q�8DP�Q�DT�Q�XY�X�8R�S�XhR�S�hl�S�x�R�S����S�XpP�Q�pt�Q�x�P�Q����Q���P�Q���P�S��R�S� P�Q� $�Q�<HR�S�HT�S���R�S���R�d��e�d�$R�S�<Te�d��f�c�TxP�Q�x|P�c�|�e�c���P�Q����Q��e�c�TpR�S�ptR�f�t�d�f���R�S��d�f���P�Q���R�Q���R�S���P�Q���Q�%�9.@n:;I?�:;I4�:;IU2�	3

I�84
I�8
/I
I�82$>�9W��Xm�����n�����X@m��(�,�(���(���m( @���@�P�@��$��D�T�m_W\��\���\�'�`���� 	�
������ 
��� 
�����,�������clang LLVM (rustc version 1.76.0 (07dca489a 2024-02-04))src/lib.rs/@/4zbmvndx2bg7ws9o/Users/nguyenductrang/Desktop/Contract/RUST_BLOCKCHAIN_TUTORIAL/library-modsafe_mathmathtry_add_ZN9safe_math4math7try_add17hafde3ac4113e4d6fEtry_sub_ZN9safe_math4math7try_sub17h5a769628142721a5Etry_mul_ZN9safe_math4math7try_mul17hf7114b09a5f0d6b4Etry_div_ZN9safe_math4math7try_div17h7cc7426f36308204EcoreoptionOption<u128>u128NoneTSome__0left_valueright_valueresult_addresult_mutHSAH������]�����ljl���ݤ��-������� ��������_$ ����4(���W$�4HSAH����HSAH������6i^��N@�|π�|P`p��*�}�x�/HSAH��������(ڇ�ջ�|�y�|��|Xk~���������$XX@��T�zRx@���������D0L������
�0L������D<\���������D0L������
x0L������D�'�
src/mathmod.rs	
��yz�
tBz<t
������4�J�$���z�t
�����K�4���<���-�L�=�L�=|-P-HLD=@L<=-�-�L�=�L�=T-LLH=DL@=H	0			%��p5`@ `
`
4HL@D�������������� ���@m�fp6�����`�%Y
����Ta�1X�+__ZN9safe_math4math7try_add17hafde3ac4113e4d6fE__ZN9safe_math4math7try_sub17h5a769628142721a5E__ZN9safe_math4math7try_mul17hf7114b09a5f0d6b4E__ZN9safe_math4math7try_div17h7cc7426f36308204E__ZN4core9panicking5panic17h57fd475c037a9df3Eltmp5ltmp4l_anon.1952149df99552e3c7169c45986530a6.4ltmp3___udivti3l_anon.1952149df99552e3c7169c45986530a6.3ltmp2_str.2l_anon.1952149df99552e3c7169c45986530a6.2ltmp1_str.1l_anon.1952149df99552e3c7169c45986530a6.1ltmp0_str.0l_anon.1952149df99552e3c7169c45986530a6.0