!<arch>
#1/12 0 0 0 0 132 `
__.SYMDEF � 0 � ` __ZN9safe_math4math7try_div17hd2b157ab055a8be5E __ZN9safe_math4math7try_mul17hf9d1038c65403b8eE #1/12 0 0 0 644 8140 `
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� � � � � � � � � � � � � �
� � �
� �� �� ���� � �����
������
� �
�
�
� �
�
� �
left_value� � right_value� �
result_add� � �
� � � � � ��
� � � �
� � � �� �� � � �
�
�
� �
�
� � �
� �
result_sub� � �
� � � � � � � � a This Rust code snippet is defining a module named `math` and a submodule named `tests`. Here's a� d 2 breakdown of what each part of the code is doing:� e5 � �C b 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`� �b b overflows, it returns `Some(result_add)` with the overflowed value. Otherwise, it returns `None`.� �e � �
�
� � �� � �C c The function `try_sub` in Rust attempts to subtract two `u128` values and returns the result as an� �f J `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� �f E with `if left_value >= left_value` instead of `if result_sub >= left� �H � �
�
� � �
� � �C c The `try_mul` function in Rust attempts to multiply two `u128` values and returns the result as an� �f B `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� �f 2 `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� �Z e multiplication of `left_value` and `right_value` does not overflow and the division of the result by� �h A `left_value` equals `right_value`. Otherwise, it returns `None`.� �D � �
�
� � �
� � �"C a The `try_div` function in Rust attempts to perform division on two `u128` values and returns the� �d E 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� � f b successful and the result is correct, otherwise it returns `None` if the `right_value` is 0 or if� �!e " the division result is incorrect.� �!% �" �
�
� � �"
� �"�]lv�L��YY���b�]lv�L �z�pٷ�]lv�L��:�G����]lv�LP��R��6�]lv�L�ѥ�~���]lv�LR0��e�0��]lv�LX\m^��ά�]lv�L����
�yu �]���x Rw Q����n���V��� ��J���� ���� ���� ���� � � � � ���� ���� [" Z ![ ����u H
#1?M \ \ \ \ � � � �� �]lv�L�]?�',�����!�ODHT �� �]lv�L�ѥ�~�� �]lv�LX\m^��ά �]lv�LR0��e�0� �]lv�L����
� �]lv�L �z�pٷ �]lv�L��:�G��� �]lv�L��YY���b �]lv�LP��R��6 �V��R[[~�����1�V��R[[~�����1 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��Ğѽ�Ŋ��<*@�Y safe_math� -209d9664bd78dd5a��]lv�L �: � �( � e�
#1/68 0 0 0 644 1148 `
safe_math-209d9664bd78dd5a.safe_math.c4c9b761e6c5df9-cgu.0.rcgu.o ���� � 8 X � X __text __TEXT � � 0 � __compact_unwind__LD � @ � 8 __eh_frame __TEXT P � H h 2 X � � P �I ��� �� } �d@��I�i|���I���j| �)�
|C�(5�|� R�_� �� ���_�H � ��W���O��{��� �������� � �� ��� ��|ԛ �h � |�?� S����{B��OA��Wè�_� �� ���_� X X p zR x 8 ��������p L0L������|0L ������ � - x r � l 1 X a __ZN9safe_math4math7try_mul17hf9d1038c65403b8eE __ZN9safe_math4math7try_div17hd2b157ab055a8be5E ___udivti3 ltmp2 ltmp1 ltmp0