📄 librand_core-d10a081d67980ee0.rmeta
/home/palash/git/iron_learn/target/debug/deps/librand_core-d10a081d67980ee0.rmeta
Language: rmeta • Lines: 1770
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���T5֪Wd��T�n�|-ca376ebfba62ea13���v�
їG}�/x$YxD-e720413b8edafa0a��	�-����1ؔ=��G��-e6f0229506bd0299�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|���������������*j��<J�
�_�$|�$��$��$�������������lͥ�$�_�$|�$��$��$PP������F*���g���&�_�&��&�������i�fu������&�_�&���&��&�&��&�_�&��&��&��&|���'��$��$�_������k��@�C��$��(��(��(��(���(��(�(�`�(|�(��(�_������`��`}��
��
��)���)��)�)�`�)|������`��`}��
8�)��*������Y!uH��A�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}}~���)��wn`g��Z#
��$�)�(4�$;B��^0
��)�+������`��`}��
�)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`���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���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��G*' 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������k��@�C��U�����U,�H
��U$�H��I/��I,) Wrap RNG with the [`UnwrapMut`] wrapper.�T�I���U������`��`}��
��U��I�
��U$�I��JU��J30 Convert an [`RngCore`] to a [`RngReadAdapter`].�d�J���U�����Y!uH��A���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��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���U��X%��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��)������`��`}��
��)��������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�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����������������������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`).��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�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���w  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�����'��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�����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��NJJG all purposes. *Changing* the implementation of this function should be����'$ considered a value-breaking change.�lŋ�&�U��
��U�,׋���$,�����&��Ό
��,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����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();�<���Otɲ���
�����ܲȎT߲�)���������Y!uH��A���)Y!uH��A��ز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�&�$�*j��<J���')��&<�&���$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�$�lͥ����)+��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�	,��&�F*���g��_(���&(
��&���!#���&�&�
��
�,� ��&(��&��_�!#�����&��^�^��^��[�^�]�[����e�S���^���
�,���8��&���!#�&��
�
�� Error type of [`OsRng`]�
<��&�fu�������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�(k��@�C����$�(�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�� �Z"�
���\��`�$3����(��`�Y[����(���Y�����Z������`��
��$�$�Z�������]M���^%��L�^���
������_ȎT�_�)�l�_�)`��`}��
����)�)�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������E�
�󉱵�>ԁ7������!>��ލk�C�8����<������Rq�)WP
j�9Bu~g4�!�w8e�)�>��r]�|#���p�͝m��m8Ģ�+��m~A8q���A��f�:U
����k��[V�Wj#�L++��ī��pd{��������Fq!A�KT0X����5WI��)%w��UB+���h:��Q���'��qXA�;�m�tNI�n���9��>r��Q�0�y6��,���K�u��`��w��@�54u�<Y��N��.��x�x�&�;�*��"���ޢZ�
U���֡�@y2 P�]��W������8]�tZ��(���<��f��y�f�Â8,
�������ɮ�&P��=��a���z�9��J������*�����c���Ȗ�pQ]O�d������vR���:B�4[��5:L}s��j�.O ��������\FF���f���L�B8RL`�:�WY7��C��!�w�j�����2K`I��@
��
q��8�	~[�� �s�����9%�����E��=#q}(^͔�%�u(�P� #�Z:!O6�HJ�T�K��.���� ��˘����֏�^�ce=ѥ���ŸA��c%��H=��|3�Gt}{�t�����g��U�+�_k�:�!8,:�.�D��se���w��F��;x��1���чKc�iWM'>��d��O�B�IF���r��pH�6ʦI<�"<��v`f�T���dcP۱���)���&/~�z�����r`#�EL�����"%E�ӛ��8�xm��\�W��p&<��2��W�A�]6?�t|�
���c���1�����YOu2�ݒ\^���}w�$�dXO�^{��@���W�_�t�G��K_I�O�w�~���Ѻ^$x�������Ձ�7��>̜c�6FGYL
P��_ΰ�{"�)E�Ӊ�qV�v.M��X�����!��p��x�l%��P��]w�25Kc�������a80`ߦB��0
��#.�Q@SG_Q2�i,�������DOD9����]�f�}0FWlM=dA$2y�Y��L�;Qm����r{��s[���C���
yxk��›��J{1������\@z��/%��h"��m�7�z�q����µC:��Ǎ1�/i
�*
��0Y�wqV/� �F&y(�jM��K�;%���@�v��k�l}(e����&�댓�+W���l��A���J����G�[�����9D��F�0A��@m���579�`xdN�}HF:�K
�RE���w̘Ux�z�*`����N��(���3�s(6�҇���v���i0,��u�Д֚<{�b��4�U{������H�b��,�#�w��9	S�@�[�3�*)�8��(��"�e\�Ƨ���R)|��-�4屾�|����\�����$0�}�Ѕ��Z�c/IK�$O|f�`�§�+L�J-�v�X��߰�A0�0�
/�I��c�ϔ��ݱR��n�o��e%[=ʛ�g �<&O֩��4�K���|Aơ%5"���6�<5A���(O��0�j4d�"�a�ڷ���W2*�O�Κ�˧�Q�SC�
c����i�$���#LmĐ/��|zY�Ԙ]:E\Qu�����U]BqQ��o��Rp��s,%����/�H�l�B�蝹��@wG��<�P@�R�ǹ���t?~���σ���)����$a/���c�uEw��T�L�n�@�����X?�'qL�-a�eӁY.��ɻ���ot�b&�����s)����ϐB������,����R�Ԃ�I�
���k�2p���p�2��AX|E�����Q����C�.�B)U
n6R�qk�5jD:~��D����dIu͔�]��Ð̆`7��x<St��g���v�u��y6�����%7���(gy�F]���(�n�٣�"\T��)G�M��z�.��Qto��G��E�e̴?�NK�^�ѽ|;�hq�VA����2�5�/���Ỽ2�3e�W,�X�]:�8\fg|�=��}�*�|�ũ��CQ�4'Fđ�o�����p	L�˜�	���*肳�rȎ�/X�;��wK����e�d���Mhgʪ	�!�L-���8�x��=Pa��8۞����Z�)��`�	硥?ZwIm�yj��F��%��$��n�`�7�v���y�1�����	B�U���)w7�`����;L���g�H��zE�c�`��Cn������?*�;���s>��lC:��E�Lxy�@������6u���IO	k�j�'0�~�WrBP2�9q��
.���~��Ot�UȦ�%�O��Ra�q��ȅh��VZ�Y�M|^���J��+UXr*�!O�G+D�cu��uY�"w+^78��g"��M�p��A��wЮ�:�i1,q
�G�ݒ�3(qJAI�/��O�����H+㮘��K��BS�Y_�"��z0��mA6�Ο�O�-<��>�~B,^��֕�P��C��6���u���.N-"߷����g��Ƒ'�������|��9ݩ�J3��l�� ���W ��1�!�Ƴ=�!74��O��7S63�������k{���Q�-i�&6�d��6�����T�L���B&)z稃=/��B���dZC��/}܉;�q[��5�Y/$I3˚Ro�6JsV���к�ϻ��@׌ڡ7t�i�F:R�k�
<X�)�g�w�P�,ʏ�)�l�^d��A�@;�r,��W*���!�e���G?&�
�=ib�8-v���gX�&����͒Xq�r4"$��O+ɡ��p}y_�˂�\�Fg(���:B�g&�C܎+eg�|M0�����4�H��؄E(/���ܛ�~G�����6�C����sh������C�@ۭ�@K�p�h��O���~���q�Ƣ��b!�/]����3+��;�� 12"��M�>!���,xg��h�G2#pm�:��ˬ�+����(�V�32�3���Z¨�������Sn)
����|��=>��zF��d��
k�V�z*����|V>���~I�BeklcQ��wL�,|���N��^g[3�O�$�]��`��{3W�N�t��2��'~��(��F�ބJ���@�y�p�LO<��a����8-c�[���-H�d$�@�D�r�D��s›����]�Ϯ��g7��Eb�����]��*�*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���E�
�󉱵�t	��J�m�
2�}����fmt_helpers_for_derive��_�_E�
�󉱵Cu��I�~�
/�M�����_�_E�
�󉱵�Z���-�
���&���Z��E�
�󉱵��j�TP��~
$�Yu�����derive_clone_copy���E�
�󉱵��g��$�
�|u�=����`�`E�
�󉱵`-��]S���x��O\�����E�
�󉱵�_d�K�t��}�J�������E�
�󉱵{��@E�=��	�������_�_E�
�󉱵��n�F����$O��E�
�󉱵��:9����~
$�L������E�
�󉱵-*U�2�f)�
>�e�f\��	derive_eq�����E�
�󉱵�' \��Tt
#�������E�
�󉱵�dG����
I}�����E�
�󉱵�!�)�
����^%_��E�
�󉱵�#Xq�_��{���������E�
�󉱵�A�؅�tԕ�������E�
�󉱵`# ��]��~	$��������E�
�󉱵y�
�7rP5�y�y�E�
�󉱵�X��W��t
�s������E�
�󉱵�|6�3_?���N���E�
�󉱵L�dDbl��
Ԇ
�����E�
�󉱵���\��@�
<�Y�����E�
�󉱵�;)ʍ7���,��E�
�󉱵{n)U���
e����������E�
�󉱵m�u\�OL���Y;���E�
�󉱵��������~6�����_�_E�
�󉱵f;�_p�����{p���`�`E�
�󉱵W�Z�V�8t	�7������E�
�󉱵4�Ƙ�ò��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 ����b&������@����"��k{��LZ�)���>��r]	#.�Q@SG����6�C��n�ݒ�6�3+��;��u�N��^g�M0����j6�d��6�Ne�����Y��L�;������H��b��,�#����6�<�|�=��}�	�!�L-�s>��lC �a80`��J����G���A��w̘Ux���+L�J-��O��0���P@�R�����gX�&b��"��$~[�� �s�A��� I�{"�)Ewʛ�g �<&�M=dA$2y����/%�땏�M��z����G?&�
�`�r4"$�d|��=>������|��"w+^781�wL�,|����.N-"A�N��.��x"ӁY.���B��0
������1���i[��5:L}6:!O6�HJG�>ԁ7���%5"��]:�8\fg�µC:��ǒ���8�x=�!74I�i�F:R�kY�
<X�)Z�Fq!A�KT2��AX|E�^d��A�@;]�G+D�c/r`#�EL��a��\FF��9�B�IF��YN�}HF:�K��6ʦI<�"[�G��E�e��[3�O�$��.��Qto��L�B8RL`�;�ݱR��n��h��VZ�Y+���W�_�n ���W ��G
k�V�z*�3���Z¨�|�[V����U]BqQ�b!�/]���t<��v`f�T\O|f�`�§���n�`�7�]O�d��3!�w8e�)�]�f��St��g�����h:�:B�g&�Ch��sh���o-H�d$��B)U
n6R���@K�p�h�q�z�q����Y�wqV/��Rp��s,%���m�tNI��YOu2��j����vR�4i1,q
�G5@�D�r�D�� �F&y(�j�O�^{��@m��R)|��-�2��'~���zF��d�ʀj4d�"��)�8��(����L�n���}�Ѕ���}w�$�dXlC�
c�������O��7SJv.M��X��y��ī��pdXr*�!O.0X����2p���p��]�tZ��(�)"�e\�Ƨ��"\T��)G������	B�)�����w7�`����c�`��CnH+㮘��K9?*�;���J3��l��Fi�$���#� 12"��M�v�U���)J���@�y��O+ɡ��pe��֏�^�cK��o���]6?�tgxk��›��[������+W���l�B���dZR>!���,xw���C�@ۭp$a/���c���579�`xd�+�_k�:�!R��f�:U
��Ѻ^$xq�J������0��]w�25K}��v����p��x�{A0�0�
/��e�W,�X����<�\�W�d|����\�ǹ���t?�:��E�Lxy!�s(6�҇�8,
����,1�!�ƳH���/�H�l��	���*�	��˘��J>̜ct�ɻ���ot��
.���~�'@�����ϐB�'0�~�W%����͒Xqc}y_�˂�\f|zY�Ԙ]:�=ib�8-va�O���~��r�q�Ƣ��s�|#���p�
������Sn})
����~]��`��{3��]�Ϯ����ޢZ�
U�%������R�\^���k�O�w�~�p�9D��F����e�d��c������~%7������֡�@y2&K`I��@
�?�f���:���@�vΘs��j�.O 763�����K��<��f�*uEw��T�*�����c�1�B�蝹��
���k���H=��|3�N��:B�45K���|A��`��w��@ �1���V�
q��8�	@���8�xm�c�����\@z�z�*`���Ԧ������8(B,^��֕�>�54u�<Y�!g��U�Q�-<��>�~=�|��9ݩE�p��A�3��=/��Q�g�w�P�,[������Dʏ�)�l�\�Q���������8��!�e�_܎+eg�|i�p�LO<ˍ
�*
��0�>r��Q�0O֩��4��j�����2>��s[���V>���~I̓�v�u���5A���(�
P��_ΰvOD9������6u���#�����Q���%�O��)C��!�w�=��g"��M2�P� #�ZF���"%E��b���&/~�_�F��%��$���B&)z�P'qL�-a�e�8,:�.�D�S2�5�/��"��z0��m;�Q�-i�&M�Ỽ2�3C��/}܉S�CQ�4'F��qk�5j�E(/���lՁ�7��sД֚<{�b�0A��@m���3(qJAI�/7w��UB+�����C�.��
�RE����(gy�F]����6FGYLuܛ�~G��mZ�c/IK�$�Y/$I3˚U�?�NK�^��Wj#�L++Ro�6JsV�V(��F�ބ�q�)WP
j���=Pa������T�LO'��qXA�;:�WY7��<����X?��-c�[��� P�]��W'�M|^��,���dc]'>��d��OX�o��e%[=����dIu��BeklcQ���Mhg�
IO	k�j�$��=#q}(^D�Ot�U�(W�N�t���v���y�1���zE���J{1��Gt}{�tO9Bu~g4�}0FWl�_Q2�i,���k�l}(�pm�:���y5WI��)%��=��a��.N��(���3��������r��+��m~����R�(�V�32�{�y�f�Â+������D��T�K��.�HA8q���A
t�G��K_IoQm����r{�l%��P|�r��pHZLmĐ/����se���wT��Ȗ�pQ2��rȎ�/X
�;��wK�u��uY0�����$0��p&<��2�e�W2*�O���;�q[��5�T��к�ϻ�W�4�H��؄k�a����8�`�	硥?��F��;x�U�w��9	S�D:~��D������k�e=ѥ���L�ލk�C�8�����PI��c�ϔ����o�����s›����P��C��?g7��Eb�����ɮ�&P-���K�u���W�A�f��+����z�Ԃ�I��͔�%�u(E�Fg(���g����ECh"��m�7�v�X��߰��͝m��m8�&�댓����!�za�ڷ�����]��Ð��4屾���(�n�٣��|�
���ch�y6��,��˧�Q�S�y6�������x�&�;�*#ѽ|;�hq�8۞������O�����8�n���9������9%�B�p	L�˜��Ƒ'CM��K�;%�g��h�G2#xA6�Ο�O<�@�[�3�*�~���σ���߷����gBrBP2�9q�&;L���g�HŸA��c%�M�@׌ڡ7tX�Ӊ�qV�x��4�U{���*�|�ũ��C���
y��i0,��uΪ�1�/i�����]���@wG��<�̆`7��x<��r,��W*�^�VA������s)��E\Qu���������чKc�iWMWP۱���)^E�
�󉱵{��������z�9�/������,�Ra�q���*�J��+U-�wЮ�:�4ZwIm�yj�z�����`��BS�Y_�:6���u��@����!>�}W.#w
D3�vK�H�H
!o#q
K]cPD"AJJO
iJH<^y���>%
3c<5��*"1~a%f����Z�|j7��,xxI�(y�*SB�^Z!~D��x�]L~I	nW#B5� �e����F[I,j)���q2'vTPW#!aQ7%oB<8��1:M6
<V����Y���2��<n%`zz,	U<qg6Az1:V
+8.;^LJ7PF��){FxYlYZgZ*uT{nc 
K=jzB	?TYKBN>e���U������FfLX	@~S&-�iJs����2Np6Db5rr����1���`LR�Mv]MAzB�~X��&���SHr�+F����'fTe��^�����/��d|���qW�:@6Deo��
?)Y"I $=$|;(,WXg}|BA)DsLEVt^WJ(lpA�"ZbI
Hm1)8z{l_N'{3d$��T���:����mBw<g4M���UG[D��&ZUd*fZf|rA}W.#w
D3�vK�H�^/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@&(@BAi����j�	��%ʘ�^/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*	0O�U.��IJ[�LJ�\/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!
('!('��/�
��:K�3�[/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��p�E��ܛvJ7|�[/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,�QfM/ksf� t̙)0o�qXs�vxx86_64-unknown-linux-gnu�w������
<�~c<!	rand_core�-d10a081d67980ee0�E�
�󉱵�����	������������������j�����������������`�������������������������������������������������jj�����!�'c'uu�Grust-end-file