📄 librand_core-2da007328faf5529.rmeta
/home/palash/git/iron_learn/target/debug/deps/librand_core-2da007328faf5529.rmeta
Language: rmeta • Lines: 2787
rust
�Q#rustc 1.92.0 (ded5c06cf 2025-12-08)��١�	�T�6a��D�
-5080178c80bf7a93���	ⷄ�ۆ��p��-225863f279df55c4��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�	getrandom��aH�%vi�yR��$-dffbd239522e2da5���/o]S��SAL�����-2d20780be38939e6��	U����%�kѿ��K-503f3915d2920600�Deserialize�\��<�serde�<���	Serialize�L��,�%#%�$�p�$�pG�$�/�$�.�$���$����BlockRngCore��Results�generate�CryptoBlockRng�R���
�
�reset�generate_and_set��
next_u32�next_u64� 	
fill_bytes�#�
#Seed�#	from_seed�#
seed_from_u64�#from_rng�(impl RngCore�#try_from_rng�*S�,�
.�
.�1�
1�
1�1�1�7�
7�7�7�<�
<�<�<�<�A�<�C�	E�
impls�GGnext_u64_via_u32�I�
Gfill_bytes_via_next�K�
KKKG
Observable�PBytes�Pto_le_bytes�GS�TS�GW�XW�Gfill_via_chunks�[�[	Gfill_via_u32_chunks�Gfill_via_u64_chunks�Gnext_u32_via_fill�`�
`Gnext_u64_via_fill�c�
c�	f
read_u32_into�f
read_u64_into�os�iiiim�iosource�iqraw_os_error�is�stry_next_u32�stry_next_u64�stry_fill_bytes�iRngCore�|�|�|���������	CryptoRng���
TryRngCore����������
unwrap_err��
unwrap_mut��read_adapter���
��������TryCryptoRng���
��
��������
�'r���
�re��'b���
��������
SeedableRng��������pcg32���MUL��INC���������
�from_os_rng��try_from_os_rng�RngReadAdapter��'a���
�inner�	��
�read��	
��
��BlockRng���
�results�����
��
��
BlockRng64���
�����	half_used�����
��iOsRng��
i��ii��i�>iOsError��
��i	��i
i��ii
��i��	UnwrapErr��
��
����
����
�>
��
����
��
����
��
����
����	UnwrapMut��
����
������
������
������
����
������
����888888888 8 8"8"8(8*808080848586898:8;8;8A8C8I8K8K8[8[8^8^8_8_8`8c8g8g8h8h8n8n8n8p8u8v8w8w8}8~888�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�8P|��������������P��IH��
�_�$|�$��$��$�������������-�L�$�_�$|�$��$��$PP�����L�Uf]ܔ���&�_�&��&�������i��i�����&�_�&���&��&�&��&�_�&��&��&��&|���'��$��$�_������D��Rq,�$��(��(��(��(���(��(�(�`�(|�(��(�_�������W� @gz���
��)���)��)�)�`�)|�������W� @gz�8�)��*��������80
8�)�_�*�����������.������������7������#�<�,�E������SW����������������������������m�o�s��x�����������_#|/��P�������_���	�`	���&�$!
��.2:`�&X�'�$
��$,5(�$
��$�$�$@�N�$Y�$c�.�.�.��.��$��$����.K
��.�/��.�T�)
�)d�)
�_�)8ķ).4�)	
�1T�)�$
�_��)C,�)
�\�	d
U��)d�*

�1d�*�.��*4�*
��.
�$9D�*ܙ*�*
�2��)�,�*�2��
@��*1<�*
�1\�*�.�2��)�,�*�2~TE��*��)�4�*
�\MD�*�*��(���������������������q�aXÅÅą��:����\�)�0,�(�^�^��^��[�^buf��[����e�S��)�\�\��\��[�\�
�[�\
has_fields��[��_��q|��7
�7��7X�7`�1��15�2)�01�1��2u�0}�.��3��0��1Q�2E�0M8���
�1��0�2��2��30
�n�3
�0�2�2��0�2��2��5fl�,
��,��,
��.$�-
l�-��-4�-�3$D�-��-l�-��-{
��$�.�.�.��,�.1��,�	�$\�,�$$�,�.`�$�.��8��0�.���?
results_empty����:��3N�91�$��.��$�T�0�.�0��07�.,�0�0,�0,d�2�.��24�2�3)D�2܈2��1(�.�2��1Q�6�1�$L�1�.U�8~�0� D�3��9�d�3�.��34�3�3)D�3��3��3#L�4	�$��4
�.��4%D�4
�$	D
5ܚ4��3,	
�S5�1$��4�.�4��3��6�3�?L�3�.,�3��.�8.�0K��6��$��.�S�W��3��9e�A�A�T�5�.d�5�.��54�5
��.
�%3D�5��5��5)č6��6
�$$�6�6�.��6d�6	�.��64�6�C	)D�6T�6
�.��6!
 	
3
|�6
�.�6�.)	
�.,�.T�.
�.�7��5���6[�%�5�?L�5��.��.��C��0�6��GJ�0g�.8�..5�.�n�,�6��CO
�n�%/�D�C�d�9�.��94�9�C)D�9܉9T�9�.<�9	�9�.$		'�.J	�.|�9|�9
�.�9�.)	
�.,�.T�.
�.D�:d�:�.��:4�:�C)
D�:��:&

_
�!�$�C�.�&�6�G�.�Zbd�:
ē;��;�D$�;�;�.��;D�;d�;�.��;4�;�C)	D�;��;"
�;�.&p�K{;Cd�<�.��<4�<�C)D�<<�<�<�.$	'�.J�.�<	
2��<)L�<
��&�%a'ĸ<��<�D$�<�<�.��<d�<!�.��<4�<�C!) D�<�="
�.��<# $"#	$#"2 "��<#L�<�OXL�=&�= �%'&)@�%9	'< �RX%Y �Rl�=
%��:��= ��7���7���8���9���;���<P(�&�7�?L�7�KD�7�.�9�G��0��.,�9*�.��G��G!�K��L��G��0�8�6�T��L��G��0��&�;�%��G{�0��.i�Gq�. '�6��&�<�%D�G��0��.x�.dk�&�%>read_u64�Ky
�K�	T�Gx��y����C/�H�C��K��DU�C��K��C��O��D��Ce�O�	L�8�8�.$	'�.J�.��8
� �.,�8z'��8
���C�������������	exhausted�m��/���.<�8�{�8
�.<�8
	
2
��8L�8�O
W	Ի8�8 �R�%)@�%9		< �RX	Y �R�8
�.<�8	2��8L�8�OW��8/
�8!��7���8m�&�7�T!�G<�7�.,�7�GL�X��.��G��&n�&��%��.�.���%���&��%%�.I�.5<����data�$�8��X1�X
�O3�OH
�>
�.��>�D�>$�>T�>��>T�>	�.d�>�.��>4�>�C)D�>��>
��>)	
��?�D$�?�?�.
��?d�?�.��?4�@
��.�C3D�@+T�@�.d�@
���.t�@
���C���������t������.�jVD�@T�@
���.d�@
�
�b$�@?+��?L|�?
[�%��?$��@	,d�?�.L�?�.��@�.	�.
4�.�.��@	*�.�A"��=���=���?��6�=�?L�=�c$�=�.d�>=�.o�.[�cu��.F�.�G/�0L�6��.Y�.P�.�.��GY�G��C��B��b��.��f	�b-�.B�G��G^�dest��read_len��consumed_u32�	filled_u8�o
�n�c��C1�H�D��a��b?�c��c���Bd�B
��$$�B$�BL�B
�$D"�B&��BT�$$�B�$�$�B�$�seed�?�i��i���C��C
��$$�C$��C!L�C�i@�C'��BU�$$�C�&$�C�$}�i4�j��iu��D\�D
��$��D+ܡDL�D�iF�D(��CW�$$�D�l�C�$�rng�:�k��iz��E|�E
��$��E+��E#�E
�W�$�m��$�i\L�E�i
t�E�E*��Dy��������������������q�aX�$�m��E�m�D��������������������q�aX�$�mM�ke��mk�m@��O�.�.&.`�O�.x�OX�P	�$�/	&/(�N
��$�N�NC�Q
�$\�$f�.�0�.��0����$��0����.a�05
� �/�.�d�R	

�1��Rd�R�1�R	1��R)4�S

�1T�S�$�2��RE,�S�2�
SD̉Sd�S


�1d�S�.��S4�S�3)D�S��S��S�2��R�,�S�2�
�@��S1<�S
�1\�S�.�2��R�,�S�2~TE��S\�T
	�1|�T�2��R�,�T�2|SD��T#��R�4�T�5GD�T�T0��R��5\�R�r,�R�6�R�7��7��7l�7�7��7��1��1s�2g�0o�1%�2��0��.��8�09�1��2��0��1^�2R�rZ�����1C�0�2�2��3��9v�0�2p�2V�0�2�2��r�2��2��5yl�V
��V��V�:$�W
l�W��W4�W�3$D�W�Wl�W��V�
��$,�W�X�X�X��V�.31��V�	�$l�V�$$�V�.g�$*�.��8
�0"�.���@�<���:��3O�92�$��.��$�T�Z�.�Z4��Z7�.,�Z�r,�Z,d�\�.��\4�\�3)D�\܉\��[(�.��\,�\�\5��[q�6�[�$L�[�.o�8��0� D�3��9�d�^�.��^4�^�3)D�^܋^��^#L�^	�$��^
�.��^%D�^�A	?
0ܻ^��],	�AV 5�1V $��^�.��^,�_�_6��]��6�]��L�]�.,�]�.�8E�0b��6��B�BP�T��3��9x�A$�AT�`�.t�`��`�.��`$	+�.,�`d�`�.��`4�`
��.
�&3
D�`��`	
��`$	L�a
�$��a�.��a%D�a�A
?0ܓat�a�.�a�.L�a�a�.��b,�b��`�t�b��b�.��b�b �.$	' �.J�.t�c��c t�c��c�.��c%�.	�.5�.�.d�c�.��c4�c�*D�c,�c��c		2��c'@�.#	
7��c.�%�d9��_���`���b��%�`��L�_�.L�`�.��.���G�.�.��.L���0��6�B@�B4�.,�b�.���G�;�.&�G
�&G�&�ь��0��.��.��~���shift��E�[
�n�&;�A��AT�d�.d�d�.��d4�d�*D�d��d��d)L�e�$��e	�.��e%D�e�A?	0ܗet�e�.�e�.��d�d�e�.��e4�e�*
D�eT�f�.��e!


 	
3
|�f�.�f�.)	�.,�.T�.�.��f,�f�f:��d���e{�&�d��L�d��.L�.
ь6�0S�6��B��B�ьu�0��.b�.X_�G&{�,�e�������AA���g
�.��g,�g��g�D�g$�gT�g��g
T�h	�.d�h�.��h4�h�*D�hܟh
��h)	
L�h�$��h�.��h%D�h�A?0
��ht�i�.�i�.��h�d�i�.��i4�i
��.�4D�i,T�j�.d�j
���.t�j
����b�>*D�jT�j
���.d�j�c$�j5	!��iL|�i
[�&��i$��j
,d�i�.L�i�.Ժj�.	�.4�.�.��j	*�."�k;��f���g���i��6�g��L�g�f$�g�.d�gM�.�.k�f���.S�.ь=�0Z�6��B�B��.e�.\�f�ь,ь����B��bm�.��f
�b.�.C�G��Gi��f��g�consumed_u64��g	e�h��4���A���]ߘ��c������ld�l�i$�l�lL�l
3�$>"�l?��lT�$$�l�i$�l�${�i4�i���z��m��m�j$�m��m!L�m��;�m@��lU�$$�m�&$�m�$x�i4�j���w��n\�n�k�nܛnL�n��;�nA��mW�$$�n�l�m�$x�k4�k���v��o|�o�m�o��o#�o
�W�$�m�$��JL�o��t�o�oC��ny��������������������q�aX�$�m��o�o�n�o��k��m���t�	D�	
}�$�	T�	̙	L�	�O@t�	D�	���	T�	��	L�	�O<L�	�	 �R�%)@�%9	< �RXY �Rl�	
�	I�����	]��	6	�&��B��&�	�%f�&�	�%)�&��%���kB�UF�U@�����O����O^$�
��
�$�
T�
|�
�
�.$$�

��
d�

�o�c
D�
�
�.	|�
�
	�f�
	�fD�
t�D�
~�$�T��\�
�Cl�4��f��|�
�p�c�A
��$�T�,���.$t�D�ժ�T��\���<	l�$�,��
���.,�
���c�.��������B�JT���.�x
d��!|�ƫ�\���,���.$t�D����
T��\�
˕?l�$�,� �!
���.,�
���c�.ݭ U!L8��!|�ƫ�\����K�����
���
���[�����c��c"�6�
�B��f$��fD�
V�.l�f��f��f��f�fA�fX̭,��&��6��f�̭��.��fwa̭,��&?�6\�f�f�Ʋ	ݭZ��,��%8�6~�f��f���ݭ�	�k!�f&left�/l�	r�chunk�n����������h���ժ;��ƫ��h�ժe��Eŭ�ƫ���7�����ƫ��
�.M+�.6=8��
�.N+�.6=8��
�.O+�.6=4��
�.U+�.6=4��
�.Y+�.6=8�̓��
��'����
�o�c$�$���T�$�
�o�'�4�$�l�4�
�JދދChunksExactMut��v��g��
�g�
chunk_size��g�_marker��gJ��K±�*�c�D��
d�4�
�J�g�gIter��h��g�h
end_or_len��g�h��gFPR<?���'
�	D����
�J��ȻX	���4�d��
�I����Zip���a��C��b��C����C���	�C��ڸ(jɼм�,���OD�
�J��]�'�f�'�6�64�V ����>
��H��		*�.�T�$�
�JȻ,
4�)	L�����$���t�
�k�c+��$�T�,�	��.$	
�	��	\�
R�')l�'	��	4�
��'Q�cXD��	
���.,�	
���cݭk>+��6	|�ƫ$��� ��1�	t�	!��.$		!'�.J	 !�.d�	#		#*	"#�.��	
 "���
&�	���[
���������������������������$�ft�
�'��f$��.$���D�Ȼ<���4�ɼDɼ^м�м��.T����6u�.D��G(����������������;t�����+мE����f$�����.��f���6��f�f[�������'�ݭO�.��G��.��G�src���f����f����zipped��
num_chunks��byte_len�w���fdz	�������չ~��J»�ü&�����_�����W�h$��������fƫ<����$��f������\���%l�#��4���FD���0|�ƫ$�C��+��A]On	�6���n��\��f#���f���	���'*�fX��T���F��ƫ�������4�,�,�c�.D�,�f��,T�,
�$�,A��,�-��,��,
ѕ' �-`��+���,Q�%�,�B�,��<�,�6��f��������k7�5:m�������,
�.b+�.6=4�4�.�.�c�.D�.�fĹ.T�.���.=��.�.��.��.
�' �.c��-���.Q�&�.�B�.̭<�.�6��f�̭�̭��k7�5:m�������.
�.e+�.6=8�L��L�l���.$	'�.J�.��t�D�
�o�%�T��	�#	�AV ,�1V 	$��d�
�o�c���.
|���'�
�J�h�hIterMut��h��g�h��g�h��g��Xt��,��%ԋԋChunksExact�׋���g؋�
�gًչ�g�
T~�F]�c_
ğ�3�'	
�H�����������C�����C����C���	�C��ڸ(j����W
��
�2�����
�J���	��	�
����%�f��,�����f��D�
��f��,�
T����4�
�W��������TryFromSliceError�����#���2D(e��D���-�������4�g������E�6��f��g���.��.^�.t�G��Gv������{������������������������;t����������-�f�%Q�����������������������q�aX����`��Wdst�_�	��������h
�H���p�AJ��'���������������PL��L�l���.$	'�.J�.��t�	D�	
�o�&�	T�	��#	�AV ,�1V 	$��	d�	���	�	�.
|�	��	'�	
�J�h�h���h��g�h��g�h��g��Xt��,��&���
�į	�6�	'	
�H�����������C�����C����C���	�C��ڸ(j�����
��
�5�	����
�J���	��	�
��	��&�f��,�	����f��	D�	
��f̭,�	
T�	�
��	4�	
�W̭��YD�	��	-��	��E��	4?h���W��	E�6��f����N�.��.��.�ь��G�/��S�����v��)��w����������������;t���������F����f��&S̭���������������������q�aX̭�� ��Y��^�	~�������hb��L����A������J�����������y��Q
��(
��&�&!+(�	�1
�_-2:��Q�5\��d�6k�1r{��������8��&(���"'�&3�&=FP(�
�1��}}~����z�Lɝn=I�2pu
�_��{�����5�����6��1��2������������2��"������).
�����DIQ��H�
����������6�CM�������6��%/4���l��
�_��1�4��n��b�5����,��6����� K���<�����"̯
���2$�p��q����������������;t������*��,��������4�����d�
*t��r��N����������������;t����R\��&$����x�����t�
6��!<�
�W�%���&
�G<���
���u��h��������������������q�aX�%�&���&L���������������������q�aX�%��9e���W��?��t�
7��!<�
�W�&���&��E<���
���v��h��������������������q�aX�&�&����L���������������������q�aX�&��5e���S��;��|�
4$� ��&<�
�W�6���&��L<���
���w����������������������q�aX�6�&����L��f$���������������������q�aX�6��En�fr���p��Q��1L�1
��'$�1\�1ܮ1D�1
}�'�LT�1�1���1I�%�1�'L�1ۂ�:���ւ���2L�2��$�2\�2܋2D�2
~ۂAT�2�2���1I�&�1��L�1���5�������2L�2��$�2\�2��2 T�3
ۂB�3|�3�3���2Z�6�2��L�2�f�2�6l���#��(S���ȅ�|�I
��I���Hi������D��Rq,��|�H��$�H\|�J
����J���IO�������W� @gz�����I��L�Ia��K
����L���J��������80
��ėK�L�K]|�OD�O��$�OT�O��O
���%ȩ1�FĿ�Xx�O���NZ��������������������q�aX�%���N�BL�N�%�����|�PD�Pժ$�PT�P��P
���&��P���OZ��������������������q�aX�&���O�BL�O�&��ժ���QT�Q��$�Q�Q|�Q�Q���P|��������������������q�aX�6���P�BL�P�f�P�6��� ����(�Y	�1(�Z�$ �2GL��Y^Nk�Y���5��(��6��1��2��0��0�����Α�2����(�Z
��$8�Y
��$�Y�-�(8�$_F��p(�Z�$�/&.(�Y
��$�Y�-�(8��@�$y�0�Wa�/��Y��Y�6��%/(�Z�$�$',
��$�$@EM�Z�H�Y
�����0��0�4�AK���(�Z�$
�`�$�2 �ZB�Z�"�6-��5��@�0~P�]g��4�[�$��[d�[
��$0t�[��[4�[
�W�%�$�ND�[�[���ZL�%�[�(L�[��������������������q�aX�%ۘ��Bl���Ҙ�4�\�$��\d�\
��$0t�\�\4�\
�W�&ۘHD�\�\���[L�&�[��L�[��������������������q�aX�&ۘ��B�k�ؚ����4�\�$��\t�\
��$0�]��\��\#4�]
�W�6ۘPD�]�]���\\�6�\��L�\�f�\��������������������q�aX�6ۘ��B	u��z������(�^	�1h�_�)#�2JO��\aQn�^���5��������W� @gz��)��6��1��2�ǟ���������2��*�^��^�6��%/h�_ǟǟ).
�ǟǟDIQ�^�H�^
����������6�CMۢ�h �_ǟ
�`ǟ�4  �^D �^�"�6-��5��@���Q�^h���4�bǟ��b
��)�c���bo����b��d�bǟ
94�dǟ��dd�d
��)/t�d�d4�d
�W�%�)�ND�d�d���cL�%�c��L�c��������������������q�aX�%���ǟcl�Ӧ���4�dǟ��dd�d
��)/t�d��d4�d
�W�&��HD�d�e���dL�&�d��L�d��������������������q�aX�&���ǟcl������4�eǟ��et�e
��)/�e��e��e#4�e
�W�6��PD�e�e���e\�6�e��L�e�f�e��������������������q�aX�6���ǟlu��z���٫�DÑ�Α�Α
����<$��l��4��
����c2D�����!�����J���.���L��H9��	
�Hɼ-$(�8��YA
PU
�Jɼ
g	pt		�	�,��	��fT���,�
�+
"$�����t����'������f�̒)|Ғƫ,̒A
�Ғ#��t��D��
�n�c.T��.
T���,���) $��L��\��
���.l�����6"�ӓ4|דƫӓ���ד0$�����|��
���?&�����‹�/?���F�������4���B���� ��$��&LӋ�����D��f7��Uɼ�ɼ�ɼ�����������������;t����f'ɼ3�f��6�f4׳=�������f������f�63�fc׳�������ݭ��.��f���C��Y�i��	_�	����
�.��������¯V��]�����sƫ2Dz�����hu��Pƫ/���������.�-�.8?4����-�L-�QX�&��%��&��'6364136223846793005������o�Tv��&���&��&��'11634580027462260723�D����������/$֟l֟4۟��)D۟�ǟT˟
�lǟL�˟$����|���9 �������/?�3���p��$���l���|�6�f2��M�����k=�i�������{��Y�����D����������/$��l��4����)D�����!t������I쨢�;��"

�!��N%)	5G$�
�Ӣ|Ӣ��
9		 <Ţi��������������������q�aX���s
�!��������������������q�aX�������w�
�Т
������	08�NV'������
�3���y�����"
���աǟš��#������|�������i���G��^i؊���6����f2��MU��^��������k��i��
���V �6W�����������h����v������թ�թ
��� $	�ϩE�����>Ī�>�"]
"��>��	
�^��R	&�����٪r
����K����^JQ��(	�
����1�.���
�^�.�.
m!*�$�@]�$�]
�S�%�"](�����t�����1��
��$����������������������q�aX����h<����0�����	Arguments���pieces��[����[����[k�ĉ���� ��x������.���}���������res�err��������|��������z
�1�
�1���`�������D��
�ɮ
�ɮ��/$��l��4����)D����|���@ �?�

�!��B%)	5G$��
	���|����	9	 @��i��������������������q�aX���s
�!�����%Ư
<��
������0
8ǯN
V'������

�3����OV��
���6��������������|�������i���G��^i؊���6t����f������������f��in�
>��V �6��GX�����X��6�������%����Tδ
ǟ�δtٴ��
-��ٴ�δ�<��
�W�6�������
�"�f+�c��)�R�����6�V �����n���w�Aδ�
�!��������������������q�aX�6���vz	���	L�	l�
���.����B�i��������������������q�aX���Us
�!��������������������q�aX�.�������������δ���즴�������80
�)L���f��������|�������i���G��^i؊���6���H��������.+�fCǟ���5��
%�"V �6I��������A�h���N	̝�
�H(Dҵ�D�(
(Dѵ
��
�^��
3
<R	
��
�ŵ��)<closure_kind>�<closure_signature>�<upvars>����	����y���'�=�'�
�*�)�(*�'�q�'�
��F�F��F��1"`��x9�'�UW���P���
�����.��q����������������H*�H�HNotFound��H�HPermissionDenied��H�HConnectionRefused��H�HConnectionReset��H�HHostUnreachable��H�HNetworkUnreachable��H�HConnectionAborted��H�HNotConnected��H�H	AddrInUse��H�HAddrNotAvailable�	�H�HNetworkDown�
�H�H
BrokenPipe��H�H
AlreadyExists��H�H
WouldBlock�
�H�H
NotADirectory��H�HIsADirectory��H�HDirectoryNotEmpty��H�HReadOnlyFilesystem��H�HFilesystemLoop��H�HStaleNetworkFileHandle��H�HInvalidInput��H�HInvalidData��H�HTimedOut��H�H	WriteZero��H�HStorageFull��H�HNotSeekable��H�H
QuotaExceeded��H�HFileTooLarge��H�HResourceBusy��H�HExecutableFileBusy��H�HDeadlock��H�HCrossesDevices��H�HTooManyLinks� �H�HInvalidFilename�!�H�HArgumentListTooLong�"�H�HInterrupted�#�H�HUnsupported�$�H�H
UnexpectedEof�%�H�HOutOfMemory�&�H�H
InProgress�'�H�IOther�(�I�I
Uncategorized�)8C�v��R������������4��-��$�����H��Q��B�k�w	��y�����������+�����_
�1l�1w����������lǷ�1츷d���1��5ܺ�-���&4ַ�5SDַ����y�5�����,��6���7��7��1�+�._�1��5���
��%�&0��8?M
�c�p�&{������Z#
��$�)�(4�$;BP
��$i�v�(��$����^0
��)�+��7ǟ?FT
��)o�|���ǟ��Gfi|���������������[DerefMut�D���<��z�,�
�{��{������#  Random number generation traits�����LI This crate is mainly of interest to crates publishing implementations of���MJ [`RngCore`]. Other users are encouraged to use the [`rand`] crate instead���52 which re-exports the main traits and error types.�����QN [`RngCore`] is the core trait implemented by algorithmic pseudo-random number���2/ generators and external random-number sources.�����OL [`SeedableRng`] is an extension trait for construction from fixed seeds and���#  other random number generators.�����PM The [`impls`] and [`le`] sub-modules include a few small functions to assist���" implementation of [`RngCore`].�����" [`rand`]: https://docs.rs/rand�����
8�l��79https://www.rust-lang.org/logos/rust-logo-128x128-blk.png���;$�	8���	�	7%https://www.rust-lang.org/favicon.ico���	'$�	8�l�	�	7#https://rust-random.github.io/rand/���	%�����
�
�8�$�
�
�8�$�
�
�
8�,�
�
�
8unused_variables���
$�
8�$�
�
�
8warnings�D�
��
<Gfi|����������r�s�r�[��j��i�z�h�{�x�{����������l��l���74 The `BlockRngCore` trait and implementation helpers�����MJ The [`BlockRngCore`] trait exists to assist in the implementation of RNGs���LI which generate a block of data in a cache instead of returning generated��� values directly.�����A> Usage of this trait is optional, but provides two advantages:���JG implementations only need to concern themselves with generation of the���PM block, not the various [`RngCore`] methods (especially [`fill_bytes`], where���A> the optimal implementations are not trivial), and this allows���NK `ReseedingRng` (see [`rand`](https://docs.rs/rand) crate) perform periodic���%" reseeding with very low overhead.���l�
 # Example���l�
 ```no_run���*' use rand_core::{RngCore, SeedableRng};���30 use rand_core::block::{BlockRngCore, BlockRng};����� struct MyRngCore;��	���	%" impl BlockRngCore for MyRngCore {�İ	     type Item = u32;���	!     type Results = [u32; 16];��	���	=:     fn generate(&mut self, results: &mut Self::Results) {��
         unimplemented!()�L�
     }�,�
 }��
���
$! impl SeedableRng for MyRngCore {��     type Seed = [u8; 32];���0-     fn from_seed(seed: Self::Seed) -> Self {���ŒL��,�������>; // optionally, also implement CryptoBlockRng for MyRngCore����� // Final RNG.���:7 let mut rng = BlockRng::<MyRngCore>::seed_from_u64(0);���
0- println!("First value: {}", rng.next_u32());�<�
 ```��
���
0- [`BlockRngCore`]: crate::block::BlockRngCore���'$ [`fill_bytes`]: RngCore::fill_bytes�,����|�[�L��
�<�|�\���T��
���[�q��4fhWYIK:<L�/����NK A trait for RNGs which do not generate random numbers individually, but in���EB blocks (typically `[u32; N]`). This technique is commonly used by���.+ cryptographic RNGs to improve performance.�����=: See the [module][crate::block] documentation for details.�d����������������T�ʖ������B��
Җ����������<��B��2��$��L���%" Results element type, e.g. `u32`.�$���A��HE Results type. This is the 'block' an RNG implementing `BlockRngCore`���?< generates, which will usually be an array like `[u32; 16]`.�<���4��$! Generate a new block of results.�D���������6�
��$��<���&��IF A marker trait used to indicate that an [`RngCore`] implementation is���,) supposed to be cryptographically secure.�����0- See [`CryptoRng`] docs for more information.�t�����)��d���'ל��3ל)��(=�
���$�(�$d�(�_�$T�(�$�_-/��(6�(�����$��^�^��^��[�^�5�[����e�S���5�(
�$$�(���*!�
���+��d�+�$��,"��+=: Create a new `BlockRng` from an existing RNG implementing���+;8 `BlockRngCore`. Results will be generated on first use.��,�$�$�i���0��.)& Get the index into the result buffer.��.���.IF If this is equal to or larger than the size of the result buffer then���/HE the buffer is "empty" and `generate()` must be called to produce new�d�/	 results.�,�0���$�.�0
�$$�0��1��0*' Reset the number of available results.���1EB This will force a new set of results to be generated on next use.�,�1���$�6�1
�$$�1��30��2GD Generate a new set of results immediately, setting the index to the���2
 given value.���3���$�.�6�3�D$�3�� ��49�
�$�%T�4����4���4�$ "}~" !�5D�5���$�%�5
�$$�5�7D�7���$�&�7
 �$$�7��7 ��!��!��!! !�$�K���C�.�&�6��=)T�=����$��c�6�=
"�$$�=�f�2��A?�
$$���A��d�A��$\�A�$%&'(*�����*(&'HJL�A$�A##�i��B&L�B�$��$##
&�$�i�4��B#l�B�&�$##
'�$�i75��C+D�C���l�$#�))�C#���ld�D|�l<�D
(�$�l�k�5#%��DEd�D���m�n#�++�E#���m�D��mT�D
*�$�m�k7$&��EL�
--��T�F�$t�E����E���E�$	��Q?�
//���Q��d�QȝT�Q�$0�_0 "��R6�R�����$��^�^��^��[�^�5�[����e�S���5.�R.
0�$$�R��;��T#�
22���T��d�T�$3456��V$��U=���U;���V�$�$11���:>�Z��X)���X���XI���YH¡d�Y��,�Z���$�.1�Z1
4�$$�Z��[��Z*����[E��,�[���$�61�[1
5�$$�[��]0��\Gˤ��]����]���$�.�61�]1
6�$$�]�@A��_;�
88�$�&T�_��ĥ_���_�$9:;}~9:;!��_D�_���$�%7�_7
9�$$�_�dD�d���$�&7�d7
:�$$�d��f)T�f����$��c�67�g7
;�$$�g�fuM��kA�
==���k��d�k��\�k�$>?@AC�����@A?CACL�k$�k<<�i��l&L�l�$��$<<
?�$�i]O��l#l�l�&�$<<
@�$�iP��m+D�m���l�$<�BB�m<��d�mέ<�n
A�$�l�k�P��nEd�n���m�<�DD�n<̮�nܮT�n
C�$�m�k�Q��oN�
FF��T�o��t�o����o���o�$	l���:7 Helper functions for implementing `RngCore` functions.�����NK For cross-platform reproducibility, these functions all use Little Endian:���MJ least-significant part first. For example, `next_u64_via_u32` takes `u32`���HE values `x, y`, then outputs `(y << 32) | x`. To implement `next_u32`���OL from `next_u64` in little-endian order, one should use `next_u64() as u32`.�����LI Byte-swapping (like the std `to_le` functions) is only needed to convert���EB to/from byte sequences, and since its purpose is reproducibility,���DA non-reproducible sources (e.g. `OsRng`) need not bother with it.�,�IKP[^_`c�<�|GHt���@��=: Implement `next_u64` via `next_u32`, little-endian order.������$�&�
JJ����$�|�$<�
I�$�kSS "��M��	NK Implement `fill_bytes` via `next_u64` and `next_u32`, little-endian order.��
���
OL The fastest way to fill a slice is usually to work as long as possible with���KH integers. That is why this method mostly uses `next_u64`, and only when���GD there are 4 or less bytes remaining at the end of the slice it uses��� `next_u32` once.�������$��c�6�
LL������<�
K�$�kQX�fZX!#ZZ�.�Z�.�Z�.��!T�PP����s���$�P��(����4��)QRQR����Q,�����c\�����R��,�PP��$\�����PP
R��$����%TVQRVT�,�SS��M[�.��#\��%�%QSS
V$����&XZQRZT�,�WW̭�[�.��#\��&�&QWW
Z$���Z|��������c�f�\\����'�P�'T�
[�'���b�f�b(*l�[��]��]��]][����$N��NK Implement `fill_bytes` by reading chunks from the output buffer of a block�t� based RNG.�����63 The return values are `(consumed_u32, filled_u8)`.�����IF `src` is not modified; it is taken as a `&mut` reference for backward���<9 compatibility with previous versions that did change it.�����OL `filled_u8` is the number of filled bytes in `dest`, which may be less than��� the length of `dest`.���PM `consumed_u32` is the number of words consumed from `src`, which is the same���" as `filled_u8 / 4` rounded up.���l�����  (from `IsaacRng`)�� �l� 
 ```ignore��� /, fn fill_bytes(&mut self, dest: &mut [u8]) {���      let mut read_len = 0;��� %"     while read_len < dest.len() {���!-*         if self.index >= self.rsl.len() {���!             self.isaac();�l�!
         }��!���"+(         let (consumed_u32, filled_u8) =���"GD             impls::fill_via_u32_chunks(&mut self.rsl[self.index..],���"B?                                        &mut dest[read_len..]);��#���#'$         self.index += consumed_u32;���#"         read_len += filled_u8;�L�$�,�$��<�$��0.9.3�use BlockRng instead���$=��$��������C��c�f�$
^���$�f$�%��*N��%N��t�&���&���&63 The return values are `(consumed_u64, filled_u8)`.��&���&I����'<���'���'O����(����(PM `consumed_u64` is the number of words consumed from `src`, which is the same���)" as `filled_u8 / 8` rounded up.��)���)-* See `fill_via_u32_chunks` for an example.���use BlockRng64 instead���*?��*����������c�f�*
_���*�f$�*��+A��+?< Implement `next_u32` via `fill_bytes`, little-endian order.���,���$�%�
aa�,���,��<�,
`�$�k�gh``�.��-A��-?< Implement `next_u64` via `fill_bytes`, little-endian order.���-���$�&�
dd�.���-��<�-
c�$�k4i�icc�.T��� Little-Endian utilities�����KH Little-Endian order has been chosen for internal usage; this makes some��� useful functions available.��gh��1��96 Reads unsigned 32 bit integers from `src` into `dst`.���d�	 # Panics�����@= If `dst` has insufficient space (`4*dst.len() < src.len()`).�P|�l������c��C�6�
g��Tn��]n��1��96 Reads unsigned 64 bit integers from `src` into `dst`.���d�������@= If `dst` has insufficient space (`8*dst.len() < src.len()`).�P|�l������c���6�
h��t��t4�������d��ik�T��il��!(*��#�&n�_n��D������&��^�^��^��[�^�5�[����e�S���5m�m
n$���y��"�&p�p��>4����&����������������;t�����o�o
p$�d��&r��(��B? Extract the raw OS error code (if this error came from the OS)�����MJ This method is identical to [`std::io::Error::raw_os_error()`][1], except���JG that it works in `no_std` contexts. If this method returns `None`, the���HE error value can still be formatted via the `Display` implementation.�����OL [1]: https://doc.rust-lang.org/std/io/struct.Error.html#method.raw_os_error�d��&��qq
r�z���&tuvw����uwvT�,�ss�&��6d����&��������������������q�aX�%�&�s�s
u$���6d����&��������������������q�aX�&��s�s
v$���Ht�����&��c��������������������q�aX�6��s�s
w$��f7yܫ�&��a=d=V=Y=��'��
+( Implementation-level interface for RNGs��
���
EB This trait encapsulates the low-level functionality common to all���GD generators, and is the "back end", to be implemented by generators.���96 End users should normally use the [`rand::Rng`] trait���MJ which is automatically implemented for every type implementing `RngCore`.�����MJ Three different methods for generating random data are provided since the���OL optimal implementation of each is dependent on the type of generator. There���EB is no required relationship between the output of each; e.g. many���NK implementations of [`fill_bytes`] consume a whole number of `u32` or `u64`���LI values and drop any remaining unused bytes. The same can happen with the���KH [`next_u32`] and [`next_u64`] methods, implementations may discard some��� random bits for efficiency.�����NK Implementers should produce bits uniformly. Pathological RNGs (e.g. always���PM returning the same value, or never setting certain bits) can break rejection���IF sampling used by random distributions, and also break other RNGs when���/, seeding them via [`SeedableRng::from_rng`].�����LI Algorithmic generators implementing [`SeedableRng`] should normally have���OL *portable, reproducible* output, i.e. fix Endianness when converting values���LI to avoid platform differences, and avoid making any changes which affect���KH output (except by communicating that the release has breaking changes).�����EB Typically an RNG will implement only one of the methods available���B? in this trait directly, then use the helper functions from the���41 [`impls`] module to implement the other methods.�����FC Note that implementors of [`RngCore`] also automatically implement���C@ the [`TryRngCore`] trait with the `Error` associated type being��� equal to [`Infallible`].�����:7 It is recommended that implementations also implement:�����NK - `Debug` with a custom implementation which *does not* print any internal���KH   state (at least, [`CryptoRng`]s should not risk leaking state through�|�   `Debug`).���IF - `Serialize` and `Deserialize` (from Serde), preferably making Serde���74   support optional at the crate level in PRNG libs.��� - `Clone`, if possible.���MJ - *never* implement `Copy` (accidental copies may cause repeated values).���KH - *do not* implement `Default` for pseudorandom generators, but instead���GD   implement [`SeedableRng`], to guide users towards proper seeding.���A>   External / hardware RNGs can choose to implement `Default`.��� MJ - `Eq` and `PartialEq` could be implemented, but are probably not useful.��!�l�!���!���!DA A simple example, obviously not generating very *random* output:��!�<�!����! #![allow(dead_code)]���"$! use rand_core::{RngCore, impls};��"��" struct CountingRng(u64);��"���"" impl RngCore for CountingRng {���"'$     fn next_u32(&mut self) -> u32 {���#"         self.next_u64() as u32�L�#��#���#'$     fn next_u64(&mut self) -> u64 {���#         self.0 += 1;���$         self.0�L�$��$���$2/     fn fill_bytes(&mut self, dst: &mut [u8]) {���$1.         impls::fill_bytes_via_next(self, dst)�L�%�,�%��<�%���%���%B? [`rand::Rng`]: https://docs.rs/rand/latest/rand/trait.Rng.html���%'����&#  [`next_u32`]: RngCore::next_u32���&#  [`next_u64`]: RngCore::next_u64���&-* [`Infallible`]: core::convert::Infallible�<�'||����'�	|����}~}~}~��)��'! Return the next random `u32`.��'���'HE RNGs must implement at least one method from this trait directly. In���(KH the case this method is not implemented directly, it can be implemented���(GD using `self.next_u64() as u32` or via [`impls::next_u32_via_fill`].�D�)�����%|�)|
}��$�)��+��)! Return the next random `u64`.��*���*H����*Kے��+HE via [`impls::next_u64_via_u32`] or via [`impls::next_u64_via_fill`].�D�,�����&|�,|
~��$�,��0)��,! Fill `dest` with random data.��,���,H����-Kے��-'$ via [`impls::fill_bytes_via_next`].��.���.?< This method should guarantee that `dest` is entirely filled���.63 with new data, and may panic if this is impossible���/B? (e.g. reading past the end of a file that is being used as the���/ source of randomness).�T�0�������c�6|�0|
��$�0���0��0=������0��'D�0|ۂ<�0�'���}~���CE�1D�1���'�%��1�
��'$�1��1D�1���'�&��1�
��'$�1��2(T�2����'��c�6��2�
��'$�2�����?��3C@ A marker trait over [`RngCore`] for securely unpredictable RNGs��3���3LI This marker trait indicates that the implementing generator is intended,���4KH when correctly seeded and protected from side-channel attacks such as a���4OL leaking of state, to be a cryptographically secure generator. This trait is���5KH provided as a tool to aid review of cryptographic code, but does not by���6@= itself guarantee suitability for cryptographic applications.��6���6LI Implementors of `CryptoRng` automatically implement the [`TryCryptoRng`]�T�7 trait.��7���7HE Implementors of `CryptoRng` should only implement [`Default`] if the���8NK `default()` instances are themselves secure generators: for example if the���8OL implementing type is a stateless interface over a secure external generator���9NK (like [`OsRng`]) or if the `default()` instance uses a strong, fresh seed.��9���9PM Formally, a CSPRNG (Cryptographically Secure Pseudo-Random Number Generator)���:NK should satisfy an additional property over other generators: assuming that���;KH the generator has been appropriately seeded and has unknown state, then���;52 given the first *k* bits of an algorithm's output���<KH sequence, it should not be possible using polynomial-time algorithms to���<IF predict the next bit with probability significantly greater than 50%.��=���=OL An optional property of CSPRNGs is backtracking resistance: if the CSPRNG's���>MJ state is revealed, it will not be computationally-feasible to reconstruct���>FC prior output values. This property is not required by `CryptoRng`.�L�?������?|��<�?���(����4��*��?<������?ʛD�?�ۂL�?�'!��D��?1. A potentially fallible variant of [`RngCore`]��@���@IF This trait is a generalization of [`RngCore`] to support potentially-���@30 fallible IO-based generators such as [`OsRng`].��A���ANK All implementations of [`RngCore`] automatically support this `TryRngCore`���BLI trait, using [`Infallible`][core::convert::Infallible] as the associated���B `Error` type.��B���BNK An implementation of this trait may be made compatible with code requiring���CMJ an [`RngCore`] through [`TryRngCore::unwrap_err`]. The resulting RNG will���D>; panic in case the underlying fallible RNG yields an error.�T�D������D������ ���������������������E&�_��T�E�_��d�E��)��ϳ��������E%��D2/ The type returned in the event of a RNG error.�,�E����E7��E!Ցd�E������������������������q�aX�%����E�
���$�E��F7��F!Ҕd�F������������������������q�aX�&����F�
���$�F��GH��G*' Fill `dest` entirely with random data.�t�G�������c��������������������q�aX�6����G�
���$�G���G��HE��G,) Wrap RNG with the [`UnwrapErr`] wrapper.�T�H����������,�H
���]���I/��I,) Wrap RNG with the [`UnwrapMut`] wrapper.�T�I�����������W� @gz������I�
���$�I��JU��J30 Convert an [`RngCore`] to a [`RngReadAdapter`].�d�J�����������80
�����K���,�K
���$�K��M*�
�����M��<�M�$�����������79T�N,�N�����N6d�N���$����N�
��$$�N��O6d�O���$��O�
��$$�O��PGt�P����$��c����P�
��$$�P��_���X"��QFC A marker trait over [`TryRngCore`] for securely unpredictable RNGs��Q���RFC This trait is like [`CryptoRng`] but for the trait [`TryRngCore`].��R���RL����SK���SO����TK����U@��U���UKH Implementors of `TryCryptoRng` should only implement [`Default`] if the���VN����VOӣ��WN��d�X������X%���T�X���)����5��*��X.�
�����X��$L�X�$��Z,�
�����Z��$T�Z�(���}~���46��ZD�Z���(�%��[�
��$$�[��[D�[���(�&��[�
��$$�[��\(T�\����(��c�6��\�
��$$�\������]0�
�����]��$d�]�(��_1���
������)�_��)T�_�)��_!��bI��_  Reborrow with a new lifetime��`���`KH Rust allows references like `&T` or `&mut T` to be "reborrowed" through���`PM coercion: essentially, the pointer is copied under a new, shorter, lifetime.���aIF Until rfcs#1403 lands, reborrows on user types require a method call.��b��)�������W� @gz���)��������b
���)�$�b�b��c98��
������c��T�c�*���}~���-/��cD�c���*�%��c�
�8�)$�c�dD�d���*�&��d�
�8�)$�d��e(T�e����*��c�6��e�
�8�)$�e�����e=8��
������e��)d�f�*��k��f<9 A random number generator that can be explicitly seeded.��f���fE����gGD pseudo-random number generators (PRNGs, or algorithmic generators).��h���hMJ A generator implementing `SeedableRng` will usually be deterministic, but���hNK beware that portability and reproducibility of results **is not implied**.���iOL Refer to documentation of the generator, noting that generators named after���iIF a specific algorithm are usually tested for reproducibility against a���jKH reference vector, while `SmallRng` and `StdRng` specifically opt out of���k reproducibility guarantees.��k���k"��\�k����,�k�������������������������x7���,�x���<�x����c\�x����c\�x��O��D��:��-�� ��������x6��kKH Seed type, which is restricted to types mutably-dereferenceable as `u8`���l1. arrays (we recommend `[u8; N]` for some `N`).��m���mKH It is recommended to seed PRNGs with a seed of at least circa 100 bits,���mLI which means an array of `[u8; 12]` or greater to avoid picking RNGs with���n" partially overlapping periods.��n���nJG For cryptographic RNG's a seed of 256 bits is recommended, `[u8; 32]`.��o��o���o:7 # Implementing `SeedableRng` for RNGs with large seeds��o���oLI Note that [`Default`] is not implemented for large arrays `[u8; N]` with���pJG `N` > 32. To be able to implement the traits required by `SeedableRng`���qDA for RNGs with such large seeds, the newtype pattern can be used:��q�<�q����q use rand_core::SeedableRng;��r�Ĩr const N: usize = 64;���r #[derive(Clone)]���r&# pub struct MyRngSeed(pub [u8; N]);�̉s # #[allow(dead_code)]���s  pub struct MyRng(MyRngSeed);��s���s  impl Default for MyRngSeed {���s#      fn default() -> MyRngSeed {��t         MyRngSeed([0; N])�L�t�,�t���t���t$! impl AsRef<[u8]> for MyRngSeed {���u#      fn as_ref(&self) -> &[u8] {���u         &self.0�L�u�,�u���u���u$! impl AsMut<[u8]> for MyRngSeed {���v+(     fn as_mut(&mut self) -> &mut [u8] {���v         &mut self.0�L�v�,�v���v���w  impl SeedableRng for MyRng {���w     type Seed = MyRngSeed;��w���w0-     fn from_seed(seed: MyRngSeed) -> MyRng {���x         MyRng(seed)�L�x�,�x��<�x��$�x�����'��y+( Create a new PRNG using the given seed.��y���yHE PRNG implementations are allowed to assume that bits in the seed are���zHE well distributed. That means usually that the number of one and zero���zMJ bits are roughly equal, and values like 0, 1 and (size - 1) are unlikely.���{HE Note that many non-cryptographic PRNGs will show poor quality output���{KH if this is not adhered to. If you wish to seed from simple numbers, use���| `seed_from_u64` instead.��|���|KH All PRNG implementations should be reproducible unless otherwise noted:���}HE given a fixed `seed`, the same sequence of output should be produced���~LI on all runs, library versions and architectures (e.g. check endianness).���~KH Any "value-breaking" changes to the generator should require bumping at���<9 least the minor version and documentation of the change.�����C@ It is not required that this function yield the same state as a����LI reference implementation of the PRNG given equivalent seed; if necessary����>; another constructor replicating behaviour from a reference��Ё  implementation can be added.�������JG PRNG implementations should make sure `from_seed` never panics. In the��̂HE case that some special values (like an all zero seed) are not viable����IF seeds it is preferable to map these to alternative constant value(s),���KH for example `0xBAD5EEDu32` or `0x0DDB1A5E5BAD5EEDu64` ("odd biases? bad����LI seed"). This is assuming only a small number of values must be rejected.�L�����������i$���‹(���)& Create a new PRNG using a `u64` seed.�����JG This is a convenience-wrapper around `from_seed` to allow construction����LI of any `SeedableRng` from a simple `u64` value. It is designed such that����HE low Hamming Weight numbers like 0 and 1 can be used and should still��؇DA result in good, independent seeds to the PRNG which is returned.�������LI This **is not suitable for cryptography**, as should be clear given that����#  the input size is only 64 bits.�������HE Implementations for PRNGs *may* provide their own implementations of����KH this function, but the default implementation should be good enough for��NJJG all purposes. *Changing* the implementation of this function should be����'$ considered a value-breaking change.�lŋ�&����
����,׋���$,�����&��Ό���,nj��.t����&t�����&��+���63 Create a new PRNG seeded from an infallible `Rng`.�������LI This may be useful when needing to rapidly seed many PRNGs from a master��ѕLI PRNG, and to allow forking of PRNGs. It may be considered deterministic.�������JG The master PRNG should be at least as high quality as the child PRNGs.����DA When seeding non-cryptographic child PRNGs, we recommend using a��—GD different algorithm for the master PRNG (ideally a CSPRNG) to avoid����GD correlations between the child PRNGs. If this is not possible (e.g.��ژJG forking using small non-crypto PRNGs) ensure that your PRNG has a good����IF mixing function on the output or consider use of a hash function with����
 `from_seed`.�������JG Note that seeding `XorShiftRng` from another `XorShiftRng` provides an���FC extreme example of what can go wrong: the new PRNG will be a clone���� of the parent.�ś��͛JG PRNG implementations are allowed to assume that a good RNG is provided����JG for seeding, and that it is cryptographically secure when appropriate.���GD As of `rand` 0.7 / `rand_core` 0.5, implementations overriding this����EB method should ensure the implementation satisfies reproducibility����.+ (in prior versions this was not required).�������"��D����l�����������d��έ<��
����l�k�!#���E���?< Create a new PRNG seeded from a potentially fallible `Rng`.�Ӡ��۠FC See [`from_rng`][SeedableRng::from_rng] docs for more information.�d�����)����
��ʡ����)����T��
����)�kx�!#Ĭ����?< Creates a new instance of the RNG seeded via [`getrandom`].�������KH This method is the recommended way to construct non-deterministic PRNGs����&# since it is convenient and secure.�����ĤQN Note that this method may panic on (extremely unlikely) [`getrandom`] errors.����FC If it's not desirable, use the [`try_from_os_rng`] method instead.������JG In case the overhead of using [`getrandom`] to seed *many* PRNGs is an����96 issue, one may prefer to seed from a local PRNG, e.g.����%" `from_rng(rand::rng()).unwrap()`.����d��������ŧPM If [`getrandom`] is unable to provide secure entropy this method will panic.�������,) [`getrandom`]: https://docs.rs/getrandom��Ө52 [`try_from_os_rng`]: SeedableRng::try_from_os_rng�\������
������6�ߪQN Creates a new instance of the RNG seeded via [`getrandom`] without unwrapping����#  potential [`getrandom`] errors.�ݫ���JЌ���9����*' `from_rng(&mut rand::rng()).unwrap()`.�������,��|�����������5�˯ZW Adapter that enables reading through a [`io::Read`](std::io::Read) from a [`RngCore`].����t�� # Examples����l��‰�˰ # use std::{io, io::Read};��� # use std::fs::File;����)& # use rand_core::{OsRng, TryRngCore};�������li io::copy(&mut OsRng.read_adapter().take(100), &mut File::create("/tmp/random.bytes").unwrap()).unwrap();�<����tɲ���
�����ܲ��T߲�)�����������80
��)��80
�زnpc,������)���D8��
���������T���*������C$������*��c������
�8�)$���5e�,�������������������F8��
���������T���*��_���B������*��^�^��^��[�^�5�[����e�S���5���
�8�)$��ǔ��&$��FC A wrapper type implementing [`RngCore`] for some type implementing���PM [`BlockRngCore`] with `u32` array buffer; i.e. this can be used to implement���/, a full RNG from just a `generate` function.�����MJ The `core` field may be accessed directly but the results buffer may not.���41 PRNG implementations can simply use a type alias���GD (`pub type MyRng = BlockRng<MyRngCore>;`) but might prefer to use a���LI wrapper type (`pub struct MyRng(BlockRng<MyRngCore>);`); the latter must���JG re-implement `RngCore` but hides the implementation details and allows���0- extra functionality to be defined on the RNG���41 (e.g. `impl MyRng { fn set_stream(...){...} }`).�����OL `BlockRng` has heavily optimized implementations of the [`RngCore`] methods���63 reading values from the results buffer, as well as���HE calling [`BlockRngCore::generate`] directly on the output array when���HE [`fill_bytes`] is called on a large array. These methods also handle���>; the bookkeeping of when to generate a new batch of values.�����OL No whole generated `u32` values are thrown away and all values are consumed���GD in-order. [`next_u32`] simply takes the next available `u32` value.���DA [`next_u64`] is implemented by combining two `u32` values, least��� MJ significant first. [`fill_bytes`] consume a whole number of `u32` values,��� WT converting each `u32` to a byte slice in little-endian order. If the requested byte���!@= length is not a multiple of 4, some bytes will be discarded.��!���"NK See also [`BlockRng64`] which uses `u64` array buffers. Currently there is���"-* no direct support for other buffer types.��"���#GD For easy initialization `BlockRng` also implements [`SeedableRng`].��#���##����##����$'��D�&�
�����&��d�&�$P��IH����(*��&<�&���.d�&,�&���.\�'��'EB The *core* part of the RNG, implementing the `generate` function.�$�'���$AA�
�������$A����.A�$���(+AA���$�$��$�
��$,�$��O/��FF����FPM [`BlockRngCore`] with `u64` array buffer; i.e. this can be used to implement���G/ݝ�G���GPM This is similar to [`BlockRng`], but specialized for algorithms that operate���H on `u64` values.��H���HOL No whole generated `u64` values are thrown away and all values are consumed���IGD in-order. [`next_u64`] simply takes the next available `u64` value.���IOL [`next_u32`] is however a bit special: half of a `u64` is consumed, leaving���JMJ the other half in the buffer. If the next function called is [`next_u32`]���KGD then the other half is then consumed, however both [`next_u64`] and���KLI [`fill_bytes`] discard the rest of any half-consumed `u64`s when called.��L���LSP [`fill_bytes`] consumes a whole number of `u64` values. If the requested length���M96 is not a multiple of 8, some bytes will be discarded.��M���M#����M#����N'��T�O�
�����O��d�O�$�-�L����*,��O<�O���.d�O,�O���.|�OL�O��\�P��PE�$�P���$H8H8�
������H8�����H8�$�����H8H8���$�$��N�
��$,�N����?< An interface over the operating-system's random data source�����PM This is a zero-sized struct. It can be freely constructed with just `OsRng`.�����EB The implementation is provided by the [getrandom] crate. Refer to���*' [getrandom] documentation for details.�����NK This struct is available as `rand_core::OsRng` and as `rand::rngs::OsRng`.���DA In both cases, this requires the crate feature `os_rng` or `std`���:7 (enabled by default in `rand` but not in `rand_core`).�����! # Blocking and error handling�����MJ It is possible that when used during early boot the first call to `OsRng`���IF will block until the system's RNG is initialised. It is also possible���HE (though highly unlikely) for `OsRng` to fail on some platforms, most���	+( likely due to system mis-configuration.��	���	KH After the first successful call, it is highly unlikely that failures or���
MJ significant delays will occur (although performance should be expected to���$! be much slower than a user-space���_\ [PRNG](https://rust-random.github.io/book/guide-gen.html#pseudo-random-number-generators)).����� # Usage example�<�����'$ use rand_core::{TryRngCore, OsRng};����� let mut key = [0u8; 16];���,) OsRng.try_fill_bytes(&mut key).unwrap();���
30 let random_u64 = OsRng.try_next_u64().unwrap();�<�
���
���
30 [getrandom]: https://crates.io/crates/getrandom�	,��&L�Uf]ܔ��a(���&vv�&���vv���&�&�
��
�,� ��&FvFv�&��_�FvFv�����&��^�^��^��[�^�5�[����e�S���5���
�,��Fvww�&���ww�&��
�?��� Error type of [`OsRng`]�
<��&��i��������&��4i���&������i����$w$w�&���$w$w���&�&���
�,� ��&�w�w�&��_��w�w�����&��^�^��^��[�^�5�[����e�S���5���
�,���wyy�&yy�&���yy����&��&���
�L��y�y�y�&����y��y�y�y�y8��y�y�y���&�6���
��ʭ��XMJ Wrapper around [`TryRngCore`] implementation which implements [`RngCore`]���Y%" by panicking on potential errors.�
L�Z�
�����Z��T�Z�(D��Rq,���$�(��T�$�(��
��$ik,�Z���$�����
�����ȝ������(��_������������(��^�^��^��[�^�5�[����e�S���5��Y�
��$,�Y��������
�������$������(����������(��
��$G�G��
����@�G���F�(���_bG�G����(�(��Y�
��$,�Y �Y�
�������$4����(ωω �
����5��$ω��B�(���[^ω�ωωωω8�ωωω���(�6��Y�
��$�Yq�q�!�
�������(q�q�!�
����E��$�$q���U�(���nqq�q�����(��(��Y�
��$L�Y�q���"�
�����`�$����(��`�25������(����6�����Z�������`���
��$��$�Z����Ƴ��]M����^%��L�^���
������_��T�_�)�l�_�)�W� @gz�����)�)Y�w���)��
���)�^��������!�!�#���
�������_�)!�����)��_��	!�!������)��^�^��^��[�^�5�[����e�S���5��^�
���),�^�!�j�j�$���
�������)j���
�)�����,/j��j�j�j�j�8�j�j�j����)�6��^�
���)�^��%���
����������)ps����%���
�����=��)�)���M�)�����lo������)��)��^�
���)L�^������&���
������`�)����+�)��`���JM��������)����6���� �^��������`����
���)��$�^�������A�V �V �V �)V L�)V ѢV �V O�V ��V �7V Z�V ��V �=V "�V ��V +�V �RV L�RV �V ��V D�V ��V C�V �V �gV ��V �V 4�V )�V �V q�V �V ]�V �%V a�V �*V ąV ��V ��V �V �V �V �V �V �V B�V X}V �|V |V �V kV 'jV JhV �0V �gV ;gV �fV �2V �ZV DZV ]YV �GV XV PWV wVV 'VV �UV �PV �RV �RV BRV �\V �cV OV �NV MNV �eV �fV �8V �2V �1V �V m)V ��V ޶V !(V ��V ��V �V �V �V �V �V FvV oV �V �V �wV V V �V aV gV ��V 6V 
V #	V )	V YV _V V #V !�V ?V V V 3V 9V 1q�~���SeedableRng::from_rng�core::convert::Infallible����RngCore::next_u32�}RngCore::next_u64����/https://docs.rs/rand/latest/rand/trait.Rng.html������ȩ����������������
std::io::Read�����	rand::Rng����io::Read����������TryRngCore::unwrap_err��������������impls::fill_bytes_via_next����rand��������RngCore::fill_bytes�impls::next_u64_via_fill���K��������G��	�����impls::next_u64_via_u32���c���������	����impls::next_u32_via_fill���I���std::io���	fhttps://docs.rs/rand�
Infallible�
core::convert���`���io�SeedableRng::try_from_os_rng�����|���������https://docs.rs/getrandom�������������������������������������~��9��������BlockRngCore::generate���}��crate::block�������������crate::block::BlockRngCore��������
��������������
��
��|������
��
����������
���������~�std::io::Error�"https://crates.io/crates/getrandom�PRNG�1https://rust-random.github.io/book/guide-gen.html����2https://doc.rust-lang.org/std/io/struct.Error.html���std::io::Error::raw_os_error()��������������������������������������|���H����������������������I�I�I�H�J���������H����������������������I�I�I�H�J�������|�����H����������������������I�I�I�H�J������BlockRngcore
result_len
index5assertion failed: index < self.results.as_ref().len()5
BlockRng64
	half_used	,assertion failed: src.len() >= 4 * dst.len(),,assertion failed: src.len() >= 8 * dst.len(),OsRngOsError	UnwrapErr		UnwrapMut	from_os_rng failed: RNG error: ReadAdapter����������������́����������Ԃ��d��i]������XU�i����j��q��5{B~.���'��W΄�1a:��}���ۂr�	0��n.�Z_ܽЕ�<�-n�ZH:�v/�,Do�ur�cmc�*�>!���'�NA�!�Y�(f���Фc�YoJt�k�҄��j�^����_�u}W�?�
�v�E�'�O�_N�D �a����_��d�r���%%}�Ů�|�E$�"}/��"a�����E���]��A|I6̅���lzA[���g�>/�+{�-�ƏDT���������ˡ]$1 4=�C_�W\�(�6��m6P��WwI��.�o&\�ݪL;��m�a�^:Nٹ�Q� T��9'��\��@��X�,/���Ӎ�9�v�A�����U�B��/J{�L�.Y� �������d�#���A('��$:B��"��Q=�@	��5�q�$RMtpVq��lj����e���r>OM�/G�s������5w�d�a_��Cjk|Y����EX�0E=����{�.���n*=KE-|��]�]��X/[V4��2���[��&"[�Y&��]����+G隱�T���q�i�s�D$��FmoN���ζo�E��i��=�F����+�sJB��L������#�G,�欕|D�.�m䣲%X�ô�u9�e/R����
�q����GH�� 2�|h����lqu��T�4���X����E+o�a:���nTu
�1��8��U����1��J8})�e���bXWᨕ�/�OC1Z)��f��OO$4��	�k�_0�%ߟnl�&�~	�>�U��JOU��>��
ll`[�ľ�
���n'�fU���#m2�
]��:��х�F�:k� �:S�&A�m�E�
|�	ɘ�#��~�y8�~�g�C�d"B�t��>a����N�2����Ÿ�nW9nefm�@&Ǎ|cp$W���f�/4
����Js�[u�
�$	��|�񦣁0��:�����l/��ք]��h�:����
{p�k�]k�`�m2�в̠�[�-�>���'ܽ���h"hc_�0_�~$
��S�OC-NT�;�|5��ϩ-L����c1��Ӛ����_v=�Z��	1��{w*u�gq����8j�*�����dw��Ƹ�g� ��hW7x�,&�wh:m��@�u�6�����8`@�E����-��bh��Sfdt&����5���|���AoҼ�c�E]�{~)>H�4$,V��Q1�:Y����Φ���ş���e���y����x��q®�.��uU����*�}�A5�X�q\uqYQZA�?!����lʄU�0�N�T���+$��
[s��J؜����{!o䧥�R�]4څR�|nJ�d3."a��j����oR��|R|��K8^�S�"�7O�|T�w~�M�_]�o6-AG�.�RUen���D���%F:�7���*~b��P@A(�="ٱL�zu�:[`�	F���,��0�~H·A�����pdA���r��я��d0ťK��/�MbE�͉p'�"GҨ(��̫nDȒ]ҩo���J�?��6��!�E��1D$����r���5�<��K*F��p�
m�z���$4�K�Km�@�ӝ�#��#�.0�PV�i���p�==H�I9Jځh^��sE�jk��E쫾A6F�
|�;�t|B`���
z%���s�\��{�.P�Ϛ�S�^NN}+�s�X�Td���<.6��H����HD3��>�ql%��o�0������m����vT��C�J���q�I�5椅
	W[K���l�Jִ��Q�m�q�S&K��[+/v�8Qr?4�6��.��� ���f:D.VB83��׏�< �a���CL��p^7`3g�2�pV,���fNϹ0Ԙy��~�z:�hz�����~yP6
֣x
/,�}LJ��a���T<C���)��>e���)f����*��Y�EDmFa���ܣ�3%�P���o�s��UZ>���I�	h����;R��=�*)a�C�3`��u�ʛ�c�}v�n�@�_�}L7H��f����³c@m`�2��I�ȃ��<.tz'b�q����)".OB��'��ǝApH����^���
;�nkG�lJr4�].������eYUc�+1�Ɓ
�#�%������^�A[6�@�L�9�'���M՛!���T��|(���S����1�.�����q��׈�<-�� .M��4hCu�B߆�����\�L��_ָ�c$N �v�5FH�{N&��t؋P��w����ӄ���s3��H�XT�����/���:��u'��Eͦ��8g.:\� �?ɉ��Bw'�t;�e��R�PU��K�|@�*9�ۑE��z~�\Aߥ�J�Q���j�E¿��5E�uDXM$V9e������́�!�a����o
��jXR�y�|�;��h͙BB�gT���ᐞԊ_�:>���`!N��w+�g���c��
�����,�jD���&��g�?���6a(�z��\�!4¼R+�|*�8�CK�0����{�u��B/���7=��Mg{PLܷ̼W�WD��Y� ��d�w����H7[�8(��;7h�a��ȡd�x�,�6۱Q���@����X
ks	����`ά��v��k���%�Q+�	�3�'m^3Lװf�&��d�a������_�h2�ѵkQ�nm��.��{�W>���'��0���R��k(Q�)��^/�q<
�[��0>�
O�/^%2�i�`	�"��IDl&��|�na �կ����k75[��� �vՓb��YR;N�B*B�yu
��j�ߔ��#<�D�n
rO�
#p���'�����n����M.\�>�&1�Z%f8jF��z���b�KT�������)�|����4��1���?y�仈)Ȱ�!�x��_����.[�N�4��r���$�Aa�L��6&t��q�-���?����V�F�)����-��*)�,��,��ZX�9��`D6Euڲ���03B���hɄ�d�B
x��F����~ҫ�o�b3ጸ���_�R��F_ԅ�<M�Y�؍�Ʋ^}0�������qS@v�8Cˑ���%����?i����8�դ-��Z��"u��“"�tAd0P�|�7�Y�Tb]�s�6�;r���9d�̗yENpW��`Q��� 5֝"�}����D�J��jn��=s�o��:Ѓ����S�%+��8�}�^c+gKo����6�����!�*���B����!�*�v�v�v�v�����=�&��.�L�Y���L����t�"�f�)�n�A���b����u���S�k�����~�
�_���Z���������a����g���>�V�����[���'
�������������
�2�s����������"�����l�=����-�u���:�U������*�B�����?�`N��H
<
(
�
�
B��#���SI��h��>� �!'"�"�"2#�#�#H$*&�&�&F'�'

(�3+�2I9�<>=T=k=pC�DHH}I�K�KRL�LMqM+!N"V<VVV�V#WxW�[�[�[�[\r\�!\Mcmc�c�c�c�d�d�d~e�e�eff;f�f�fg�g�gh3iIi�iGj�j�j*kk�k&l�l�l9m�m�m�n�o�op�p4q�qrtr�rRs���������N���5����!�*���X�K�8��L���������P������F���K��i
���!"Y"�#,$a&�'�*�K3LRMVW�[V\#c^c�c�c�d9e�ef,f�fg�g�h|i�jk�kl�lm�m)o�oq�qPr.s












&%%%�������:��������2����w�����W������������E������*�|�B�k�����p���M�M��������G������6�>�����������3���j���.�W�����z

�
��
Wy��	������S��!�"�"G#�%�&'['�*�29�<�<C=Y=�B+D!H\I.K�KhL�M�U&V@V�V7WR[�[�[�[\�\c9c�cd�de[e�e�eOf/g�g�h�h5i�i�j>k\lMmn�nQo�o%pjq�rfs���������������'�-�2�6�:�>�B�H�U���G���
�b�o��T�a�%�j�<���Q�^����p���B�O�f�����l�y����M�Z�����U�������}���\������b���-�:�Q�����I�V������#���������������������������-�o�������������������H�U�g��'�9����)�c�h�l�p���5�P������&�=�����;�L�P�V�\��D
7#
�
�
�
=�����ND��c���9���!"""x"�"�"-#�#�#�#0$6$C$&%&�&�&�&A'�'�'(�+�2C9�<+=9=O=e=]CjC�D�DBHwI�K�K�K�K?LLL�LM^MkM&NVV8VRV�VW WsW�[�[�[�[�[\b\o\�\#cJcjc�c�c�c�d�d�dEeze�e�eff8f�f�fg~g�gh�h"i/iFi�i�iDj�j�j�jk'kzk�k�kl#l�l�l�l'm6m�m�m�m�n�n;o|o�o�o�o�o�op�pq"q1q�q�q�qr\rbrqr�r:s@sOs�st
tttt%t+t1t7t=tDtJtPtWt]tctitptwt}t�t�t�t�t�t�t�t�t�t�t�t�t�t�t�t�t�t�t�t�tuuuuu"u(u.u4u:uAuGuMuSuZu`ufulusuyuu�u�u�u�u�u�u�u�u�u�u�u�u�u�u�u�u�u�u�u�uvvvv!v'v/v7v=vCvIvOvUv[vavgvmvsvyvv�v�v�v�v�v�v�v�v�v�v�v�v�v�v�v�v�v����������+�4�8�<�@�F�{���6�y���d�t�V��������S�b���u�D�S�k�����n�~���O���������0���������g�/�>�V�����K�[��������8���8���������
�2���������!�)���J����������/�j�n���U���*�B�����S�Y�v�	�
��
�
�
Bu�����~����>��!"z"�"�"2#�#4$8${%#&�&�&�&F'�'�*�29�<�<>=T=�B_CD�DHFI)K�K�K�KALRL`MqM�UV"V<V�VW#WN[�[�[�[�[\d\r\�b&cmc�c�deHe~e�e;fg�g�h�h$i3i�i�i�j�jk*k�klHl�l*m9m�m�m�n�n>o�o�o�o�oppq%qVq�q�q_rertr=sCsRs�stttt"t(t.t4t:tAtGtMtTtZt`tftmtttzt�t�t�t�t�t�t�t�t�t�t�t�t�t�t�t�t�t�t�t�t�tuuuuu%u+u1u7u>uDuJuPuWu]ucuiupuvu|u�u�u�u�u�u�u�u�u�u�u�u�u�u�u�u�u�u�u�u�uvvvvv$v,v4v:v@vFvLvRvXv^vdvjvpvvv|v�v�v�v�v�v�v�v�v�v�v�v�v�v�v�v�v�v�v7�?�����C�����'�l��7�^��X�*����[�����A�����L�`�����9�v����"�W�t���<�o�����k���C�v�����P�����7�K�����$�S������� �~���������������������(�`�{�������T�����u�~�(�R�`���$�2����}��B��������7���t�%�G��1
$
?
�
�
)������9&�}F��%{��!�!">"�"�"##�#�#	$@$�%M&�&�&('�'�'(�*�229�<=4=K=a=3CgCdD�D4HoISK�K�KLIL�LM<MhMN�UV1VKV�V�VW_Wi[�[�[�[�[\8\l\�\	cCcZc�c�c�c�d�d�depe�e�e�ef(f�f�fgfg�g�g�hi,i?iei�i)jcj�j�j�j$kfk�k�k�k l�l�l�l�l3m�m�m�m[n�n�ngo�o�o�op�p�p.q�q�q�q-rnr�rsLs�st����;������f���$�X��L�����U����������F�X����� �p������Q�a���0�\�����_���7�c�����D�����1�C�}����M��������g���x������������������"�X�u�������=�����k�t��L�X����*���	�w��<���������/���h��A�{%
�*
�
�
�z���v,�p9j��n��!�!")"|"�"#r#�#�#�#:$�%,&�&�&'�'�'�'�*�2)9�<=.=E=[=CaCGD�D+HfI1K�K�K�KCL�L�LMbM�M�UV(VBV�V�VWQWT[�[�[�[�[	\#\f\�\c:cTc�c�c�ctd�d�dege�e�e�e
f"f�f�fgXg�g�g�h
i&i6iPi�ijNj�j�j�jkXk�k�k�klvl�l�l�l-mwm�m�m>n�n�n^o�o�o�op�p�p(q�q�q�qrhr�r�rFs�s�s��V��I��\�.���6�����E����d�����[���J���@�����o���G����T����O�����8�������������������*�d�}�������t���w���:�d��6�����#�D�������;���x�)�I�5
(
g
�
.��>+��S��*��"W"�"#�#�#*$&_&�&-'�'�'79�<=6=M=c=JC�D9HtIvK�K1L�LMPM
N�U6VPV�VWdW{[�[�[�[\T\�\cHc\c�c�c�c�d�d�d!ewe�e�e�ef*f�f�f
gkg�gh�hiDizi.j�j�j
kkk�kl�l�lm�m�mnono�o�o�pq�q�qNr�r,s�s�����3����x����������������F������+�}�l�����q�N�N���I����B�J�����������k���X�����
�
��
X
�����T��"�"H#�%�&'\'9�<�<�B,D"H]I/KiL�M�U8WS[�\c:c�cd�de]e�ePf0g�g�hi�i�j?k]lNmn�nRo&pkq�rgs�����4����y����������������G������,�~�m�����s�O�O���I����B�J�����������k���X�����
�
��
Y�����U��"�"I#�%�&'^'9�<�<�B.D#H^IkL�M9W�\�cd�d;e]e�ePf0g�g�hi�i�j@k^lOmn+oTo(pmq�rjs}�x���!�����f����y�o�����������4���
����k�Z�����_�<�<���6�������%�-�����������Y���F������	�
��
�
F������B��"�"6#%�&�&J'9�<�<�BDHKIWL�LvM&Wu\(cpc�c�dJe�e>fg�g�h�i�j-kKl<mn@opYqwrUs����OYblv?IS]gs}�����������	(5�������	&gq|�n�`�]�N�x��Y�������9�U���"�������T�&��
�!"�"�#B$�&(iC�D�KKLjMVW�[n\.i�i�j&k�k"l�l5m�m�n�o
p0qrprNstr[�2!�#^+/4�4k5#6+9�<�>?�?�A�F�I�N�O:P�P�Q�S�[0e�f^h�iDp�y�zi{?|�}��[���������������؍&���ۓ�H���F�G�/�`�����7�uDv�v��"w�w�xyyC���������ϊ��U���p�XZ�Z�ZK[�[
h�i��3�������4�pY�}0!�#\+/4�4i5!6�7�<�>?�?�A�F�I�N�O8P�P�Q�SVZ.e�fh�iBp�uzg{=|�}��Y���}������������֍���ٓ�F�ޜ��D��-�^�C���)9Bv�v w��w�xwy�y�������	�͊��3�S���n�$�qZ�~1!�#]+/4�4j5"6�7�<�>?�?�A�F�I�N�O9P�P�Q�SWZ�Z�ZJ[�[�[/e�fh]h�i�iCp�u�zh{>|�}��Z�
��~������������׍���ړ�G�ߜ2�����E��.�_�D���*9Cv�v!wB��w�xxy�yߺ�����
�Ί����T���o�%�ueilo�Z�ZC[�[�[Vh�i+�����Z�ZG[�[�[Zh�i/���������c�5�������������e���G���v���N�
�[�������B���������h���{�{���A����'�������|�-�=
0
�
6��G4��\2���"&#�#&�&:'�':9�<"=VC�DBHwI�LNlW�\�c�d�d�e�fpgh6j�jsk�l�m�n�p�q�r�s����'�����!�*����y����"�����
�_�Z�a�����������s���-�u�:�����?�t(
s��h~!�!'"�#�#*&�'�*'K�KM�U�VL[!\�bRc�c�c�de�ef f�fg�g�hNiLj�j�k�k�l�l�m�n�o�p�q	r�r�KV�[c/e�ho�K�U}[
c#e�ho���������.5CRgksz~�������������
.=Pckovz��������������������"&=D^eimq��������������!9@D\cgn���������������	$	(	,	0	4	B	I	P	W	[	c	k	s	{	�	�	�	�	�	�	�	�	�	�	




$
,
?
C
K
O
W
_
g
o
s
{

�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
'/7?GZq�������������� 19AIZbfnv���������������������



&
*
2
:
>
F
M
Q
Y
a
e
m
q
y
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�

"&.6:BJRV^fnv|���������������������$*06<BHNTZ`flrx~�������������������#*18?FMT[bipw~������������������
&-4;BIPW^els�KV�[c1e�h!o����P�Y�O�P�Q�R�;�?�C��!�&�+�0����������������������R�������������G���
������o
s
w
$pqrstu����_"c"g".$g&k&o&
+�+�+�+�+�+�+5LTMWX\`c�c�d�e.fg�g~i�jk
lm�m�oqRr0s�v�{V}�$�$~4 ������,���f�8�8=Q��^�S�G�5�L������� ���������L���K��{
�v��!"k"�#/$s&�'�+:LYMW]\ec�c�c�d�ef3f�fg�g�i�jk�kl�l"m�m�oq�qWr5sVZ�^_�k�c�k�c�Cɼ�g�gҺ�h��g�h��g�h��gFPR<?���&�6�J�f�&]�&���6�6�6���6���Cɼ�g�gҺ�h��g�h��g�h��gFPR<?���%�6�J�f�%]�%ٷ�6�6�6ٷ�6��Cɼ۵�Cɼ����ɼ۵��ɼ���Cɼ���6ӷ�Cɼ۵�6���Cɼ���Cɼ۵��.��%��&�I�����������C�����C����C���	�C��ڸ(jɼ���I�����������C�����C����C���	�C��ڸ(jɼ۵�Jɼ���Jɼ۵�Jݵ�J���J���Jݹ��JȺ���J����ݶ���Jٷ������&�c�.�&�c�.�p�c�o�c�o�c�o�&�o�%�h�&�h�%�k�c�H۵�H���L���L���Lݵ�L���L���Lݵ���%���&���%���&�Dɼ۵�6���Dɼ���6ӷ[�%[�&]�&ɶ�6]�%��6<-"0%36(=8;C=!$': .#1&479)V V �	<���jcore_intrinsics����d��i]��5H[%@������3,���Z��panic_internals��generic_assert_internals����d��i]���*+�:�P�
9�}����fmt_helpers_for_derive��_�_�d��i]���7��z�
����#�����������d��i]���ݣ����
b�������_�_�d��i]���Li���(���&���Z���d��i]����j�TP��~
$�Yu�����derive_clone_copy����d��i]������}ޞ��
��u�=����`�`�d��i]���gx����
�V 
fmt_internals�const_fmt_arguments_new��d��i]���l4�zö�����O\������d��i]��}~�����V ���d��i]���E�����tm�}�J��������d��i]�����f��\�$crate::const_format_args�'�$�"]���Z�������d��i]���
=��d'�	)�������_�_�d��i]���9Y���d���$���d��i]����:9����~
$��������d��i]���MyN�!%�+kV �d��i]���j
ɋȆ�
g�e�f\��	derive_eq������d��i]���F�gs�Kf���],����������d��i]����0j��qV �d��i]��³'���t
����������d��i]��Y��jq�"�V �d��i]����;���
ڷ�������d��i]��_V�[N�@ŢV ���d��i]��Y�%��u4���^%���d��i]���#Xq�_�T�����������d��i]��(/�^6��@��V ���d��i]��Jo��eAt��8�������d��i]��<"���"�
��V ���d��i]����c�+�$crate::panic::panic_2021��"��%��]����S�R�d��i]��i�V]B���~	$��������d��i]�����"�Kp9V V ��d��i]���X��W��t
q�D�������d��i]��OY�	�x����V �d��i]��ʘ�tHW�M���N����d��i]��L�dDbl��
��+������d��i]��|76�����	�V �d��i]����zL!����#�����������d��i]����y�����
<�Y&�����d��i]��ol�l�=�����YV �d��i]��.�-�V-����,���d��i]��{n)U���
������������d��i]��zޝ��/���V ���d��i]������:�T���Y;����d��i]����������������_�_�d��i]��U��L};��V ���d��i]��eW�S�^>std::format���� ��
hint_must_use�liballoc_internals��d��i]�������r�}����`�`�d��i]����[6�����V ���d��i]��������~t	���������d��i]��<���'��$crate::__export::format_args��'�(��Z�����d��i]��T��}�9�))%(����%��Z�ts�d��i]��Ƌ,љ]�F+�� � ��" ��* ��2 ��� ��
 �� �� J+���: � � �& �. R+�6 ���N+�> B'�#� �'�$W!J(�!�(s)�%V+*]&%#�*
'�#b i'$
!�'k$�!�(%�!)h%B"�)�%�"`*�&\#�*�'H$$(�$�(E%I)�%v"�)1&�"�*�&R Y'$� �'�$�!x(�!�(�)�%y+P*�&L#�*2'�#� �'8$G!(�$�!�(5%2"9)�%f"�)!&�"�*�&�#6+�'[$:(%�(X%c)�%�"�)M&#�*�&�4ODHT ����{�.P��� 2�|h��V{p�k�]�Q�m�q���/4
��w_�~$
��S��T���qGľ�
���g�9�v�A�-��U���\��e���0��:�{�-L���ň�~�g�C�p�i�s�D$H�E]�{~���]���E`���
z%��~yP6
֣x�[�Y&D�A[6�@�v�5FH���S�^NN������/"6a(�z��<��s�\��_N�D �a���g� ��h�׏�< �a�����#�GO��1D$����M՛!����nl�&�~	cv�E�'�O�T��|(�����Y� ��dD�8j�*����7[�8(��F��'��0U�D�n
rc�,��,��xH:�v/�,u9�e/R�S��0�~�}0����%����?i��OO$4��	a\�!4¼R=��m6P��% 5֝"�}�����8`@���nW9neft|��K8^�S�/�q<
�[Xȃ��<.tz�o��:Ѓ��g�?���;�pdA쁽�$:B��"3E쫾A6F��̫nDȒ]�h͙BB�g4�6�;r����GH��Up�==H�I9��1��J8})]�J؜��B��L���N�$RMtpV6�OC-NT�;���/�MbE��.0�PV��V��Q1לv�8Qr?�� �:S�&Al��CL��p��R�PU��K(�pV,�����R��kV
��jXR�2�YR;N�B*`�R��F�̗yENpW��ˡ]$1"Jځh^������_�u}ll`[�f��m�a�^:(����_v=����*~b��P����d�#�1��³c@m_ָ�c$N �&��d�a�PI�	h������i��K҄��j�^�"a��j���Z%f8jF��hK�Km�@�����9d���ۂr�	0YoJt�k�d"B�t��>qfdt&�˗1��{w*uό�|T�w~�M��L�zu�:[���Mg{PL�B0P�|�7�a:��}��=�F��LUen���D��!�Y�(f�}�A5�X�q�A�?!�����e���r8�]�]��XA4څR�|��oR��|R��Q���j,�͉p'��B߆��������`�KY�؍�Ʋ^�B/���7=A4�6��.����|5��χ,�欕|DP���
�$	�y�	ɘ�#ny����x��nJ�d3.�
|�;�t|B�C1Z)��f�`(Q�)��^W�\Aߥ�J+n����M.f��[��&"C�>�U��JOd�"GҨ(����~�z:���.[�N�4pH·A�������r���q"u��“"�)>H�4$,�}+�s�X���<-�� .���_��d�{N&��t؋7H��f�������m��'b�q���%������^�%X�ô�RTd���<.6�!�a����o1�w����HE��'�NA����:��u#��)Ȱ�!n���hɄ�d|N�T���+�'��Eͦ��$WwI��.�o&-AG�.�R�zA[���gք]��h�}��AoҼ�c�:Y����Φ�?ɉ��Bw'&�nm��.S�l�Jִ������XU����4��1l�/J{�L�./-��*)w�d�x�,�6H�
�����,9_ԅ�<M����03B{Y� ����0W7x�,&�lJr4�]�.�����qT���ᐞ5?����V�uF�)����v���~�~�+G隱�F�����_�a����N�r�'��ǝ�W\�(�6$,/���Ӎ,`�	F���,�q®�.���t;�e�'+�|*�8�C>��r��Ѿo䧥�R�]��z���$4��I6̅���lC�J���q��х�F�:kkԊ_�:>�6Dl&��|�n\q�-���ti����/^%2�i�Z�)".OB�$�Aa�Lr�'�����ei����j�W[K�����o�b3�K�0���?Z��	����
�q�T�?���\uqYQZ�
/,�}LJ����X
ks	JW�?�
��Cjk|<EDmFa�����׈�tAd�lʄU�0��0Ԙy��hz�������|��z�"�7O��*)a�C�r���%%}�m�@&Ǎ|uT��9'��\*��A('�2k���%�Q+M�|@�*9)�>/�+{�-\�>�&1�g��n.�Z_>OM�/G�s9�k�_0�%�bTu
�1��8[���d0ťK�^7`3g�2��ܣ�3%��	��5�q5�	�3�'ND.VB83�������8�դ�
]��:��j��%F:�7����Q=�@4c�*�>!�
D3��>�ql����D�J��*=KE-|�@����E+oY�m�E�
|m�\�L��m^3LװfO��fNϹ���`!N��w7Nٹ�Q� )��`Q����ƏDT�� ����U�B�.n'�fU��h���vT���E�uDXM$V.-��Z���$��
[s��8g.:\� �%�k75[���^n�@�_�}L�x��_���o;7h�a���G�Y�Tb]�s�h"hc_�0�M��4hCu�d��i]��q��lj���7sE�jk�������l/��|�#m2�i�-n�Z
��FmoN�I��ζo�EJk�`�m2��Do�ur�cm�wh:m��@�P���o�s����lqu��TW�
;�nkG���dw��Ə���v��LB�yu
��aO�
#p��d���?y��mŮ�|�E$��6&t��s���qS@v�c1��Ӛ���c�}v�:����
~�W΄�1в̠�[�-�������:E����-��2����Ÿsgq����S&K��[+/�cp$W���fvƁ
�#�9e���/��{�W>�T��5���|ј/[V4��2�B�u�6���P��w��3��H�XT!��0>�
O�Y�3`��u����B
x��F�}�4���X�X�8Cˑ�����>���'��;R��=���Js�[u�x�E¿��5-F��p�
m���Фc�I�5椅
	�C���)���6��!�E�&\�ݪL;'��~�y8o�q��5{B�jD���&�:�a:���nZ{�.���n?��ӄ���s `	�"��I[a �կ���]�e���bX^U��>��
eeYUc�+1��]��A|�bh��S���H����H����*��Y��`�2��I�j�ߔ��#<b 4=�C_#Wᨕ�/�O_ZX�9��`Dyҩo���J�6Euڲ�z�_]�o6���r���5��<��K*����ş�������E���UZ>������a���T<�۱Q���@�I�"}/��"a�ۑE��z~*���́�00E=����>>e���)f��ܽЕ�<	5w�d�a_�;��+�sJMApH���	��@��X�+�h2�ѵkQR �vՓb�_Y����EX�=ӝ�#��#�@A(�="ٸ%��o�0���.�m�QuU����*��.������
~.���'�ܽ����+�g���c�8���{!������_�Q���)�|�kz���b�iKT����j� ���f:��jn��=s��̼W�WDC�^��
S����1y�|�;��3������!�{�u��@�L�9�'��g��K.��`��D)8{x\CVbr?eX< P'g]i4U#~_Q2Nc9p?v4)^{3)-=?�s�@c.39�jNo+yk 8%5#+�>q@(cHYZ^qNc����@eg&-�n�BQ8p,>)5^g/���`�g�"�Jy!a/�������%�'^O_I������zE����hG
/
7$m:2�P7)3i1SeF�!�^.8Air�/�qN��FtS!h.y6p	^7XZo\&gIpTX-%�u��>lD?�D��lQ'!�����~>.J�/9o%w8�sRlS�	L6����F{7>����A3;�v�W`e~+�Yst�&vd9����:{_uMMg"[6 [*wcpLQrF;Mw��x?\T3BhM{*jeGsC������w6\q"��!W779$\,A)$]b'"%�
NO��`�0?kD%Kt(P��{���l~QTpt}tGRi9���	e{{������a�g��K.��`��D)8{x\^/home/palash/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/rand_core-0.9.3/src/block.rs� ��$L"�P첮������2ECAA$8NMBKQBO&+4&">
%1
?;11(#:%OF/>*MDG)9J-1*GQ0N5HMK15P7II?PHENXAO.H$$(?j'JO@=%'?)$B@)31$
.NM#/J2L76/<$7&
7$24</ 23!&/?&9
0&;*,^(#
B-&**2$L,PGQ0QPHPNHMT:$$(?2IJOB=''?)1&B@+31$
.NM#/J2 L76/ >$>239$
4*/7$73
7 0 &;7 ,^(#
D-&**2$L,R
<'%">#F
$13
)F%%@BA@A@@BA'!>#O
&13
+V%%@BA@A@&(@BA3L�����"��<�+��^/home/palash/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/rand_core-0.9.3/src/impls.rs� -g.��Ʀ�a6J�4���9�2ECAA$;ONIPMFE>CA''OPLHP/;#;+;+$%)* * 5M]*<02#U&$B*D3
O7J=PQ#0&.,HC(#
>QO7J=PQ#.@Q@D@D
$% !B< !BB  A*$" !B< !BN  A*�$pP�rwɟh[Z��~)\/home/palash/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/rand_core-0.9.3/src/lib.rs� ���V�Ԉ�l%xG`i����24ECAA$$MN6R3P$Q##Q@:(=, ,FH:NNPFOML OQJ0MPMLFC5GD;OLJ8NLHBNE%#(#
(
32
C($$.&MPL#&MPM#&MP,D;G. $$$$/*DMLPLAMIOPOQOL6LJPNG @2J4OMON?7+&<&</M1+
168;
'MWF-,==NGGMLPLALOPO&2N&<,/$'$'/,4N&&A4%PUN4
<$'$'/,A=FHNOPJL #P6PQ'O?QOI$+%%("
)(
)0
%#5
<0MMRMP!PMQPAHQC%OMNPQ,.OQMIQ(MPO,/I/23M3@ AE,2
.:!7
)B
;QQOILLONOKOOLJ3'2.'DKL.,"DP+VKO>*U1:(?
V(O>/1=.))[*m8GJ7]
II/
!+!5'2"
I%4D
5*JJ29:,
 5(
(
1
"%];L
=30!
')a;N
=50!
'%8?>
B71
''8C@
D71
'&4EE!T!
('!('��ɴ�:��c�(�)z[/home/palash/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/rand_core-0.9.3/src/le.rs� Ca���a��3Z/iݔ�@2ECAA$L :
A
4)B>:
A
4)B>I%$$9$$%,,9,ڇ-��/Rq��An�.[/home/palash/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/rand_core-0.9.3/src/os.rs� ��v�3�������}��s2ECAA$F'@QF+OE;"NJI,LN%`(-44'-&&K;%E+GROMT/=*=*O/++1�H�H#Q�
����#)�G�J&L�O�Px86_64-unknown-linux-gnu��.�,܀	P��I�	rand_core�-2da007328faf5529��d��i]����	���	��0�����������
�����
j������������������	�	`�����������������������������������������������������jj������6$E�">�>���Grust-end-file