📄 librand_core-375cbdf48043d588.rmeta
/home/palash/git/iron_learn/target/debug/deps/librand_core-375cbdf48043d588.rmeta
Language: rmeta • Lines: 1737
rust
�x#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�xV�/�z�V���2#-f23d5fb9f19d1030���v�
їG}�/x$YxD-e720413b8edafa0a��	+Y�D]�O.ʼ��
$�-965a3d5e7b2182f0�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|����������������@(�n��
�_�$|�$��$��$�������������kn�K�$�_�$|�$��$��$PP������=nt�z�G��&�_�&��&�������is8Skخ-{��&�_�&���&��&�&��&�_�&��&��&��&|���'��$��$�_�������gDB
���$��(��(��(��(���(��(�(�`�(|�(��(�_������a�gQ3�#��
��)���)��)�)�`�)|������a�gQ3�#8�)��*�������T��
���8�)�_�*�����������.������������7������#�<�,�E������SW����������������������������m�o�s��x�����������_#|/��P�������_���	�`	��
M+�.6=8��
�.N+�.6=8��
�.O+�.6=4��
�.U+�.6=4��
�.Y+�.6=8��,
�.b+�.6=4��.
�.e+�.6=8�ی�.�-�.8?4����-�L-�QX�&��%��&��'6364136223846793005������o�Tv��&���&��&��'11634580027462260723���
��%�&0}}~��:l��`g��Z#
��$�)�(4�$;B��^0
��)�+������a�gQ3�#�)f�)pwGfi|���������������[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�[�7i��h�z�g�{�w�{����������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 {����LL��L,��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�������U�U���UT��V���U��B��V
�V����V�V����V<��V<�V-�V �VL���%" 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�����U��V�
�U$��<���&��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��U��)�Ud��U%�\�U/�\%��(=�
���$�(�$d�(�_�$T�(�$�_-/��(6�(�����$��^�^��^��[�^buf��[����e�S����������������������q�aX�YÅÅą��:�����(
�$$�(��)��*!�
�\�+�\d�+�$��,"��+=: Create a new `BlockRng` from an existing RNG implementing���+;8 `BlockRngCore`. Results will be generated on first use.��,�$�$
�$�$�,�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���$�Y�1
�$$�1��30��2GD Generate a new set of results immediately, setting the index to the���2
 given value.���3���$�.�Y�3
�$$�3�,�3��49�
�$�%T�4�\��4�\�4�$ "}~" !�5D�5���$�%�5
�$$�5�7D�7���$�&�7
 �$$�7��7 <closure_kind>�!<closure_signature>�!<upvars>�!! !�$��
�%�.�&�Y��=)T�=����$�
�Y�=
"�$$�=dest�$�=��A?�
$$�\�A�\d�A��$\�A�$%&'(*�����*(&'GIL�A$�A##�$���B&L�B�$��$##
&�$seed�$�B��B#l�B�&�$##
'�$�l$�C��C+D�C����$#�))�C#���nd�D|�n<�D
(�$�nrng��C')��DEd�D�����������������������q�aX�$�o�#�++�E#���o�D��oT�D
*�$�o�m�D%'��EL�
--�gT�F�$t�E�\��E�\�E�$	��Q?�
//�\�Q�\d�Q�\T�Q�$0�_0 ��R6�R�����$��^�^��^��[�^�]�[����e�S���^.�R.
0�$$�R��R��T#�
22�\�T�\d�T�$3456��V$��U=�_��U;�_�V�$�$11
3�$�$�V�Z��X)�`�X���XI�a��YH�ad�Y�b,�Z���$�.1�Z1
4�$$�Z��[��Z*�c��[E�c,�[���$�Y1�[1
5�$$�[��]0��\G�d��]�e��]���$�.�Y1�]1
6�$$�]�,�]��_;�
88�$�&T�_�\ĥ_�\�_�$9:;}~9:;!��_D�_���$�%7�_7
9�$$�_�dD�d���$�&7�d7
:�$$�d��f)T�f����$��k�Y7�g7
;�$$�g�j$�g��kA�
==�\�k�\d�k�k\�k�$>?@AC�����@A?C?AL�k$�k<<�l��l&L�l�$��$<<
?�$�l$�l��l#l�l�&�$<<
@�$�l$�m��m+D�m���n�$<�BB�m<�nd�m�n<�n
A�$�n�m�m��nEd�n���o��������������������q�aX�$�o<�DD�n<�p�n�pT�n
C�$�o�m�n��oN�
FF�wT�o�pt�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�$�m�!#��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.�������$��k�Y�
LL������<�
K�$�m��j$�#%��.��.L�.��!T�PP�U��s��U$�P�U&���U1��'QRQR���UQ,����k\����R��,�PP��$\��U�PP
R�U$����%TVQRVT�,�SS�k�.��.��#\��%�%QSS
V$����&XZQRZT�,�WW�k�.��.��#\��&�&QWW
Z$���Z|����
�'��k�.�.�\\����'�P�'T�
[�'src���j$�,.l�[�h]�h]�i]][]�'�k�'�Y�Y��$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��H��  (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�$�L,�$�L<�$�O0.9.3�use BlockRng instead���$=��$Ě͚����j��kޏ�$
^���$�j$�%��*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���*?��*ĚԞ���
�&��kޏ�*
_���*�j$�*��+A��+?< Implement `next_u32` via `fill_bytes`, little-endian order.���,���$�%�
aa�,���,��<�,
`�$�m�,?``�.��-A��-?< Implement `next_u64` via `fill_bytes`, little-endian order.���-���$�&�
dd�.���-��<�-
c�$�m�.�cc�.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������k��j�Y�
g���dst����1��96 Reads unsigned 64 bit integers from `src` into `dst`.���d�������@= If `dst` has insufficient space (`8*dst.len() < src.len()`).�P|�l������k����Y�
h���צ�4�������d��ik�T��il��!(*��#�&n�_n��D������&��^�^��^��[�^�]�[����e�S���^m�m
n$�����"�&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��&����������������;t���qq
r$����&tuvw����uwvT�,�ss�&��6d����&��������������������q�aX�%�&�s�s
u$���6d����&��������������������q�aX�&ӳs�s
v$���Ht�����&��k��������������������q�aX�Yӳs�s
w$��j$�ܫ�&��������'��
+( 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�!�H�!���!DA A simple example, obviously not generating very *random* output:��!�<�!�O��! #![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�#�L�#���#'$     fn next_u64(&mut self) -> u64 {���#         self.0 += 1;���$         self.0�L�$�L�$���$2/     fn fill_bytes(&mut self, dst: &mut [u8]) {���$1.         impls::fill_bytes_via_next(self, dst)�L�%�L,�%�L<�%�O�%���%B? [`rand::Rng`]: https://docs.rs/rand/latest/rand/trait.Rng.html���%'�P��&#  [`next_u32`]: RngCore::next_u32���&#  [`next_u64`]: RngCore::next_u64���&-* [`Infallible`]: core::convert::Infallible�<�'||�U��'�	|�U�U}~}~}~��)��'! 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�)���U�%|�)|
}�U$�)��+��)! Return the next random `u64`.��*���*H����*K����+HE via [`impls::next_u64_via_u32`] or via [`impls::next_u64_via_fill`].�D�+���U�&|�,|
~�U$�,��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����U��k�Y|�0|
�U$�0צ�0��0=������0��'D�0|�'�<�0�'���}~���IK�1D�1���'�%��1�
��'$�1��1D�1���'�&��1�
��'$�1��2(T�2����'��k�Y��2�
��'$�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�?���U��?|�U<�?��U&���U1��(��?<������?��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`���ALI 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���C>; panic in case the underlying fallible RNG yields an error.�T�D���U��D���U�U�����������������U���E&�_��T�E�_��d�E��)������������E%��D2/ The type returned in the event of a RNG error.�,�E����E7��E!��d�E���U��������������������q�aX�%����E�
��U$�E��F7��F!��d�F���U��������������������q�aX�&����F�
��U$�F��GH��F*' Fill `dest` entirely with random data.�t�G����U��k��������������������q�aX�Y����G�
��U$�Gצ�G��HE��G,) Wrap RNG with the [`UnwrapErr`] wrapper.�T�H�U�������gDB
���U�����U,�H
��U$�H��I/��I,) Wrap RNG with the [`UnwrapMut`] wrapper.�T�I���U������a�gQ3�#��U��I�
��U$�I��JU��J30 Convert an [`RngCore`] to a [`RngReadAdapter`].�d�J���U������T��
�����U��K���,�K
��U$�K��M*�
�����M��<�M�$�����������79T�N,�N��ȩ1�FĿ�Xx��N6d�N���$��������������������q�aX�%�$���N�
��$$�N��O6d�O���$��������������������q�aX�&����O�
��$$�O��PGt�P����$��k��������������������q�aX�Y����P�
��$$�Pצ�P��W"��QFC A marker trait over [`TryRngCore`] for securely unpredictable RNGs��Q���QFC This trait is like [`CryptoRng`] but for the trait [`TryRngCore`].��R���RL����SK����SO����TK����T@���U���UKH Implementors of `TryCryptoRng` should only implement [`Default`] if the���VN����VO����WN��d�X���U��W%��UT�X��U'Չ�U2Չ(��X.�
�����X��$L�X�$��Z,�
���\�Z��$T�Z�(���}~���46��ZD�Z���(�%��[�
��$$�[��[D�[���(�&��[�
��$$�[��\(T�\����(��k�Y��\�
��$$�\צ�\��]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��)������a�gQ3�#��)��������b
���)�$�b�b��c98��
������cȎT�c�*���}~���-/��cD�c���*�%��c�
�8�)$�c�dD�d���*�&��d�
�8�)$�d��e(T�e����*��k�Y��e�
�8�)$�eצ�e��e=8��
������e��)d�e�*��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����������������������U���x7���,�x���<�x����k\�x����k\�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`).��l���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�O��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�L,�t�L�t���t$! impl AsRef<[u8]> for MyRngSeed {���u#      fn as_ref(&self) -> &[u8] {���u         &self.0�L�u�L,�u�L�u���u$! impl AsMut<[u8]> for MyRngSeed {���v+(     fn as_mut(&mut self) -> &mut [u8] {���v         &mut self.0�L�v�L,�v�L�v���v  impl SeedableRng for MyRng {���w     type Seed = MyRngSeed;��w���w0-     fn from_seed(seed: MyRngSeed) -> MyRng {���x         MyRng(seed)�L�x�L,�x�L<�x�O$�x�����'��x+( 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�����U��
��U�l$�����(���)& 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��ŠJG all purposes. *Changing* the implementation of this function should be����'$ considered a value-breaking change.�l���&�U��
��U�,ҋ���$,�����&��Ɍ
��,Œ��.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����n�U�������nd���n<��
��U�n�m�!#���E���?< Create a new PRNG seeded from a potentially fallible `Rng`.�Π��֠FC See [`from_rng`][SeedableRng::from_rng] docs for more information.�d�����)��������������������q�aX�U�)���
��š����)��ȎT��
��U�)�m��"$ħ���?< 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�\���U��
��U���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()`.�������,��|����������������������q�aX�U�5��
��U���5�ƯZW Adapter that enables reading through a [`io::Read`](std::io::Read) from a [`RngCore`].����t�� # Examples����l���I�ư # 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();�<���OtIJ���
�����ײȎTڲ�)����������T��
�����)�T��
����Ӳnpc,������)���D8��
�������ȎT���*������C$������*��k��������������������q�aX�.�����
�"�f+�c����
�8�)$���]��,���h��h��i�����)�����Y���F8��
�������ȎT���*��_���B������*��^�^��^��[�^�]�[����e�S���^����
�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`].��#���##����##����$'�PD�&�
���\�&�\d�&�$��@(�n����')��&<�&���$d�&,�&���.\�'��'EB The *core* part of the RNG, implementing the `generate` function.�$�'���$(�$�
���\���$2�\���F�$���+.eg���$�$��$�
��$,�$��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'�PT�O�
�����O�\d�O�$�kn�K����)+��O<�O����d�O,�O���.|�OL�O��\�P��PE��$�P���$(�N�
�������,�\���7�$�����TV���$�$��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�<��O��'$ 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();�<�
�O�
���
30 [getrandom]: https://crates.io/crates/getrandom�	,��&�=nt�z�G�_(���&(
��&���!#���&�&�
��
�,� ��&(��&��_�!#�����&��^�^��^��[�^�]�[����e�S���^���
�,���8��&���!#�&��
�
�� Error type of [`OsRng`]�
<��&s8Skخ-{���5�&
3i�5�&��
���i���5(��&���!#���&�&���
�,� ��&(��&��_�!#�����&��^�^��^��[�^�]�[����e�S���^���
�,���H��&�&���46����&��&���
�L�����&���!�(*-/8�9=?���&�Y���
�����XMJ Wrapper around [`TryRngCore`] implementation which implements [`RngCore`]���Y%" by panicking on potential errors.�
L�Z�
���\�Z��T�Z�(�gDB
�����$�(�S�$�(��
��$ik,�Z���$(�Y�
���\��\*����(��_���MO�����(��^�^��^��[�^�]�[����e�S���^��Y�
��$,�Y��8�Y�
���\���$3����(�����Y[�(��
��$(�Y�
���\8��,��=�(���VYRT���(�(��Y�
��$,�Y �Y�
���\���$3����(���Y �
���\)��$3��5�(���NQY�`beg8�quw���(�Y��Y�
��$�YH�Y!�
���\�����(��AE!�
���\-��$�$t��<�(���UX������(��(��Y�
��$L�Y�� �Y"�
���\��`�$3����(��`�Y[����(���Y�����Y������`��
��$�$�Y�������]M���^%��L�^���
������^ȎT�^�)�l�_�)a�gQ3�#����)�)�wئ�)��
���)�^������ئ(�^#���
�������_�)@Ȏ��)��_��	ik�����)��^�^��^��[�^�]�[����e�S���^��^�
���),�^��^$���
��������)AȎ�)�����*-m�tvy{8�������)�Y��^�
���)�^H�^%���
������Ȏ��)gj��UY%���
�����2��)�)�ȎA�)�����`c������)��)��^�
���)L�^�.  �^&���
������`�)AȎ�)��`���<?mo����)���Y���� �^�������`���
���)��$�^��,�//
�)L�)�1Z2 3%�3*�70"455:�=@�6E�7J9O�RUL�R[2:`�:e;j�;o<tu<y�g�=��>��B��D���zG����M��%��O��*�nP�AQ�BS���_T���mU�����3V�gY�Z��Z���kl+j�0ei$i*�h0�27�\=*\CE[I�GP�YVY\�Wb1WhVn�Pu�S{_S��R��\��c��O�pO�
O��e��f��9��3�2���
)����ٶ��'�������^)
V\�%*+01�7�=�C!IOU�[�
a�	g�m�sy��������������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��������"����z����zK	�xJ���QsUe�i���?l~�٫~]`STb��O>����]��K?s��s�2N�����Gb��j}<,.aYӯK����ud���c�6�/=��:A6ȓHJ\�?9����nZ�?�z�G�L��)��CD"��T'�~n�ԣL���q�=�;�l�O���#����_Bk�����w7�#ͅ�8�a~�`[V1�8��*��#MNZ���r���莗�9��怺Z����o�C*�] ����ną��"9j��U*u��O��_ZzR��^���Yq�|}>J�*���X�%XE�M����%hq�m#��I	o�&K�6�N���w�G���'/��K�Y�r�[ٖU�6�h���f��1*����[����G�wb�	���s˻�ֈ�tK����pd��#�
)���S�pxP{hD�f��JK�բ&O�{�,�߁]&��k6�C�sFa�?�,�}GA�:%����WIl��'5왩�;�D��Lv>�F���-pd�4�5#�yv�є���N`2,awpԬ��w*c�%��̒}��@�l*v�e�
.�R�.XT���hd�(v-B}����uz�S�_5��,��Ӆm%P	b�;	�TI�X41��a��.b��U���y���Y�����,�[ɑQ�ȴ51j�D^1~�V��"ۏ�i⧞�Ş��������3A�	����y>�k���:c'� !��^��_N�H'I)G6n��rl1�i�{GŹՍ��|ց9!���:u��H��u��CX;��=/=9K�nN�R�:��+`�m�NٸD��w*%��>���%�c������ũ��āJ��Pc�Mz��ODM��_�?���9����gERX��D�T��lf�	��X�A��7��<1�I�!0H�V�]��J�hDU�8�&q�2t�E��F��W�~�m�6z�&vXw������V�QU\���a���Gb����>�}��&�C���ܣ��Fȿ��`(�W��0�ݽ�nBo#�?	��h�Ɉ8����"V�,�L�V�)J\��?��+ F�X�W���A���W��̫���o;K[T�|�h�D(.�cN[�VJ�.�3���YL;(�Z-a��h@��殼C��h]ڲ�q�y�Q(�HD�0b��;��?��`e���z��}��rIL�mJI�Η�A�:�2��ȋF��پtq�!0~���7ԛ��3Kѷwa���"ڨxXj`(�+�o�]"�S�u0{��Pc5�|��{���E (̏�*����oB��&n�-]�}�zyL�����K��վ���[y�]�'rdCkk�Xv2�%��â�C�g��IS�ėex����N�ܧr&z�Rԏsi�.mat�X����<���K��6����eI��	׬ך��5>��E���WO������zmͪ��C�Y膸w"5g:�Gϥ |�<)�s`X6���*���^�:�jA>��BVԗ�ȱ���]N��ʥC��@4ⷭ��Fu$��H���A�}F�]�H�3����An5��祪�sـ��#�A��=���y�b�(�]�c(>�j��P�S�f��C�U~��|��W�0��Q=�nwaÅ���ۦD�^Zț�(>���Ԡ���u���(��`}H�U_�ΧY?��:Ac)X����-���)�I�~�s�=�R0�c��Ö��`N���%3�eϕj�}%[��%,�|#}*%�4�#�����79sfS�N/�e��<D�ú&�+ZhF�wS�r5�ٜ�[�3T�QI]WX��o�%&9OxB�CJ?xW��b�y���� qS�����y��͈�?�[
��>�����>�fJ'��tVu(��$�
I�8�'��B�.��I���C��+����1�@��և�-����:�гI( 㜌cB��嬧���m�:�ѧc�K�C��,��c�ƚ�Hz��o��,�%�:y*�p�����+�B[� �E��w�L���L�t�m��mW�Z���cI��UE���ޗ\�"�w�N���kB:N[ȉ�*�䁯I/Oi؍�e�_�'�w���`H=��g*����Ը��-��Y4r�NJ-Q�����ZM�t�ȗ�&284��N3�چ�Z��3�𤉸j^�Hl?V��rY�<Q����3�L��8��Q��s��_�\�.�2�'9�y���W�!!ކh�j���v���h4E��s��X��6cn�OB�RE�����V,��܂�@B�pria��&<@�xa��ϧ��`��dHr�HnIJq�.(��$2��=�}+��vd��3�IAJ�t?���:�)w���\���\1:
���xql�
ƅb����c�W���]D�u�3��yW}b���0>��R���1	�x�mZ��5�X8r<��c���e�h�spH8��w�;�ç̅ M��ʉ�]8Y����»��#ܩϞ[=���ڋPg�j�_E�WE�NF���o�ٱ,�Šj�
4���m�'R� S�PWC�(����H�
���:��T4,g�Оf�o򅟠��K
;�wʞ�1\����N�K1�`��wV�Ÿ��C�&Ю�qj��Ycއ0�^[W�4
xX`�d��VjUG_�&�؏�D=�j�vJ$Y�
��W��S]`cKO��y!�8��Zt�z��������`���Q���eU��G!�l4A���a*<��ʠ{��9�c
*�|^59�9x�����P����Q"۟~eo��%	��+�Ђb�5k��gw*��ͅ;��Yߗ+t�מ@b��N�EH_���ힴ`z�����$e�s����<xO�tv�l�ݧ����8�&�CI�lȍ��:���"Y,b	��:�[F=���|�Su��<��?�����h�9�wd�`V>��L=��f�Gq+�J(AtN� C:�+3Z������4{�Y�>��#P�w�&��=3��������=cԾ�M���(��\n;�m��F/�n�'�e����Cg�#Qy�������w�X�0�
���m�l�m�7�6�-%$Oav�UmC��>��Bqze'[4�]���������<����`r�k���Q�@Y�`�%��	��"$��;��Ɉ����JY�إ�T��u,h��|��h��p�pB��)gX�@���Af#\5�om�嫎���]���[=��B�0�� ���������/s�*�*bE�z���*�*�E�z������*�-GE7jDw�zs����*�-RE<jOw�z~���T�U�V�W�� �(�A�T�{.!)+\+,�,�-*.R/�/]0�1u293�3�3<4�4D5�5�5 6`6�6�7/8y8(9j9�9L:�:);�;�;-<�<==a=�= >�>7
?B�BE�E�E�EFKF�F�F�F!G�G0"H�M�O�P�QAReST�T�T�U�UJV^V�X�X�XYZ�Z�NZXj�k�
l�n&ozo�o=p`w�w{m{!|�|�}~~?
�r���L���������5�����M�������=�����g��
�W3�A������������G���(�L������X�!��(�B����`����������V��!�0�NǞǴ���}ț���[�tɒ������������X�v�����b��gΞ���A�����U�����V���V�<�U���r���S���ք���� }(�*�-�A]E:R�TAjZw�z�����*�-.y/p3z58]8O9`;�<%?_EF�F�T�UVV�X�ZDj�nZw�w�z8������~���
��������9�����w�;��@�����������������h���G�J���z���������������������












&%%%� |(K*J+�+M,t-?.30f182�2�34�4�5�556u6
7�8�9:y:�:�;�;B<=/=v=�=5>�A]B^DE�E�EF`F�F�F6G~M�OAPQ9RS.T�T�T�U&X�X�X�Y4Z
j�k�lXn;o�o�owUzY{�{C|}~�~�v���a��5�J����<�R����_�,�ě[�������Ԧ"�[���-���n����,����9�����ɿ�i����a�������7�]���)����j����u�z�������v���>����%���V!\!_!f!j!p!w!�(�(�())
)))+W+,�,�-.%.M/�/�/Y0�1p243�3�3�384�4?5�5�5�56[6�6�6�7�78*8g8t8#9X9e9�9H:�:$;y;�;�;(<�<�<�<=\=�=>>�>�>&?3?�A�A�B�B�D�D�D�DE�E�E�EF8FFF�F�F�F�FG�G�G+H�M�O�P�P�PfQsQ�Q<R`S{T�T�T�T�T�T�U�UFVYV�X�X�XzYZ�Z�Z�Z�Z�ZTj�k�l�no"ovo�o9p[w�w�w{h{|�|�}y~:�a�n���G����„τ$�1���مH����܆��ˈш,�9����b�����R�;��ן����������A�ˬ��&�F���������E�R�����$�>�����
�[��������ڿ�G�T����+�LǙǯ���xș���!�W�oɐ�����ʼ�����S�t��˶������S�`��V�eΙ�����<�{ϊ�����PЂБ�����QћѪ�F�S���'�-�:�PӦӪӹ�m�������NՎՔգ�����������֐ןףש׮״׺׿��������������������������	�����#�(�-�2�7�=�B�H�M�S�X�^�c�h�m�s�x�~؃؉؏ؙؔ؞أتذضؼ�����������������������
��� �&�,�3�:�@�F�L�S�Z�`�f�l�t�zقيِ٘٠٦٬ٲٸپ���������������������������$�*�0�6�<�B�H�N�Y!c!m!t!x(�()))))G*F+�+8,p-.*.�/0Q1#2�2�3�3�3�4�5�5�5 6`6�6�6�78i8y8Z9�9�9d:�:{;�;�;-<�<==a=�=> >�>(?�A�AHB�BID�DE�E�EFKF�F�F!G�GiMrO,P�P�PhQ5R�RT�T�T�T�T�UX�X�XYZ�Z�Zj�kslCno&ozo�ow�wQzU{z{.|}�}�~{c�r���L��1�Ą&�5���ޅ�����'�ψ.�=������[�(���E�������������E�{���(�����G�X������(������5�������ſ�I�V����N�������$�[��������f̹����U�b�Y�g�����~�����������Ѭ�H�r���+�/�<��ӭӻ��������՗����������֓עק׬ײ׸׽�������������������������������!�&�+�0�5�;�@�F�K�Q�V�\�a�f�k�q�v�|؁؇؍ؒؗ؜ءاحسع������������������������
����#�)�0�7�=�C�I�P�W�]�c�i�q�w�هٍٕٝ٣٩ٯٵٻ������������������������	����!�'�-�3�9�?�E�K�Q�M�O^*S+,�,�-�-".3/g/�/F0�1^23N3�3�3&4�4!5Y5�5�56H6�6�6�7�7�7'8D8q8	9=9b9�96:�:
;>;�;�;<y<�<�<=I=�=�=>�>�>?0?�B�B�D�D�D�D�DE�E�EF$FAFyF�F�F�F
G~G�GH�M�OrP�P�PEQpQ~QFScT�TqU�U7VRV|X�X�XkYZ�Z�Zj�k�l�n�nobo�opwww�wjzc{|�|�}U~&�$�k���3�ځ��J���̄�.�q�Ņ+�d�����솚���6�z�ԉ@�����t�6�ٛo�ǟ����
�ݥ�d���4�����#�8�o���o�ְ#�O��˹��7���ź�G�P�������Կ�� �Q�����$�<LjǪ���aȉȿ���K�hɀ�����ʥ�����<�d��ˁ������3�]���,�bΌι���(�\χϪ���<�pЎЮ���7�qѧ��Pқ��7�H�}���LԚ���4�{�����
�^֬���Nל�L*K+�+x,u-�-.'/T/�/>0�1R23;3�3�34M45F5�5�5�5@6�6�6�7�7�7!818k8�8*9\9�9*:�:�:+;};�;
<m<�<�<=A=�=�=>�>�>�>*?wB�B�D�D�D�D�D
E�E�E�EF;FqF�F�F�FGgG�G�G�M�O[P�P�P.QjQvQ<SYT�TeU�U+VLVtX�X�X_Y�Y�Z�Zj�k�l�n�noUo�opwbw�wVzZ{�{�|�}L~��e�w�&�́��6���Ƅք(�d����O�����憄�؈0�m�lj3�i���`�-�Лf���ڟ����
�G���+������/�N���a����I�ޱ�����.������9�;�������˿��K������6�zǤǺ�Sȃȶ���B�_�zɾ����ɗ�����.�^˾�l�������W����\΃Τ����Gρϕ���.�[ЈЙ���)�\ѡ���J�y�	�1�?�[���>�x���&�Y��ի��P֊���1ז��,.7/w/J0�1b23n3�3*4�4%5x5�56L6�6�78[8
9M9�9::�:;^;�;<}<�<=M=�=�=�>#?�B�D�D�D�D�EF(FCF}F�F�F�FG�GH�M�O�P�PWQ�QHSeT�TuU�U;VTV�X�X�XoYZ�Z�Z�k�l�n�ngo�o!p�w
|�|�}j~+�6���8�߁�����v�ʅ0�|�ֆ����ىE���ޛt�ɟ�������9�ìȮ=���t�۰7��۹�<�����L�a�����ٿ��9�����)�>ǍǬ���fȋ�����R�mɂ�����ʪ�����A�f��˒����E���H�����-�x���A����<э�-����MӘ�QԷ�9Ջ���c���p�N,@.40g192�2�34�4�566v67�8�9:z:�:�;�;C<0=w=�=6>^B_D�EbF�F8G�M�OBPQS/T�T�U'X�X�Y5Z�k�lYn<o�o�o�{D|}~�~���b�	�K�����=�S������\�������#�\�����o��� �:�j����b�������9���*����k���v�{������w������&��O,A.50h1:2�2�34�4�576x6
7�8�9:{:�:�;�;D<1=x=�=8>_B`D�EbF�F9G�M�OCPQS/T�T�U'X�X�Y5Z�k�lZn=o�o�o�{E|}~�~���c�
�L�����@�U���
�ƛ]�����צ$�]���q�!�k�b������9���*���˭���w�|�������������(��<,.."0U1'2�2�3�3<4�4�5$6d6�6}8�9�9h:�:�;�;1<=e=�=$>LBMD�EOF�F%G�GmMvO0PQST�T�UX�X�Y#Z�kwlGn*o~o�o~{2|}~�~��P���9����+�A�������J�����æ�J�����]��X�	�P�����&����������d�i���������������������OYblv?IS]gs}�����������	(5�������	&gq|�$.�/�3�5�6�7)8s8d9�;�<>�>2?�B�D�G�PrQ!o�wm�΄0����8������%���Q��	���S���_�d�������������R�9��������������J��=��2����I��<��1�
�TP�����B��5��*���F��9��.���,>/Q0�1i2%3�314,56S6�6�79�9A:�:;�;!<�<T=�=>�>�B�D�E�FG�G�M�O�P^QLSiTyU?V�XsYZ�Z�k�l�noo�o)p|�|�}r~3�@�����~���8�������R���|�������A�������T�����k�������F�������5�I�D�9�_�G�q���t*�-8E(j4wuzc�~�� v(E*n-�-R/93D5�7/8(9);�<�>�AE�E�F3RT�T�UJV�X�Zj�nw`wOz
�/���ԄM���ֈg�Y�y�L������3�	���4��Ǹ�����x���������\�d�����E���Y���Z�p�Y�v�W�������o����������ݹc�����������������.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��r���������*�*+.}/~//�/s3w3{35�5�5�5�5^8S9T9U9V9c;g;k;�<�<�<�<�<aE�EF
F�F�F�T�UWV�X�X�X�XGjHjIj�noo�z�z�z�z�z�z�z@�E�J�O����چ�����3�4�5�6�7�8���;��=�B�������
���j�I�L�����������������Y����$�1$�� ��D�D�DEF�F�P�Q�+�-.�/3�58c8W9o;�<%?�EF�F�T�UXV�X�ZJjoZw�w�zT������~�ۆ���9���@���B�G����������������o�N�Q���z�������������������"% #&!$�u�u�	<���jcore_intrinsics�����"����[�&�CP�
2�}����fmt_helpers_for_derive��_�_��"����`�o�%��
/�M�����_�_��"��������j`����&���Z����"������@V���R~
$�Yu�����derive_clone_copy�����"����uåG�	>�
�|u�=����`�`��"������׫�����x��O\�������"�����p���/�t��}�J���������"����N��*
n�	�������_�_��"�����KA.T�=g���$O����"������NF)�� ~
$�L��������"������,m��ad�
>�e�f\��	derive_eq�������"�����SΏByѳt
#���������"����U����
0��
I}�������"����J;[�<�����^%_����"����9�?'�Ǿ5��{�����������"�����%+����tԕ���������"����q�� �|��~	$����������"�����ïWJ2��y�y���"�����X��W��t
�s��������"�����M#
�����N�����"�����'u�NM6��
Ԇ
�������"������Ӯ�̹�
<�Y�������"����jLJRެL����,����"������N�4�
e������������"����Xj�֡����Y;�����"���� ���1�8��~6�����_�_��"�����1K�%6��{p���`�`��"����d���YfHt	�7��������"����W|(8�-c�S?MM+M_M#MGMgM/MOMoM7MWMMCMcM'MKMkM3MSMsM;M[MwM�Q�O�Q^N|R�R�P%QBOySYQyO�M�Q�O�MRP*NJRUP�N�R�P�NS�POHS�M�Q�ORN�RS�PIQiO�S~Q�O�M�QPN:REPNNlRyP�N�R�P�N8SQ2OiS�4ODHT ���c)X����Bqze'���dHr�H ria���ܣ��F��8�a~V��rY�����$c�9�c
*�|X�|}>J�$
���m~	�xJ���t?���%u���(���$Oav�Um��@���Af�,g�ОfAG�wb�	1z�Rԏs��oB���t�E��F�w���Yq#�6z�&vymZ��5/�tq�!0~��l4A���aV���Q"۟[��"$���߁]&��k9�ȗ�&284�E (̏�y�b�(�]��Zț�(>����+`�mf5��,���L�:y*�p��a��.b�P���-���X41��O\�.�2�':�+3Z��q�Y4r��	�L��8���X8r<��0����>�}}��@�l*F�jA>���܂�@B�p)��CD"�6�C�sF:f��C�U~���ۦD�^���N�EH_�a���H�
?�j�vJ$YNcԾ�M��w���]N��ʾ�y�Q(�H�~]`STb��R�.XT�H�V�QU\��{0�^[W�4
Jkk�Xv2�����JY�إ�kB:N[ȉ�ȓHJ\�?9Ö��`N���(�Z-a��h����Gb��j	���c�6��yW}b���,�N/�e���xX`�d��Kn�'�e���zpxP{hD�f6��hd�(I����nZ�?)G6n��r^WX��o�%&�%hq�'D��Lv>�?_�'�w���9OxB���}�zyL���:�)w���&k��gw*��^v-B}��J�W�~�mx�I�~�s����āJ��k�+�Ђb�5]5왩�;�>�,�L�V�)���A���Wˈ&n�-]�C�Y膸w�sـ��#����mW�Z��X��6cn�c�W���]*[�VJ�.ی��1	�x�.���Q���T�� ���Ô�`��wF�l�m�7��<Q����3BVԗ�ȱ�C��>�����7ԛ���&�CI�lȍg��ힴ`zb`�%��	������P�Z�
)���S�5i⧞�W�h���f.�����=v���K��6�nBo#�?	���Y����R��o��,�%�nIJq�.(!�����<����_Bk���f�	��X�q��"�����%,�|#}��NٸD�gD�0b��;ϒ��怺Z�<D�ú&�+��y�������»��#6�Su��<��k��A�:�2�`V>��L=�n�m��F/�y��N3�چ
��pd��#4��*��#M�y!�8��Q	����y>Z�Ս��|ց`a�?�,�};�J�hDUu�̫���o;���zmͪ����*���^�:�
ƅb���)C�&Ю�qHZt�z����R*<��ʠ{�W�=�;�l�Oȿ��`(��/=��:A6
��h]ڲ�q����"ڨxX��X����<��C��,����3����A�A��=�����8�'��B����-���������V,�[4�]���߄z����zK@��殼C��U���y�Q�C��@�w�L���L����_N�H'I]��j^�Hl?��1\��D`H=��gϥ |�<)ι�-Q���
K����ud>�����>����ZM�t�}+��vd#�[=��B�0��WIl��'=�z�G�L��K[T�|�h��?��`e�V�Ÿ��GD�u�3�+��rIL���Ԡ�����*�����mJI�Ζ?�[
���i�.mat��m%P	b�Mv�e�
.�G��cI��U�O�{�,8̅ M���4]`cKO�P�T��u�t�m�,h��|č�[ٖU�6-9!���:a*������6�-%�3���YL;�Ԭ��w*D��]8Y��5����`S1�I�!0s����eIӲ��gERXo�ϧ��`'� !��^\ą��"9j� V��"ۏ�Vu(��$�
I�GA�:%���<�w*%��>h�8�&q�2v�Cg�#Qy{j`(�+�o���N`2,awpCF���-pd@�D(.�cN�o�ٱ,�Š;��$2��="�Z��3��j�
4��<�4�5#�A�ȴ51T��w7�#�A��7��<r=/=9K�d���9��n"5g:�G����79sfS�spH8�2�Y�>��#s]��K?s�J\��?��+�1�@����㜌cB����S�PWC�(�>&��=3���u[� �E�����ȋF��٘j�_E�WE9u��H��bm#��I	o�(�g��IS��&K�6�)���K��զ:�гI( ��s�2N��"�w�N�����P�S����3�IAJ�$�_ZzR��^"nN�R�:e;	�TIN��D�T��lp�`[V1�8]"�S�u0�*���X�%%u��CX;��c`}H�U_����,�[ɑQS����[y�]�H�V�]�tj�D^1~�UCJ?xW��b��OB�RE�}<,.aYӯ
\���\1:
'{��Pc5��'rdC�:�ѧc�K�c���e�h�1ܩϞ[=��7!!ކh�j�ڋPg�8�m�'R� =j��YcއIVjUG_�&L�
��W��SO�(��\n;x�w�X�0�}�Q�@Y��#\5�om�����s˻�2ֈ�tK��3���v���N���w�G*ėex���&<@�xa�Pc�Mz��Ol���xql�(��|��W�j�}%[���?l~�٫c(>�j���WO���ƵnwaÅ���NF���:�0��Q=�����:��T4@=�R0�c���3T�QI]��o򅟠�B��JK�բ&7����+�B�xO�tv�l�eJ(AtN� Cp������|/Oi؍�e����莗�9��h�Ɉ8�����"V����%�c��i}��&�C��~Q��s��_�yv�є��BP�w�t�9�wd�m�}F�]�H����'/+��1*����/[����0c�ƚ�Hz��a���Gb|r5�ٜ�[���w�;�ç3+t�מ@b`����4{r F�X�W��%��â�C���z��}��h��p��pB��)gX��Y?��:A���y��͈����f�Gq+�o�����/s����#�����uz�S�_K|��{�Ǡ�	׬ך��.��I���C�*�䁯IXw�����z�U*u��O�!�5>��E��$��H���A�W��0�ݽ��Y,b	��:�i3Kѷwa�ZhF�wS���;��Ɉ��l1�i�{G�_�����]���e�s����<dh4E��s��fJ'��tV���N�K1E4ⷭ��Fu�^59�9xYŞ����X[F=���|jNZ���rͅ;��Yߗ_DM��_�?m����ũjXE�M����&�ԣL���q�k���:c[��N�ܧr&��%3�eϕ�E���ޗ\�QsUe�i����+�����9�y���W�eU��G!�Uݧ����8�fc�%��̒E?�����hl��`r�k���n5��祪���T'�~ns`X6����؏�D=M�-���)�0>��R�-��K�Y�r,�O>������:���"h����3A�Y�K
;�w�C*%�4�#���] ����n qS���������m�����o�C*�~eo��%	�\N$_���#?,
��>�6qwy63�3��9CL8P0O�5y|6iVgy�nc���G���s��v8H#?/}�,��@e��$��wyMR�F���x45bA~km3����9����vsb[qG�F6|�~�_e.;Y7.mM~a;v���X�C��F=���{��	��?TCHM
>��WgYvr]C����&T@>*RG8mJ���'F8,} `Gmo!{ Q$3g2d:2���T4u�����G[&NZglWx*ek:Ab�j�l0i�,0/\U$R��~82'E��RNfV#)M]krD\?l"\Hzrj@GT{/$6Ng(._e1oWr!%Ck5|C)|Qr�lv�m#\'~+]U5cY|Rr.w!g!BY+vD	]$
[T=1h1=	8, oW9K/c_!
�_VO FlvH^����b~�@��+:�����	m>9�K�m�81��JOseg^I4Je���7�@��F9i�Ce�}7VqIN$_���#?,
��>�^/home/palash/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/rand_core-0.9.5/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@&(@BA��S�%��$�B��s^/home/palash/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/rand_core-0.9.5/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*�����N�=*��\/home/palash/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/rand_core-0.9.5/src/lib.rs� �g��kѬpf>������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!
('!('bD�h̚��Hp�#�[/home/palash/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/rand_core-0.9.5/src/os.rs� ��v�3�������}��s2ECAA$F'@QF+OE;"NJI,LN%`(-44'-&&K;%E+GROMT/=*=*O/++1�ʘ��5�|�|����[/home/palash/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/rand_core-0.9.5/src/le.rs� Ca���a��3Z/iݔ�@2ECAA$L :
A
4)B>:
A
4)B>I%$$9$$%,,9,=�=��p�ב��7�"qy0o�qXs�vxx86_64-unknown-linux-gnu�l-_I-�SW�*[��#J	rand_core�-375cbdf48043d588���"���������	������������������j�����������������`�������������������������������������������������jj�����!�'c'uu�Grust-end-file