📄 libcrossbeam_utils-30ff13b172e89a74.rmeta
/home/palash/git/iron_learn/target/debug/deps/libcrossbeam_utils-30ff13b172e89a74.rmeta
Language: rmeta • Lines: 5740
rust
�^#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�	primitive�L�
crossbeam_loom�t�	tests�,��$��impl_consume�d�
�\��,����\�aarch64�L�����.��<��<ۏ������	

�seq_lock�SeqLock�&�(�
(optimistic_read�(
validate_read�(write�SeqLockWriteGuard�-lock�-�0�2�atomic_cell�4444444444	4
444
444
AtomicCell�E�E�4H�4J�4L�4N�4P�P�
P
into_inner�Pis_lock_free�P�Pswap�P�4X�Xtake�4[�[�	4^�^compare_and_swap�^�^�bF�4d�d�4�4impl_arithmetic�4	i	fetch_and�i
fetch_nand�ifetch_or�i	fetch_xor�4
n�n>4q�q�4t�t�4
can_transmute�wA�wB�4�zLEN�zL�zLOCKS�}}4
AtomicUnit��
4
��	����
��4atomic_is_lock_free���4���4���4atomic_swap���4atomic_compare_exchange_weak���consume���
AtomicConsume��Val��load_consume����impl_atomic������cache_padded����������������
�����������������������������backoff�����
SPIN_LIMIT��YIELD_LIMIT��Backoff��step����
�reset��spin��snooze��is_completed������>��	once_lock�����OnceLock����once��������������
�get_or_init����
initialize����	�
get_unchecked�������parker�����������	�
��Parker��unparker��_marker����>���
�park��park_timeout��
park_deadline����into_raw��from_raw�����Unparker��inner�����unpark������������EMPTY��PARKED��NOTIFIED��Inner������cvar��	�����sharded_lock�����������	�
���
���������������
NUM_SHARDS��Shard����write_guard��ShardedLock����shards��������������������
�	������is_poisoned��get_mut��try_read��read��	try_write���
������LockedPlaceholder��
�������>������	���
�����������������
������������������������������
current_index��	�
ThreadIndices��mapping��	free_list��
next_index��thread_indices��THREAD_INDICES��init��Registration����	thread_id�����
wait_group�������	WaitGroup�����������>���
�wait�����������������������������	�
���	SharedVec����SharedOption����scope��'env����R��AbortOnPanic��
����	�	�	�Scope���%�handles���"������%�spawn��'scope������builder���&������&��%��
�
stack_size���&�����	�������ScopedJoinHandle���&���handle���
��������join��	������������as_pthread_t��into_pthread_t������4�	fetch_add��	fetch_sub����������	fetch_max��	fetch_min�4��)��)����������*��*4��)��)����������*��*4��)��)����������*��*4��)��)����������*��*4��)��)����������*��*4��)��)����������*��*4��)��)����������*��*4��)��)����������*��*4��)��)����������*��*4��)��)����������*��*4��)��)����������*��*�����������������������������������������	�����
������������CachePadded�����������	���
���>�����������
����������ShardedLockReadGuard��'a������_guard����ShardedLockWriteGuard���3�������REGISTRATION��__rust_std_internal_init_fn���	�__RUST_STD_INTERNAL_VAL��	��5�ScopedThreadBuilder���&��%��%��&���&��%��*8+838U8V8W8Z8]8`8a8b8f8j8k8l8m8v8v8v8�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�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�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�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��--�
.�/���x�s%N���EE�G�4)~���L!���D���D���D��D��D��D�D�_�D��Y�YU�Yv��Xb�?e0J������b���D�XU�t~�-����[��D�XP���jO�������]���D�X;
�h�|f�����V���D�X�4��q:�����^���D�X��H�fE(�����W���D�X�$vR@|a������_���D�X!�)�F�s�����X���D�X���|&k�������`���D�X���ÖQo|�����Y���D�X�:��)���Y�Y\�Yp��X=nۼk�p�D����2�����u��� �D��J��J�`�J���J��J�J��J���J��J��J��J�_�J��J�D�_�J�_�������d���s���L����������d!���p`	�D���L��L�������������Gj��I��M�_�M��������{�4������N�_�N��N�����������PX�z����D��N���N���N�_�N�_����t�4�JIr���N��N�D����3�����4����nM���譎8���P�_�P�_�P����4���������m8�P��P�_�P�_�P��P��P����"�����"�IP�	V����#����ܨُ�)a��R��R�_�R�����%8:�k�Bjs����&��&���"�����ˊ���8�_�S�_���5��%���&�0��1��I�&�%�����(��(���
��������lN�<p8�P��T�'�T�_�T2-dE����������HE������������JE����������������LE��NE��nE����������qE����tE��������������������������Y�������������������������������Y��������������������������������������-�	/��=����(�_
�Y�^��`�������_�'��
��
���>��8
&��)��j&&�
'�~#�Ež��$��E�D��&���
"��
��D3D�Y
`|�
�-����MaybeUninit���uninit�������B1}-�hn�D�����Q
E�D�����R�Dl��D��-�-
UnsafeCell��-��*��]����]n�]m�Dm�[�Ԍ#
	Č#
��D$�#T��"N$�"���,���	
���
��/���	
���
��/p��	���.���	
���
��`,���	
���
��`,j��	���]"(��w����$��_�[]�[2��[��[�D��C�[���{�[,��%67�t߇	
d߇
)(�· 
�·
��[Q-����A|���2�����u��� �[����[�[_���{�[~%�[07;{�[LEN���{�[%�[07;{�[LEN����Qi��Q

���Q
w�D����'ĝ�{
�iRX��R$����R
��R28���Qi��Q

���Q
w�D�F06��R	����R	
���R�h39���Qi
��Q

���Q
w�D�G06	��R
V_��R


U��R
�h4:
���Qi��Q

���Q
w�D�H
06��R��R
��R�h4:���Qi��Q

���Q
w�D�I
06��R����R
���R�h4:,�����X������P���R9���R9���R9���R9���R9$Ԏ�hO�h
���QG�g��ha]���QG�F/�h�����QG�G��hTP���QG�H"�h�����QG�I�_a�W�o�	�o
�ox�o�M�2��2
��D�2�2���2V�Jt�2�D�2�Dft�5Z	�B��rT"6�v	
�r�]��rp"10�\�
L�
�6'��&��
��
��D+8
?|��]IZ���j
��D�������L$��5�5Once��5��5=d0ݞh.��^��]�\�A
�[��A��[,�A$0��A
�[��A��[,�A$1��B
�[��A��[,�A$2��	
�[�	��[,�	$8�����a
���a
��Q����a�����������������;t�������������������;t����Q�Q�y�����t�b�������3#;Z:��`�Q���tbY��y�y_����a
���a
��Q17����a

��y�z�h0�y	��a����a���!�a

��|�|�h$�y	��!aP	��$a����a��y ��|�|�h���|�|�h�T_��������	�2\����<������30 Miscellaneous tools for concurrent programming.�4�t8 ## Atomics�G��K<9 * [`AtomicCell`], a thread-safe mutable memory location.���YV * [`AtomicConsume`], for reading from primitive atomic types with "consume" ordering.����� ## Thread synchronization�����-* * [`Parker`], a thread parking primitive.���OL * [`ShardedLock`], a sharded reader-writer lock with fast concurrent reads.���PM * [`WaitGroup`], for synchronizing the beginning or end of some computation.�����
 ## Utilities�����96 * [`Backoff`], for exponential backoff in spin loops.���VS * [`CachePadded`], for padding and aligning a value to the length of a cache line.���QN * [`scope`], for spawning threads that borrow local variables from the stack.�����&# [`AtomicCell`]: atomic::AtomicCell���,) [`AtomicConsume`]: atomic::AtomicConsume�� [`Parker`]: sync::Parker���&# [`ShardedLock`]: sync::ShardedLock���" [`WaitGroup`]: sync::WaitGroup�� [`scope`]: thread::scope�����8�$���8�|�$�8�$���8�$���8warnings�D�$�8rust_2018_idioms���$�8�,���8�L�$�8unused_assignments���$�8unused_variables���������������2�������!��	l�L���$�	spin_loop�L������$�I��5Condvar�<��;�,��;��4��t��Z
�D���UT��Y
WL���VD���[\��^L���]D���b\���XL���_L���YL���`L�����.�����������������������*~�oq��*egVX�� ��z}mpt��
 Atomic types.�
��<
�~�SY
�4�4��T�	
E��l�

��d�
D�
&-mem�
� �$(�X"b\.��#�D;��$�<R�%�L_�1S4GI8:tK,�w<��[~#�Ež��'��,�&&�Ed��[)*+,��!��[((�d��5|����[����������������;t����[(�(
*$���8l����[�[(�	(
+$�	stamp�,�	��
7,�
�[�D((
,$�
��#���D��x�s%N�./3��$�--��d�,�--�[���D1��,��D�h00
1$����D3�3��$����D�h2�2
3$�|�
\�	
Ewz��������$�46�D���47�2\��48��]T��-49���4:���[4;��$��4=ManuallyDrop�d���4>�\\���4?
RefUnwindSafe�l���4A
UnwindSafe�T���4B���4C�
<�&4D�_0&4w��
���L��L����,��������(��{}L�o��bĸ��*' A thread-safe mutable memory location.�����]Z This type is equivalent to [`Cell`], except it can also be shared among multiple threads.�����`] Operations on `AtomicCell`s use atomic instructions whenever possible, and synchronize using���]Z global locks otherwise. You can call [`AtomicCell::<T>::is_lock_free()`] to check whether���.+ atomic instructions or locks will be used.�����]Z Atomic loads use the [`Acquire`] ordering and atomic stores use the [`Release`] ordering.����� [`Cell`]: std::cell::Cell���A> [`AtomicCell::<T>::is_lock_free()`]: AtomicCell::is_lock_free���52 [`Acquire`]: std::sync::atomic::Ordering::Acquire���52 [`Release`]: std::sync::atomic::Ordering::Release�T��FF���D��D)~���L!Gf��!,�4EE�^��+�II̟����D$��D��+�KK̟���$��D��$�MM̟��D	��'�OO̟��D	���QQ̟��DRSTUVW��)��52 Creates a new atomic cell initialized with `val`.���t� # Examples���<� ```���,) use crossbeam_utils::atomic::AtomicCell;����� let a = AtomicCell::new(7);�<�����D�DPP
R�D�&#���85 Consumes the atomic and returns the contained value.�����UR This is safe because passing `self` by value guarantees that no other threads are���+( concurrently accessing the atomic data.���t�����<�����,ɢ������ܶ let v = a.into_inner();����� assert_eq!(v, 7);�<���T��D�DPP
S�D$���"#��FC Returns `true` if operations on values of this type are lock-free.�����VS If the compiler or the platform doesn't support the necessary atomic instructions,���\Y `AtomicCell<T>` will use global locks for every potentially concurrent atomic operation.���t�����<�����,ɢ����UR // This type is internally represented as `AtomicUsize` so we can just use atomic���! // operations provided by it.���:7 assert_eq!(AtomicCell::<usize>::is_lock_free(), true);�����'$ // A wrapper struct around `isize`.���
 struct Foo {���     bar: isize,�,� }���IF // `AtomicCell<Foo>` will be internally represented as `AtomicIsize`.���85 assert_eq!(AtomicCell::<Foo>::is_lock_free(), true);�����;8 // Operations on zero-sized types are always lock-free.��� 74 assert_eq!(AtomicCell::<()>::is_lock_free(), true);�� ��� \Y // Very large types cannot be represented as any of the standard atomic types, so atomic���!LI // operations on them will have to use global locks for synchronization.���"@= assert_eq!(AtomicCell::<[u8; 1000]>::is_lock_free(), false);�<�"��d�"PP
T�D��%��#&# Stores `val` into the atomic cell.��#�t�#���#�<�$����$,ɢ�$���$���$���$ assert_eq!(a.load(), 7);�|�% a.store(8);��% assert_eq!(a.load(), 8);�<�%��,�%���D�D�hP�%P
U�D$�%��%��*��'EB Stores `val` into the atomic cell and returns the previous value.��'�t�(���(�<�(����(,ɢ�(���(���)��)��) assert_eq!(a.swap(8), 7);���)��<�)��$�*���D�D�DP�*P
V�D$�*��*��,��*EB Returns a raw pointer to the underlying data in this atomic cell.��+�t�+���+�<�+����+,ɢ�,���, let a = AtomicCell::new(5);��,�̾, let ptr = a.as_ptr();�<�,��4�,���D�DP�-P
W�D$�-��-�YY̟�-��D<�-�DZ��0��-RO Takes the value of the atomic cell, leaving `Default::default()` in its place.��.�t�.���.�<�.����.,ɢ�/���/����/ let five = a.take();��/���/ assert_eq!(five, 5);���0" assert_eq!(a.into_inner(), 0);�<�0��$�0���D�DX�0X
Z�D$�0܋1�\\̟�1��D$�1�D]��3��1'$ Loads a value from the atomic cell.��1�t�1���1�<�1����2,ɢ�2���2���2���2�<�3��$�3���D�D[�3[
]�D$�3��3 �__̟�3��$�3��D�3�D`ab$&��97��4MJ If the current value equals `current`, stores `new` into the atomic cell.��4���4^[ The return value is always the previous value. If it is equal to `current`, then the value���5
 was updated.��5�t�5���5�<�6��ܓ6 # #![allow(deprecated)]���6,ɢ�6���6 let a = AtomicCell::new(1);��7���7,) assert_eq!(a.compare_and_swap(2, 3), 1);���7 assert_eq!(a.load(), 1);��7���7,) assert_eq!(a.compare_and_swap(1, 2), 1);��8 assert_eq!(a.load(), 2);�<�8��Use `compare_exchange` instead���86��9�����D�D�D�D^�9^
`�D$�9current�<�9�
�9��?B��:M���;���;\Y The return value is a result indicating whether the new value was written and containing���<UR the previous value. On success this value is guaranteed to be equal to `current`.��=�t�=���=�<�=����=,ɢ�=���=���>���>1. assert_eq!(a.compare_exchange(2, 3), Err(1));���>���>���>0- assert_eq!(a.compare_exchange(1, 2), Ok(1));��?��<�?����?���D�D�D��������������������q�aX�D�D^�?^
a�D$�?��<�?�
�@��Gc��@LI Fetches the value, and applies a function to it that returns an optional���Ab_ new value. Returns a `Result` of `Ok(previous_value)` if the function returned `Some(_)`, else�ԭB `Err(previous_value)`.��B���Bgd Note: This may call the function multiple times if the value has been changed from other threads in���Cda the meantime, as long as the function returns `Some(_)`, but the function will have been applied���D" only once to the stored value.��D�t�D���D�\�D ```rust���E,ɢ�E���E����E1. assert_eq!(a.fetch_update(|_| None), Err(7));���F74 assert_eq!(a.fetch_update(|a| Some(a + 1)), Ok(7));���F74 assert_eq!(a.fetch_update(|a| Some(a + 1)), Ok(8));��G assert_eq!(a.load(), 9);�<�G��d�G���D���^�cc�G^�����G����D��H���������������������;t����DL�H
b�D��$�G��G����K�ee̟�K�Df�f��K$�K���D�hd�Kd
f�D$�K��O4�O�O�Y�Q�Q�Q8check�,�Q$�Q,�Q8�q�Q&�Q8��Q$�Q,�Q8�4�Q&�Q8��Q$�Q,�Q8a��Q&�Q8�,�Q$�Q,�Q8	atomic_op�L�Q&�Q8�$�Q*�Q�Q�R8�Q8�l�Q'�Q�Q,�Q8�q�Q$�Q,�Q8�4�Q�Q�Q�Q�Q�R8�R,�R8���R&�R�R,�R8�4�R%�R8,�R,�R8��L�R%�R%�R�T�T,�T8�q�T&�T8��T$�T,�T8���T&�T8�,�T$�T,�T8��L�T&�T8�$�T$�T,�T8fallback_op�\�T&�T8�$�T*�T�T�X8$�T�T�X8�4�T	�T�T�U
�T8��,�T$�T,�T8�q�T$�U8�T�U$�U,�U8���U$�U,�U8��L�U%�U8�4�U	�U�U�U�U8��,�U$�U,�U8�q�U$�U8�4�U'�U8]D�U$�U,�U8���U$�U,�U8��L�U%�U8�4�U	�U�U�V�U8��,�U$�U,�U8�q�V$�V8�4�V'�V8^L�V$�V,�V8���V$�V,�V8��L�V%�V8�4�V	�V�V�V�V8��,�V$�V,�V8�q�V$�V8�4�V'�V8_L�V$�V,�V8���V$�V,�V8��L�V%�V+�V�V�W8��V�V�W8���V�W764�$�W8�4�W	�W�W�W�W8��,�W$�W,�W8�q�W$�W8�4�W'�W8`L�W$�W,�W8���W$�W,�W8��L�W%�W8,�X,�X8��\�X%�X%�Y�Y|�Y�Y���Y�Y,�Y8�q�Y&�Y8��Y$�Y8�D�Y$�Y,�Y8example�<�Y&�Y8��Y*�Y�Y�8$�Y8�T�Y�Y,�Y8�q�Y�Y�Y��<F Increments the current value by `val` and returns the previous value.���YI<��Z<  The addition wraps on overflow.���Z#<��[<��t�[<��[<��<�[<ɢ��[,<��\+�\�\�\8��\�\,�\8��<�\<��\< assert_eq!(a.fetch_add(3), 7);���\"< assert_eq!(a.load(), 10);��]<��<�]+�]�]�]8�4�]8�]8�]8�)L�]�]�]�]8$�]$�]8��]&�],�]8�q�](�],�]8�q�]�]�_8�^8�44�^�^8�$�^�^�^8$�^ �^8�4�^�^�^8�^8�,�^ �^8�
,�^�^�^%�^8�^8�,�^�^8"4�^�^�^�^8�^
�^�^�^8$�^ �^8�4�^�^�^%�^8�_8old��_�_
�_8�,�_%�_
�_8�,�_�_8�,�_ �_8�d�_�_�_8��_%�_8���_<F Decrements the current value by `val` and returns the previous value.���`I<��`<# The subtraction wraps on overflow.���`&<��a<��t�a<��a<��<�a<ɢ��a,<��b+�b�b�b8��b�b,�b8��<�b<��b< assert_eq!(a.fetch_sub(3), 7);���b"< assert_eq!(a.load(), 4);��c<��<�c+�c�c�c8�4�c8�c8�c8�)L�c�c�d�c8$�c$�c8��c&�c,�d8�q�d(�d,�d8�q�d�d�f8�d8�44�d�d8�$�d�d�d8$�d �d8�4�d�d�d8�d8�,�d �d8�
,�d�d�d%�d8�d8�,�d�d8"4�d�d�e�d8�d
�d�d�e8$�d �d8�4�e�e�e%�e8�e8���e�e
�e8�,�e%�e
�e8�,�e�e8�,�e �e8�d�e�e�e8��e%�e8���e<K Applies bitwise "and" to the current value and returns the previous value.���fN<��f<��t�f<��g<��<�g<ɢ��g,<��g+�h�h�h8��h�h,�h8��<�h<��h< assert_eq!(a.fetch_and(3), 7);���h"< assert_eq!(a.load(), 3);���h<��<�i+�i�i�i8�4�i8�i8�i8�L�i�i�i�i8$�i$�i8��i&�i,�i8�q�i(�i,�i8�q�i�i�k8�i8�44�i�i8�$�i�i�j8$�i �j8�4�j�j�j8�j8�,�j �j8�
,�j�j�j%�j8�j8�,�j�j8"4�j�j�j�j8�j
�j�j�j8$�j �j8�4�j�j�j%�j8�j8���j�j
�j8�,�j%�j
�k8�,�k�k8��k%�k8���k<L Applies bitwise "nand" to the current value and returns the previous value.���kO<��l<��t�l<��l<��<�l<ɢ��l,<��m+�m�m�m8��m�m,�m8��<�m<��m<  assert_eq!(a.fetch_nand(3), 7);���m#<  assert_eq!(a.load(), !(7 & 3));���n#<��<�n+�n�n�n8�4�n8�n8�n8�T�o�o�o�o8$�o$�o8��o&�o,�o8�q�o(�o,�o8�q�o�o�q8�o8�44�o�o8�$�o�o�o8$�o �o8�4�o�o�o8�o8�,�o �o8�
,�o�o�o%�o8�o8�,�o�p8"4�p�p�p�p8�p
�p�p�p8$�p �p8�4�p�p�p%�p8�p8���p�p
�p8�,�p%�p
�p8�,�p�p	�p�p�p8���p�p8��p%�p8���p<J Applies bitwise "or" to the current value and returns the previous value.���qM<��q<��t�r<��r<��<�r<ɢ��r,<��r+�s�s�s8��s�s,�s8��<�s<��s< assert_eq!(a.fetch_or(16), 7);���s"< assert_eq!(a.load(), 23);���s<��<�t+�t�t�t8�4�t8�t8�t8�D�t�t�t�t8$�t$�t8��t&�t,�t8�q�t(�t,�t8�q�t�t�v8�t8�44�t�u8�$�u�u�u8$�u �u8�4�u�u�u8�u8�,�u �u8�
,�u�u�u%�u8�u8�,�u�u8"4�u�u�u�u8�u
�u�u�u8$�u �u8�4�u�u�u%�u8�u8���u�v
�v8�,�v%�v
�v8�,�v�v8��v%�v8���v<K Applies bitwise "xor" to the current value and returns the previous value.���vN<��w<��t�w<��w<��<�w<ɢ��x,<��x+�x�x�x8��x�x,�x8��<�x<��x< assert_eq!(a.fetch_xor(2), 7);���x"< assert_eq!(a.load(), 5);��y<��<�y+�y�y�y8�4�y8�y8�y8�L�z�z�z�z8$�z$�z8��z&�z,�z8�q�z(�z,�z8�q�z�z�|8�z8�44�z�z8�$�z�z�z8$�z �z8�4�z�z�z8�z8�,�z �z8�
,�z�z�z%�z8�z8�,�z�{8"4�{�{�{�{8�{
�{�{�{8$�{ �{8�4�{�{�{%�{8�{8���{�{
�{8�,�{%�{
�{8�,�{�{8��{%�{8���{<> Compares and sets the maximum of the current value and `val`,���|A<  and returns the previous value.���|#<��}<��t�}<��}<��<�}<ɢ��},<��~+�~�~�~8��~�~,�~8��<�~<��~< assert_eq!(a.fetch_max(2), 7);���~"<��<��<�+���8�4�8�8�8�*L����8$�$�8��&�,�8�q�(�,�8�q�����8��8�44����8�$������8$�� ��8�4������8��8�,�� ��8�
,��ÀĀ%ŀ8׀8�,ۀ�8"4�����8�
����8$� ��8�4������%��8��8������
��8�,��%��
��8�,����8���'Á8max�Łȁс8��Ɂ$́8�΁%ҁ8���<> Compares and sets the minimum of the current value and `val`,����A<��т#<���<��t��<���<��<��<ɢ�Ѓ,<���+������8�����,��8��<��<���< assert_eq!(a.fetch_min(2), 7);��DŽ"<�����<��<��+������8�4��8Ʌ8ͅ8�*LЅم�څ8$ۅ$߅8��&�,�8�q�(�,�8�q����8��8�44����8�$������8$�� ��8�4������8��8�,�� ��8�
,������%��8ņ8�,Ɇφ8"4ц؆��چ8ۆ
߆���8$� �8�4���%�8��8������
��8�,��%��
��8�,����8���'��8min�������8����$��8���%��8��҇%�����,��8�q��&��8���$��,��8�4��&��8�,��$��,��8��<��&��8���*������8$��8�T����,��8�q���������<���̈I<���<�����#<��<��t�<���<��<��<ɢ���,<��+������8�����,��8��<��<���<�����"<���׋<��<��+������8�4��8��8��8�)L����ʌ��8$��$��8�Ì&ƌ,Ȍ8�qɌ(̌,ό8�qЌҌ��8�4�	����,��8�q��$��8�o��$����ǎ
8��8������8"4��Ǎ��ɍ
ʍˍ�8$̍ Ѝ8�4э׍؍8ڍ
ݍ8,ލ8�4�'�,�8�4�%��8���� ��8�)L������8���$��8�D��'��8F4��$Ȏގ��8��8�44����8�$������8$�� ��8�4������8��8�,�� ��8�
,������%��8Ï8�,Ǐ͏8"4Ϗ֏�؏8ُ
ݏޏ�8$ߏ �8�4���%�8��8������
��8�,��%��
��8�,����8�,�� ��8�dΐҐ8�ϐ%Ӑ8���<�����I<���<�����&<�͒<��tݒ<���<��<��<ɢ���,<�Փ+����8���,�8��<�<���<�����"<���”<��<�+������8�4��8��8��8�)L��������8$��$��8���&��,��8�q��(��,��8�q������8�4Ε	ԕ֕��,�8�q�$�8�o�$�����
8��8������8"4����ߖ��
����ݖ8$�� ��8�4����–8Ė
ǖ8,Ȗ8�4Ζ'Ԗ,֖8�4ז%��8���� ��8�)L������8���$��8�D��'��8F4��$��ȗ�8�8�44��8�$����8$�� ��8�4������8��8�,�� ��8�
,������%��8��8�,����8"4����ؘ˜8Ø
ǘȘ֘8$ɘ ͘8�4ΘԘ՘%٘8�8������
��8�,��%��
��8�,����8�,�� ��8�d������8���%��8��י<�����N<���<��t��<���<��<��<ɢ�ț,<���+������8�����,��8��<��<���<�����"<����<��<��+������8�4��8��8ŝ8�Lȝѝ��ҝ8$ӝ$ם8�ٝ&ܝ,ޝ8�qߝ(�,�8�q����8�4��	������,��8�q��$��8�o��$����ݟ
8Ξ8��ҞԞ8"4֞ݞ��ߞ
�����8$� �8�4���8�
�8,��8�4��'��,��8�4��%��8���� ��8�L����ǟ8���$��8�D��'��8F4��$ޟ����8��8�44����8�$������8$�� ��8�4������8��8�,�� ��8�
,������%��8٠8�,ݠ�8"4�����8�
�����8$�� ��8�4������%��8��8������
��8�,��%��
ɡ8�,ʡС8�ӡ%֡8���<�����O<���<��t��<���<��<Σ<ɢ��,<���+������8�����,��8��<��<�ɤ<���٤#<�����#<��<��+ͥΥե8�4ϥ8�8�8�T�������8$��$��8���&��,��8�q��(��,��8�q����Ԫ8�4��	����ƪ,��8�q��$��8�o��$��צ��
8�8������8"4��������
������8$�� ��8�4������8��
��8,��8�4��'��,��8�4��%��8��ɧ ʧ8�T˧է�8�֧$٧8�Dۧ'�8F4�$������8��8�44����8�$��èڨ8$Ĩ Ȩ8�4ɨϨШ8Ҩ8�,ը ۨ8�
,ܨ��%�8��8�,����8"4��������8��
������8$�� ��8�4������%��8é8��ǩ˩
ͩ8�,Ω%ө
��8�,���	������8������8���%��8����<����M<���<��tͫ<��<��<��<ɢ���,<�Ŭ+լ֬�8�׬۬,ݬ8��<ެ<��<�����"<��청<��<ܭ+����8�4�8��8��8�D��������8$��$��8���&��,��8�q��(��,��8�q�����8�4��	ĮƮݲ,ܮ8�qݮ$ޮ8�o�$�����
8��8������8"4����ϯ��
����ͯ8$�� ��8�4������8��
��8,��8�4��'į,Ư8�4ǯ%Я8��� �8�D�����8���$��8�D��'��8F4��$����˲8Ѱ8�44հܰ8�$ް���8$� �8�4���8�8�,�� ��8�
,������%��8��8�,����8"4����DZ��8��
����ű8$�� ��8�4��ñı%ȱ8�8����
�8�,��%�
��8�,����8���%��8����<�����N<�ճ<��t�<���<��<��<ɢ���,<�ݴ+�����8���,��8��<��<���<�����"<���ʵ<��<�+������8�4��8��8��8�L��������8$��$��8���&��,��8�q��(��,��8�q¶Ķ��8�4ֶ	ܶ޶��,��8�q��$��8�o��$������
8��8������8"4�������
�����8$�� ·8�4÷ɷʷ8̷
Ϸ8,з8�4ַ'ܷ,޷8�4߷%�8���� ��8�L������8���$��8�D��'��8F4��$��и�8�8�44���8�$������8$�� ��8�4������8��8�,�� ��8�
,������%��8��8�,����8"4��ȹ�ʹ8˹
Ϲй޹8$ѹ չ8�4ֹܹݹ%�8��8������
��8�,��%��
��8�,����8���%��8��̺<�����A<���#<���<��t��<���<��<̼<ɢ��,<���+������8�����,��8��<��<�ǽ< assert_eq!(a.fetch_max(9), 7);��׽"<��䆾<��<��+þľ˾8�4ž8پ8ݾ8�*L�����8$�$�8��&��,��8�q��(��,��8�q������8�4��	������,��8�q��$��8�o��$��̿��
8�8����8"4�������
������8$�� ��8�4������8��
��8,��8�4��'��,��8�4��%��8���� ��8�*L������8���$��8�D��'��8F4��$������8��8�44����8�$������8$�� ��8�4������8��8�,�� ��8�
,������%��8��8�,����8"4��������8��
������8$�� ��8�4������%��8��8������
��8�,��%��
��8�,����8���'��8Ԗ������8����$��8���%��8����<�����A<����#<���<��t��<���<��<��<ɢ���,<���+������8�����,��8��<��<���<�����"<�����<��<��+������8�4��8��8��8�*L��������8$��$��8���&��,��8�q��(��,��8�q������8�4��	������,��8�q��$��8�o��$������
8��8������8"4��������
������8$�� ��8�4������8��
��8,��8�4��'��,��8�4��%��8���� ��8�*L������8���$��8�D��'��8F4��$������8��8�44����8�$������8$�� ��8�4������8��8�,�� ��8�
,������%��8��8�,����8"4��������8��
������8$�� ��8�4������%��8��8������
��8�,��%��
��8�,����8���'��8ܞ������8����$��8���%��8����%�����EE�G�4)~���L!jklm���*���NK Applies logical "and" to the current value and returns the previous value.����t�������<�������,ɢ������" let a = AtomicCell::new(true);�������(% assert_eq!(a.fetch_and(true), true);���� assert_eq!(a.load(), true);�������)& assert_eq!(a.fetch_and(false), true);����  assert_eq!(a.load(), false);�<����L������i��i
j$��������+���OL Applies logical "nand" to the current value and returns the previous value.����t�������<�������,ɢ������"��������*' assert_eq!(a.fetch_nand(false), true);������������)& assert_eq!(a.fetch_nand(true), true);���� ��������+( assert_eq!(a.fetch_nand(false), false);������<����T������i��i
k$��������)���MJ Applies logical "or" to the current value and returns the previous value.����t�������<�������,ɢ������#  let a = AtomicCell::new(false);�������)& assert_eq!(a.fetch_or(false), false);���� ��������(% assert_eq!(a.fetch_or(true), false);������<����D������i��i
l$��������*���NK Applies logical "xor" to the current value and returns the previous value.����t�������<�������,ɢ������"��������)& assert_eq!(a.fetch_xor(false), true);������������(% assert_eq!(a.fetch_xor(true), true);���� ��<����L������i��i
m$��������*�oo̟���<���Dp�p��<���Dnn
p�D���!�rr̟���Ds�s��� $���D�Dqq
s�D������7�uu̟����$���_�DT���Dv�_v*,���8�������D��^�^��^��[�^buf��[����e�S����������������������q�aX�hÅÅą��:����t��t
v�D$��������&l��4�x�yyx���`�����`��
w�`�`"$ ���(-\��$��4�[��
zaddr�$�������4�[쮇��4�e��),��4�e~ǀC�����������������������������������������������������������������������������C\2�[�2}}�[���TƊ4�g'ĝ�{
�i�.)4���g|ӊ�g������� $��4���g����������������G����F�����,^�����h����
�$��_order�4�����+,��4���g�h���h����
�$��_val�$����4ȋ���*$�4���g�h���h����
�$����$����4���������4���g�h�h������������������������q�aX�h�h�ӌ�
�$Ԍ_current�D�_new�$��_success�D��_failure�D�����)���4���̟̎�_	���=\��4���D���̟����$�
��Dsrc�"$���.d��4���D�h���̟��
��Ddst������"$���2\��4���D�D���̟á
��D��ơ�ӡ "���v���4���D�D�����̟ݧ��$������
��D�����<��
��<>��	
�F\�	
<�	
��D9�����%���DSP Trait which allows reading from primitive atomic types with "consume" ordering.�l������������� ���������L����D���$! Type returned by `load_consume`.������$��DA Loads a value from the atomic using a "consume" memory ordering.�����IF This is similar to the "acquire" ordering, except that an ordering is���LI only guaranteed with operations that "depend on" the result of the load.���GD However consume loads are usually much faster than acquire loads on���JG architectures with a weak memory model since they don't require memory��� fence instructions.�����KH The exact definition of "depend on" is a bit vague, but it works as you���JG would expect in practice since a lot of software, especially the Linux���" kernel, rely on this behavior.�����HE This is currently only implemented on ARM and AArch64, where a fence���JG can be avoided. On other architectures this will fall back to a simple�� `load(Ordering::Acquire)`.�d����������
���$�̈d�����*���
+���8�4�8�8�d����8$�(�8$�'�8����8$� �8�	$���8�D�'�8G<�%�ĭ\�����	,�8�4�&�8�,�$�,�8��&�8��*���+���8����8����8crossbeam_no_atomic���8$�8�l�8
�8�$�'�8�$�'�8�4�'�,�8�4���
8!$�8���,�8��%�8�d�	���%�+���8����8�t�8$�8�l�8
�8loom�$�'�8�$�'�8�4�'�,�8�4���
8!$�8���,�8��%�8�d�	���%�%���:���̟��J�����D��������

G��d���
�[���,���DerefMut�D&���LD�57��/,���̟�/��$�/�J��/,���̟�/��D$�/�J��0���̟�0�J��
��2(��0:7 Pads and aligns a value to the length of a cache line.��0�t�1���1�<�1����1%" use crossbeam_utils::CachePadded;��1���1+( let padded_value = CachePadded::new(1);�<�2���2�D�J��
��D�qv8��4��2 Returns the inner value.��3�t�3���3�<�3����3%���3���3+( let padded_value = CachePadded::new(7);���4*' let value = padded_value.into_inner();���4 assert_eq!(value, 7);�<�4��T�5�J�D��
��D$�5��5 ���̟�5�J�����\�54�5���D��5,�5���J��D��6�
��D$�6��6#���̟�6�J�����6!L�6���J��D��6�
��D$�6��71���̟�7��T�7�J��_���78�7�����J��^�^��^��[�^���[����e�S������7�
��D$�7��7��8"���̟�9�J�����9$�9�D�J��
��D�q�9��95���̟�9�_�Dd�9�J��_�!#��:8�:�����J��^�^��^��[�^���[����e�S������:�
��D$�:��:�� �>\�<�����$��p$,�+���<�[���:� -L6�BTH��r�]\c��r���{/, Performs exponential backoff in spin loops.�����RO Backing off in spin loops reduces contention and improves overall performance.�����c` This primitive can execute *YIELD* and *PAUSE* instructions, yield the current thread to the OS���a^ scheduler, and tell when is a good time to block the thread using a different synchronization���^[ mechanism. Each step of the back off procedure takes roughly twice as long as the previous�L� step.���t�������$! Backing off in a lock-free loop:���<�����! use crossbeam_utils::Backoff;���'$ use std::sync::atomic::AtomicUsize;���,) use std::sync::atomic::Ordering::SeqCst;�����63 fn fetch_mul(a: &AtomicUsize, b: usize) -> usize {���%"     let backoff = Backoff::new();�t�     loop {���%"         let val = a.load(SeqCst);���UR         if a.compare_exchange(val, val.wrapping_mul(b), SeqCst, SeqCst).is_ok() {���             return val;�l�
         }�܊         backoff.spin();�L�     }�,��<�������30 Waiting for an [`AtomicBool`] to become `true`:���<�����	!����	&# use std::sync::atomic::AtomicBool;���	,���	���	&# fn spin_wait(ready: &AtomicBool) {���
%����
#      while !ready.load(SeqCst) {���
         backoff.snooze();�L���,��<�������\Y Waiting for an [`AtomicBool`] to become `true` and parking the thread after a long wait.���a^ Note that whoever sets the atomic variable to `true` must notify the parked thread by calling��� [`unpark()`]:���<�����
!����
&����
,����
 use std::thread;�����*' fn blocking_wait(ready: &AtomicBool) {���%����#����'$         if backoff.is_completed() {���             thread::park();���         } else {���!             backoff.snooze();�l���L���,��<�������+( [`is_completed`]: Backoff::is_completed���.+ [`std::thread::park()`]: std::thread::park���#  [`Condvar`]: std::sync::Condvar���1. [`AtomicBool`]: std::sync::atomic::AtomicBool���-* [`unpark()`]: std::thread::Thread::unpark�<��L�d���s��|�$�����+�+p�+��*�@��n�*{�rd��L��������� Creates a new `Backoff`.���t�����<�����!������! let backoff = Backoff::new();�<�����L��
����� Resets the `Backoff`.���t�����<�����!������!���� backoff.reset();�<���,����L�h���
�$�����" Backs off in a lock-free loop.�����]Z This method should be used when we need to retry an operation because another thread made�l�
 progress.�����EB The processor may yield using the *YIELD* or *PAUSE* instruction.���t�������$����<�����!����'����,������6����%��t�����%����U������l�������L���,������  let a = AtomicUsize::new(7);���$! assert_eq!(fetch_mul(&a, 8), 7);���#  assert_eq!(a.load(SeqCst), 56);�<���$����L�h���
�$���.�� ! Backs off in a blocking loop.�� ��� XU This method should be used when we need to wait for another thread to make progress.��!���![X The processor may yield using the *YIELD* or *PAUSE* instruction and the current thread���";8 may yield by giving up a timeslice to the OS scheduler.��"���"GD In `#[no_std]` environments, this method is equivalent to [`spin`].��#���#[X If possible, use [`is_completed`] to check when it is advised to stop using backoff and���$QN block the current thread using a different synchronization mechanism instead.��$���$ [`spin`]: Backoff::spin���%+���%�t�%���%���%3���&�<�&����&!����& use std::sync::Arc;���&&����',����'����' use std::time::Duration;��(���(&����(%����(#���)��L�)��,�)��)���)1. let ready = Arc::new(AtomicBool::new(false));���* let ready2 = ready.clone();��*�ܻ* thread::spawn(move || {���*2/     thread::sleep(Duration::from_millis(100));���+#      ready2.store(true, SeqCst);�<�+ });��+���+*' assert_eq!(ready.load(SeqCst), false);���+ spin_wait(&ready);���,)& assert_eq!(ready.load(SeqCst), true);���,�� # std::thread::sleep(std::time::Duration::from_millis(500)); // wait for background threads closed: https://github.com/rust-lang/miri/issues/1371�<�-���-���-1��4�.���L�h��.�
�$�.��="��2[X Returns `true` if exponential backoff has completed and blocking the thread is advised.��3�t�3���3���3\Y Waiting for an [`AtomicBool`] to become `true` and parking the thread after a long wait:��4�<�4����4!����4����4&����5,����5����5���6���6*����6%����6#����7'����7����7����7!��l�8��L�8��,�8��8���81����9����9#  let waiter = thread::current();��9���9����:2����:#����:     waiter.unpark();�<�:���;���;*����; blocking_wait(&ready);���;)����<���<�=���=���=1��d�>���L��>�
�$�>��>�L��_���>8�>�����L��^�^��^��[�^���[����e�S������>�
�$�>��?��@�L�����@<�@�L��
����>d��&# Thread synchronization primitives.�'��+-���YO���P��$������4����D����\����3�����4�����#L���l�L����]T��-���\\������t$��5����A��2|�"��D����̟��Ld!���p`	���!#T�$�����u��!,�����^��0���̟�۴$���$��L��)���̟���$��L�����̟��L������!-\���L��
��D��S\����L����D�������������hl����h��D�
��D��$���GI��AT�����L���h�����������l����
��D��$���/1��<closure_kind>��<closure_signature>��<upvars>������D���h�h���]��$l�����L��D���
��D$������̟��L�����$����L�h���
��D$�T�4��������b\%�����4<���������Ib�5����<g�;���,p�;�����*��PhantomData�\����������D�Ó���<��Q���?��2��I-������D|�Ċz��UWCE��
�� A thread parking primitive.�����WT Conceptually, each `Parker` has an associated token which is initially not present:�����^[ * The [`park`] method blocks the current thread unless or until the token is available, at���63   which point it automatically consumes the token.�����a^ * The [`park_timeout`] and [`park_deadline`] methods work the same as [`park`], but block for���   a specified maximum time.�����b_ * The [`unpark`] method atomically makes the token available if it wasn't already. Because the���_\   token is initially absent, [`unpark`] followed by [`park`] will result in the second call��   returning immediately.�����b_ In other words, each `Parker` acts a bit like a spinlock that can be locked and unlocked using�� [`park`] and [`unpark`].���t�����<������������&# use crossbeam_utils::sync::Parker;����� let p = Parker::new();���! let u = p.unparker().clone();��	���	  // Make the token available.�|�	 u.unpark();���	30 // Wakes up immediately and consumes the token.�l�	
 p.park();��	�܁
����
2/     thread::sleep(Duration::from_millis(500));���
     u.unpark();�<�
���
���
52 // Wakes up when `u.unpark()` provides the token.�l�������<������� [`park`]: Parker::park���*' [`park_timeout`]: Parker::park_timeout���
,) [`park_deadline`]: Parker::park_deadline���
  [`unpark`]: Unparker::unpark�4�
�M��Gj��I����D�����N��<���������Rҹ��^=x�hܾ�M���M�����<��M��
�\��M����������� Creates a new `Parker`.���t�����<�����&�������<�������M��
�����@= Blocks the current thread until the token is made available.���t�����<�����&���������!������ ��|�������3��l��<���$����M�h���
�$���-��]Z Blocks the current thread until the token is made available, but only for a limited time.���t�����<��������&���Ԇ������UR // Waits for the token to become available, but will not wait longer than 500 ms.���/, p.park_timeout(Duration::from_millis(500));�<���d����MÓÓ�ēsecs��xœnanos��x�|)f�nA��h���
�$�timeout�<��� .��]Z Blocks the current thread until the token is made available, or until a certain deadline.���t�����<�����'$ use std::time::{Duration, Instant};���&���ԍ����?< let deadline = Instant::now() + Duration::from_millis(500);�����U���� p.park_deadline(deadline);�<���l� ���M�Q�Q�Q��Q��>H��ʒ����h�� �
�$� deadline�D� ��%#�� 63 Returns a reference to an associated [`Unparker`].��!���![X The returned [`Unparker`] doesn't have to be used by reference - it can also be cloned.��"�t�"���"�<�"����"&��"���"����#!���#���# ��|�#����#3��l�$�<�$���$���$����$*��D�%���M��N��%�
�$�%��(*��%+( Converts a `Parker` into a raw pointer.��&�t�&���&�<�&����&&��&���&����'" let raw = Parker::into_raw(p);���'/, # let _ = unsafe { Parker::from_raw(raw) };�<�'��D�(�M����
�this�$�(��+0��(+( Converts a raw pointer into a `Parker`.��)�d�)	 # Safety��)���)SP This method is safe to use only with pointers returned by [`Parker::into_raw`].��*�t�*���*�<�*����*&��*���*����+"ȣ��+-* let p = unsafe { Parker::from_raw(raw) };�<�+��D�,���M��
���,Ԟ-�M��_���-8�-�����M��^�^��^��[�^���[����e�S������-�
�$�-��-��.��.96 Unparks a thread parked by the associated [`Parker`].�D�.�N{�4�������.,�.����5�5I�5��4�5phantom��4�5��4榦�������������������z�.hH!�B�B�BGlobal�����I���/�N�/�Nl�/�N�����6��/>; Atomically makes the token available if it is not already.��0���0\Y This method will wake up the thread blocked on [`park`] or [`park_timeout`], if there is�D�1 any.��1�t�1���1�<�1����1����1����2&��2�Ը2����2!���2�܅3����32����3؍<�3���4���45��l�4���4���<�5���5�Ԃ6����6*��4�6���N�h��6�
�$�6��9,��7.+ Converts an `Unparker` into a raw pointer.��7�t�7���7�<�7����72/ use crossbeam_utils::sync::{Parker, Unparker};��8�ԯ8����8!����8$! let raw = Unparker::into_raw(u);���91. # let _ = unsafe { Unparker::from_raw(raw) };�<�9��D�9�N����
��$�9��>2��:.+ Converts a raw pointer into an `Unparker`.��:�d�;���;���;UR This method is safe to use only with pointers returned by [`Unparker::into_raw`].��;�t�;���<�<�<����<2��<���<����=!���=���=$Ͳ��=/, let u = unsafe { Unparker::from_raw(raw) };�<�>��D�>���N��
���>�?�N��_���?8�?�����N��^�^��^��[�^���[����e�S������?�
�$�?��?��@�N�����@,�@���N�N��@�
�$�@��A,�A��[��A4�A��[��AD�A��[d�B,�B�����z�.hH!�����B,�B����E|�B$�B����;�;��;��;�;poison��;�;data��;J��+΃���hl�B$�B����;�;���;��:�x\�^�T�B������B)$�B���������������������;t������h��B�
�$�BОD�BܳZ4�Z�����h��Z�
�$�Z��d������������Box�	����]T$	�-���<F	����X	�*����\n	�����������	����,�	���˲D�	���֖l�	������T�	����
LockResult�T�	�=��PoisonError�\�	�=��TryLockError�d�	�=��
TryLockResult�l�	�=���,�	�;���4�	�<���|�	�Q�����	�Q���$�	���ThreadId�D�	�E����	�?���D�	����2\�	����|	5�	'�4	DS	�a	�D	�܍	������'	������A	��nqSV7:��=	-0!��	�4�	��l�	��� 	Ô�	���	T�	��[d�	,�	�����������8�G=�8�G=����	$�	����<�<��<��<�<���<�<���<�L��V��h��>	\�	����-�-�]�-��*��]�������������������;t����Q�Q��Q��<�Q���<�����͹�h��!	��!	 A sharded reader-writer lock.��	���a	^ This lock is equivalent to [`RwLock`], except read operations are faster and write operations�|�	 are slower.��	���a	^ A `ShardedLock` is internally made of a list of *shards*, each being a [`RwLock`] occupying a���	b	_ single cache line. Read operations will pick one of the shards depending on the current thread���
H	E and lock it. Write operations need to lock all shards in succession.��
	���
[	X By splitting the lock into shards, concurrent read operations will in most cases choose���c	` different shards and thus update different cache lines, which is good for scalability. However,���N	K write operations need to do more work and are therefore slower than usual.��
	���
U	R The priority policy of the lock is dependent on the underlying operating system's���
]	Z implementation, and this type does not guarantee that any particular policy will be used.��	�|�	 # Poisoning��	���_	\ A `ShardedLock`, like [`RwLock`], will become poisoned on a panic. Note that it may only be���_	\ poisoned if a panic occurs while a write operation is in progress. If a panic occurs in any���2	/ read operation, the lock will not be poisoned.��	�t�	���	�<�	����+	( use crossbeam_utils::sync::ShardedLock;��	���#	  let lock = ShardedLock::new(5);��	���4	1 // Any number of read locks can be held at once.�,�	 {���&	#     let r1 = lock.read().unwrap();���&	#     let r2 = lock.read().unwrap();���	     assert_eq!(*r1, 5);���	     assert_eq!(*r2, 5);���.	+ } // Read locks are dropped at this point.��	���0	- // However, only one write lock may be held.�,�	����*	'     let mut w = lock.write().unwrap();���	
     *w += 1;�Ԭ	     assert_eq!(*w, 6);���$	! } // Write lock is dropped here.�<�	���	���!	 [`RwLock`]: std::sync::RwLock�\�	������D�	�NPX�z����� ��!	4�	������Ǿ������lf���]v
���2�����u��� �����	,�	����-�-�]�-��*��]����D��5	������	��$�	�N��<	������	��$�	۴$�	�N��-	������	�N	��0	������	�N	��	���̟�	�N��
��&	��-	* Creates a new sharded reader-writer lock.��	�t�	���	�<�	����+	���	���#	��<�	���	�D�N��
��D�,�	�	��������������D�[���h��!(	��6	3 Consumes this lock, returning the underlying data.��	�d�		 # Errors��	���_	\ This method will return an error if the lock is poisoned. A lock gets poisoned when a write���	 operation panics.��	�t�	���	�<�	����+	���	��� /	, let lock = ShardedLock::new(String::new());�,� 	���� *	'     let mut s = lock.write().unwrap();��� #	      *s = "modified".to_owned();�,�!	���!7	4 assert_eq!(lock.into_inner().unwrap(), "modified");�<�!	��T�!	�N��������������������q�aX�D�=�=���=���:�L���{��D��
��D$�"	��#	������#	�N��������)!	��$+	( Returns `true` if the lock is poisoned.��$	���$^	[ If another thread can still access the lock, it may become poisoned at any time. A `false`���%D	A result should not be trusted without additional synchronization.��%	�t�&	���&	�<�&	����&+	����&	����&	���'	���'-	* let lock = Arc::new(ShardedLock::new(0));���'	 let c_lock = lock.clone();��'	���'#	  let _ = thread::spawn(move || {���(,	)     let _lock = c_lock.write().unwrap();���(+	(     panic!(); // the lock gets poisoned�t�(	 }).join();���))	& assert_eq!(lock.is_poisoned(), true);�<�)	��\�)	���N��)	�
��D$�)	��./	��*7	4 Returns a mutable reference to the underlying data.��*	���*T	Q Since this call borrows the lock mutably, no actual locking needs to take place.��+	�d�+	���+	���+_	����,	���,	�t�,	���,	�<�-	����-+	���-	���-'	$ let mut lock = ShardedLock::new(0);���-"	 *lock.get_mut().unwrap() = 10;���.*	' assert_eq!(*lock.read().unwrap(), 10);�<�.	��<�.	���N��������������������q�aX��D�=�=���=���:�L���{�����.	�
��D$�.	��7D	��0:	7 Attempts to acquire this lock with shared read access.��1	���1]	Z If the access could not be granted at this time, an error is returned. Otherwise, a guard���2]	Z is returned which will release the shared access when it is dropped. This method does not���2Y	V provide any guarantees with respect to the ordering of whether contentious readers or���3(	% writers will acquire the lock first.��3	�d�4	���4	���4_	����5	���5	�t�5	���5	�<�5	����5+	���5	���6#	  let lock = ShardedLock::new(1);��6	�ܵ6	 match lock.try_read() {���6#	      Ok(n) => assert_eq!(*n, 1),���6!	     Err(_) => unreachable!(),�4�7	 };�<�7	��D�7	���N��������������������q�aX���3�����4����nM���譎��D�=�=�=Poisoned��=��=�=
WouldBlock�F$8]��<�����7	�
��D$�7	��I=	��?X	U Locks with shared read access, blocking the current thread until it can be acquired.��@	���@[	X The calling thread will be blocked until there are no more writers which hold the lock.���A^	[ There may be other readers currently inside the lock when this method returns. This method���A_	\ does not provide any guarantees with respect to the ordering of whether contentious readers���B+	( or writers will acquire the lock first.��C	���CF	C Returns a guard which will release the shared access when dropped.��C	�d�C	���C	���C_	����D	���D	�d�D		 # Panics��E	���EZ	W This method might panic when called if the lock is already held by the current thread.��E	�t�E	���F	�<�F	����F+	����F	����F	���G	���G-	* let lock = Arc::new(ShardedLock::new(1));���G	���G	���G!	 let n = lock.read().unwrap();���H	 assert_eq!(*n, 1);��H	�ܴH	����H	     let r = c_lock.read();���H	     assert!(r.is_ok());���I	 }).join().unwrap();�<�I	��$�I	���N��������������������q�aX���3�����4����nM���譎��D�=�=���=���:�L���{����I	�
��D$�I	��VF	��O>	; Attempts to acquire this lock with exclusive write access.��P	���P]	����Q\	Y is returned which will release the exclusive access when it is dropped. This method does���Q]	Z not provide any guarantees with respect to the ordering of whether contentious readers or���R(	���S	�d�S	���S	���S_	����T	���T	�t�T	���T	�<�T	����T+	���U	���U#	���U	���U!	����U	ր�V	���V'	$ assert!(lock.try_write().is_err());�<�V	��L�V	���N��������������������q�aX���4���������m��D�=�=�=���=��=�=��F$8]��<�Š��V	�
��D$�V	��l?	��c\	Y Locks with exclusive write access, blocking the current thread until it can be acquired.��d	���d[	����e^	����f_	����f+	���g	���gI	F Returns a guard which will release the exclusive access when dropped.��g	�d�g	���h	���h_	����h	���i	�d�i	���i	���iZ	���j	�t�j	���j	�<�j	����j+	���j	���j#	���k	���k&	# let mut n = lock.write().unwrap();�\�k	 *n = 2;��k	���k&	# assert!(lock.try_read().is_err());�<�l	��,�l	���N��������������������q�aX���4���������m��D�=�=���=���:�L���{�����l	�
��D$�l	��t:	������t	��T�t	�N��_���u8	�u	�����N��^�^��^��[�^���[����e�S������u	�
��D$�u	��u	��x	��x	��Ot�4�JIr��-)����O��y%	�O��_���y8	�y	�����O��^�^��^��[�^���[����e�S������y	�
�$�y	��y	��{+	���̟�|	�<�|	�N�����|	<�|	�N��
��D��}"	���̟�}	�N�����}	$�}	�D�N��
��D�q�}	���B	8��������P��	��P$��	�P�Ѐ5	8�������Հ	�P�����\��	4��	���P���	,��	���P��P���	�
�8�P$��	��>	8��������P�	�_�PT��	�P��_�#%���8	��	�����P��^�^��^��[�^���[����e�S�������	�
�8�P$��	���	��K	8��������	�_�Pd�	�P��_�#%���8	��	�����P��^�^��^��[�^���[����e�S�������	�
�8�P$��	�Ä	���C	8���������	��$��	�P�ه5	8�������އ	�P������	$��	���P�h���	�
�8�P$��	�Ԋ?	8�����ۛي	�T܊	�P��_����8	��	�����P��^�^��^��[�^���[����e�S�������	�
�8�P$��	���	�ˌL	8�������Ќ	��d܌	�P��_����8	��	�����P��^�^��^��[�^���[����e�S�������	�
�8�P$��	���	���6	8���������	�P�����\��	4��	���P�͎	,Ў	���P��P�֎	�
�8�P$׎	���9	8���������	�P����ُ!	L܏	���P��P��	�
�8�P$�	���#	l��	��
�,�	��������������Q�[�h�̔	lӔ	����!��!���!���!�:�!�+L:�!�+L������!	<��	�������base���.>�$��E�E�E���E��r,���H�[�G�GRandomState��Gk0���Gk1�����7�������	L��	����?�?��?���:�?�	�:$x��Lk��[����	T��	����[�Ж4	tӖ	��;�;��;��;�;���;�;���;J��+΃���
����5	t��	����������d!���p`	��C`����`�ؗ!	$ۗ	���
����	d��	��QIP�	V���dΚ	,Κ	����[���	L��	��������	�Q������	$��	���Q�h���	�
�$��	t�T����I�5����<"�;���,+�;���<�*���-[]GI46D7$���BLI Enables threads to synchronize the beginning or end of some computation.���� # Wait groups vs barriers�����PM `WaitGroup` is very similar to [`Barrier`], but there are a few differences:�����eb * [`Barrier`] needs to know the number of threads at construction, while `WaitGroup` is cloned to���   register more threads.�����_\ * A [`Barrier`] can be reused even after all threads have synchronized, while a `WaitGroup`���%"   synchronizes threads only once.�����da * All threads wait for others to reach the [`Barrier`]. With `WaitGroup`, each thread can choose���GD   to either wait for other threads or to continue without blocking.���t�����<�����)& use crossbeam_utils::sync::WaitGroup;��������� // Create a new wait group.��� let wg = WaitGroup::new();����� for _ in 0..4 {���63     // Create another reference to the wait group.��     let wg = wg.clone();�����     thread::spawn(move || {���         // Do some work.�����41         // Drop the reference to the wait group.���         drop(wg);�\�     });�,������85 // Block until all threads have finished their work.�t�	 wg.wait();���	���<�
���
���
#  [`Barrier`]: std::sync::Barrier�L��R�ܨُ�)a����,�����5�5I�5��4�5���4�5��4榦����������������- ���d�,������- ����l�$�������,�����;�;��;��;�;���;�;���;J��+΃���[Ԛ�R�����<��R��
�t�
�R������DA Creates a new wait group and returns the single reference to it.���t�����<�����)��������<�����R��
�����JG Drops this reference and waits until all other references are dropped.���t�����<�����)���������������� thread::spawn({������     move || {���>;         // Block until both threads have reached `wait()`.���         wg.wait();�L���<�������63 // Block until both threads have reached `wait()`.�t�۽�����<���$��R�h��
�$����R�����$����R�h���
�$����R����,����R�R���
�$����R��_���8������R��^�^��^��[�^���[����e�S�������
�$����� �j�j�j�j��N�j�j�j�j�j�jܗ�jt��52 Threads that can borrow variables from the stack.�6��:NK Create a scope when spawned threads need to access variables on the stack:���<�����  use crossbeam_utils::thread;����� let people = vec![���     "Alice".to_string(),���     "Bob".to_string(),��     "Carol".to_string(),�4� ];����� thread::scope(|s| {���     for person in &people {���         s.spawn(move |_| {���/,             println!("Hello, {}!", person);�|�         });�L�����
 }).unwrap();�<������� # Why scoped threads?�����KH Suppose we wanted to re-write the previous example using plain threads:����� ```compile_fail,E0597����������������������4�������! let mut threads = Vec::new();���ܭ for person in &people {���,)     threads.push(thread::spawn(move || {���+(         println!("Hello, {}!", person);�d�	     }));�,����ܹ for thread in threads {���     thread.join().unwrap();�,��<�������a^ This doesn't work because the borrow checker complains about `people` not living long enough:���\� ```text���41 error[E0597]: `people` does not live long enough�ܮ	   --> src/main.rs:12:20�D�	    |���	$! 12 |     for person in &people {���	KH    |                    ^^^^^^ borrowed value does not live long enough�<�
 ...�T�
 21 | }���
/,    | - borrowed value only lives until here�D�����FC    = note: borrowed value must be valid for the static lifetime...�<�������a^ The problem here is that spawned threads are not allowed to borrow variables on stack because���OL the compiler cannot prove they will be joined before `people` is destroyed.��
���
c` Scoped threads are a mechanism to guarantee to the compiler that spawned threads will be joined���
 before the scope ends.���� # How scoped threads work�����ZW If a variable is borrowed by a thread, the thread must complete before the variable is���^[ destroyed. Threads spawned using [`std::thread::spawn`] can only borrow variables with the���_\ `'static` lifetime because the borrow checker cannot be sure when the thread will complete.�����_\ A scope creates a clear boundary between variables outside the scope and threads inside the���b_ scope. Whenever a scope spawns a thread, it promises to join the thread before the scope ends.���b_ This way we guarantee to the borrow checker that scoped threads only live within the scope and���+( can safely access variables outside it.���� # Nesting scoped threads�����_\ Sometimes scoped threads need to spawn more threads within the same scope. This is a little���^[ tricky because argument `s` lives *inside* the invocation of `thread::scope()` and as such���)& cannot be borrowed by scoped threads:����� ```compile_fail,E0521��� ����������     s.spawn(|_| {���GD         // Not going to compile because we're trying to borrow `s`,���1.         // which lives *inside* the scope! :(���30         s.spawn(|_| println!("nested thread"));�\��<���<�������b_ Fortunately, there is a solution. Every scoped thread is passed a reference to its scope as an���<9 argument, which can be used for spawning nested threads:���<����� ����������     // Note the `|s|` here.���     s.spawn(|s| {���KH         // Yay, this works because we're using a fresh argument `s`! :)���3��\������<���4��������Ǿ�������*��io�������\����������������,��*���p���4��F��I��5���,��;���4�������?���#L�����|�-D�<���D��T�̜��������\�~l�o��`��L�����̟��5�5I�5��4�5���4�5��4榦������;�;��;��;�;���;�;���;J��+΃���?�?��?���:�?�	�:$x��Lk��D������d�����̟��5�5I�5��4�5���4�5��4榦������;�;��;��;�;���;�;���;J��+΃���������$[��-* Creates a new scope for spawning threads.�����`] All child threads that haven't been manually joined will be automatically joined just before���]Z this function invocation ends. If all joined threads have successfully completed, `Ok` is���a^ returned with the return value of `f`. If any of the joined threads has panicked, an `Err` is��� \Y returned containing errors from panicked threads. Note that if panics are implemented by���!\Y aborting the process, no error is returned; see the notes of [std::panic::catch_unwind].��"���"vs **Note:** Since Rust 1.63, this function is soft-deprecated in favor of the more efficient [`std::thread::scope`].��#�t�#���#�<�#����# ���#���# let var = vec![1, 2, 3];��#���#����$����$B?         println!("A child thread borrowing `var`: {:?}", var);�\�$���$��<�$��,�%����������������������q�aX�%���Ǿ������lf���]v�"����%����%�������%�����%��������&��&���"�����ˊ����%̿%���������%
��%������%$�%������%d�%��S8:�k�Bjs��0,����S��%�S�����&$�&���S�h��&�
�$�&�)������������������h�������&��&���"�����ˊ���D�-������������������5�5I�5��4�5���4�5��4榦������;�;��;��;�;���;�;���;J��+΃������������������;t������
JoinHandle�����I? �j

�h����hD�.�����������������݃����������������;t������Ǿ������lf���]v�"����h��2��2! A scope for spawning threads.�,�2�%���%�%��4(���ˊ������$�2��28<�2����5�5I�5��4�5���4�5��4榦������;�;��;��;�;���;�;���;J��+΃���?�?��?���:�?�	�:$x��Lk�������3T�3����R.<�4��������Rҹ��^=x�%�%�h��48���S��5�%������$�5��@�ܭ5 Spawns a scoped thread.��5���5_\ This method is similar to the [`spawn`] function in Rust's standard library. The difference���6_\ is that this thread is scoped, meaning it's guaranteed to terminate before the scope exits,���796 allowing it to reference variables outside the scope.��7���7_\ The scoped thread is passed a reference to this scope as an argument, which can be used for���8 spawning nested threads.��8���8C@ The returned [handle](ScopedJoinHandle) can be used to manually���9EB [join](ScopedJoinHandle::join) the thread before the scope exits.��:���:mj This will create a thread using default parameters of [`ScopedThreadBuilder`], if you want to specify the���:?< stack size or the name of the thread, use this API instead.��;���;! [`spawn`]: std::thread::spawn��;�d�;���<���<QN Panics if the OS fails to create a thread; use [`ScopedThreadBuilder::spawn`]���<  to recover from such errors.��=�t�=���=�<�=����= ���=���=����>"     let handle = s.spawn(|_| {���>2/         println!("A child thread is running");�t�>         42�\�>��?���?30     // Join the thread and retrieve its result.���?)&     let res = handle.join().unwrap();���?     assert_eq!(res, 42);���@��<�@��,�@���������(��(���
��������lN�<p���������4�@����@�����@�������̖A��������A����$�A���%$�A����$�A���%$�A
��%����$�@��@����������EI��BB? Creates a builder that can configure a thread before spawning.��C�t�C���C�<�C����C ���C���C����D     s.builder()���D=:         .spawn(|_| println!("A child thread is running"))���D         .unwrap();���E��<�E��<�E�������5��%���&�0��1��I��%�4�E�
��%$�E��F8���S��_���G8�G�����S��^�^��^��[�^���[����e�S������G�
�8$�G��G��Q4�&��%����T���4�Q$�Q��VH��Q%" Sets the name for the new thread.��R���R0- The name must not contain null bytes (`\0`).��R���RIF For more information about named threads, see [here][naming-threads].��S�t�S���S�<�S����S ���T use std::thread::current;��T���T����Tř��T*'         .name("my thread".to_string())���UGD         .spawn(|_| assert_eq!(current().name(), Some("my thread")))���U����U��<�V���V���V0- [naming-threads]: std::thread#naming-threads�$�V�T�F�F��F��1"`��x9�T��
��&�%$�V�
$�V��\M��W2/ Sets the size of the stack for the new thread.��X���X(% The stack size is measured in bytes.��X���XRO For more information about the stack size for threads, see [here][stack-size].��Y�t�Y���Y�<�Y����Y ���Z���Z����Zř��Z"         .stack_size(32 * 1024)���Z:7         .spawn(|_| println!("Running a child thread"))���[����[��<�[���[���[(% [stack-size]: std::thread#stack-size�T�\�T�[�T��
��&�%$�\�$�\��f���]30 Spawns a scoped thread with this configuration.��]���^_����^���_���_WT The returned handle can be used to manually join the thread before the scope exits.��_�d�_���`���`=: Unlike the [`Scope::spawn`] method, this method yields an���`A> [`io::Result`] to capture any failure to create the thread at���a the OS level.��a���a#  [`io::Result`]: std::io::Result��a�d�a���a���a@= Panics if a thread name was set and it contained null bytes.��b�t�b���b�<�b����b ���c���c����c      let handle = s.builder()���c         .spawn(|_| {���c63             println!("A child thread is running");���d             42�t�d         })���d���d���e3ؓ��e)����eŔ��f��<�f��,�f�T���������������������q�aX���(��(���
��������lN�<p�&������
�"�f+�c������������f�����f�������&��&���"�����ˊ����%̇g��������g���$�g��%$�g����$�g���%$�g
��&�%���$�f��f�	�<�l���������������������5�5I�5��4�5���4�5��4榦������;�;��;��;�;���;�;���;J��+΃������������������;t��������v/8�����ۛ�v�T	��v/8�����ۛ�v�T	��x&��v85 A handle that can be used to join its scoped thread.��w���wA> This struct is created by the [`Scope::spawn`] method and the���w*' [`ScopedThreadBuilder::spawn`] method.���x�&�����ۛ�x���(��(���
��������lN�<p�&�P�lN�<p����4�x���x,4�x�������y4�y����5�5I�5��4�5���4�5��4榦������;�;��;��;�;���;�;���;J��+΃������������������;t����P���z4�z����E�EThread��E���%��W�F���z <�z��������Rҹ��^=x�&�h��{8�����ۛ�{�T��
�ȃ&��{:7 Waits for the thread to finish and returns its result.��{���{\Y If the child thread panics, an error is returned. Note that if panics are implemented by���|\���}�d�}���}���}^[ This function may panic on some platforms if a thread attempts to join itself or otherwise���~/, may create a deadlock with joining threads.��~�t�����<����� ����������EB     let handle1 = s.spawn(|_| println!("I'm a happy thread :)"));����A>     let handle2 = s.spawn(|_| panic!("I'm a sad thread :("));�������>;     // Join the first thread and verify that it succeeded.��ˁ!     let res = handle1.join();���     assert!(res.is_ok());�������>;     // Join the second thread and verify that it panicked.��ނ!     let res = handle2.join();��     assert!(res.is_err());������<����$σ�T��������������������q�aX�P����
�8�P$ԃ$ֆ��������������P�h�P�����'���.+ Returns a handle to the underlying thread.�Ƈ�t·����<������ �������������HE     let handle = s.spawn(|_| println!("A child thread is running"));����DA     println!("The child thread ID: {:?}", handle.thread().id());��ԉ��<���4�����T�������
�8�P$��D�$���(������
JoinHandleExt�l���'��
RawPthread�TË�'�����[���2@B$&�Ջ18�����ۛڋ�T���'�'�� ���$d�����T����
�8�P$���ڎ%tݎ�T��
�8�P$����.8�����ۛ���T��_����8�������T��^�^��^��[�^���[����e�S��������
�8�P$���•���EE�G�4)~���L!�����������&�̈I��������#����p������8�������,ɢ�������let a = AtomicCell::new(7u8);���������������"���׋��8����H����������
� ���Ì���&���I��������&��͒�pݒ�����8�������,ɢՓ��������D���������"���”��8���H����������
� ��������&���N�����p�������8�����ț,ɢ������������D�����������"������8����Hȝ�����ҝ�
� ӝ�ٝ��'���O�����p�������8Σ����,ɢ������������D�����ɤ��٤#�����#��8����P���������
� ��������%��M�����pͫ����8�������,ɢŬ��׬۬����Dݬ�լ�����"�������8ܭ��@����������
� ��������&���N��ճ�p������8�������,ɢݴ��������D�����������"���ʵ��8���H����������
� ������پ&���A����#����p�������8̼����,ɢ������������D�����ǽ��׽"�������8����H��������
� ������&���A�����#����p�������8�������,ɢ������������D�����������"�������8����H����������
� ������@��EE�G�4)~���L!�|���������@��&�@̈I��@����@��#��@��p@���@���8@�����@��,ɢ@���@��@��let a = AtomicCell::new(7i8);�������@��@����@��"���@׋��8@����H@�������|�|�@���
� @���@Ì�@��&�@��I��@����@��&��@͒�p@ݒ��@���8@�����@��,ɢ@Փ��@�@�����
�@�@����@��"���@”��8@���H@�������|�|�@���
� @���@���@��&�@��N��@���p@����@���8@�����@ț,ɢ@����@��@������
�@��@����@��"���@���8@����H@ȝ�����|�|�@ҝ�
� @ӝ�@ٝ�@�'�@��O��@���p@����@���8@Σ���@�,ɢ@����@��@������
�@��@ɤ��@٤#���@��#��8@����P@������|�|�@���
� @���@���@��%�@�M��@���p@ͫ��@��8@�����@��,ɢ@Ŭ��@׬@۬����
�@լ@���@��"���@����8@ܭ��@@�������|�|�@���
� @���@���@��&�@��N��@ճ�p@���@���8@�����@��,ɢ@ݴ��@�@�����
�@��@����@��"���@ʵ��8@���H@�������|�|�@���
� @���@���@پ&�@��A���@�#�@���p@����@���8@̼���@�,ɢ@����@��@������
�@��@ǽ��@׽"���@����8@����H@������|�|�@��
� @��@��@��&�@��A���@��#�@���p@����@���8@�����@��,ɢ@����@��@������
�@��@����@��"���@����8@����H@�������|�|�@���
� @���@���q��EE�G�4)~���L!���������q��&�q̈I��q����q��#��q��pq���q���8q�����q��,ɢq���q��q��let a = AtomicCell::new(7u16);������ �q��q����q��"���q׋��8q����Hq�������q���
� q���qÌ�q��&�q��I��q����q��&��q͒�pqݒ��q���8q�����q��,ɢqՓ��q�q�����#�q�q����q��"���q”��8q���Hq�������q���
� q���q���q��&�q��N��q���pq����q���8q�����qț,ɢq����q��q������!�q��q����q��"���q���8q����Hqȝ�����qҝ�
� qӝ�qٝ�q�'�q��O��q���pq����q���8qΣ���q�,ɢq����q��q�������q��qɤ��q٤#���q��#��8q����Pq������q���
� q���q���q��%�q�M��q���pqͫ��q��8q�����q��,ɢqŬ��q׬q۬�����qլq���q��"���q����8qܭ��@q�������q���
� q���q���q��&�q��N��qճ�pq���q���8q�����q��,ɢqݴ��q�q������q��q����q��"���qʵ��8q���Hq�������q���
� q���q���qپ&�q��A���q�#�q���pq����q���8q̼���q�,ɢq����q��q�������q��qǽ��q׽"���q����8q����Hq������q��
� q��q��q��&�q��A���q��#�q���pq����q���8q�����q��,ɢq����q��q�������q��q����q��"���q����8q����Hq�������q���
� q���q������EE�G�4)~���L!������������&��̈I����������#�����p��������8���������,ɢ����������let a = AtomicCell::new(7i16);������ ������������"���׋��8�����H������������
� �����Ì����&����I����������&���͒�p�ݒ������8���������,ɢ�Փ����������P�����������"���”��8����H������������
� �����������&����N������p���������8�������ț,ɢ���������������a������������"������8�����H�ȝ������ҝ�
� �ӝ��ٝ���'����O������p���������8�Σ�����,ɢ���������������r�����ɤ���٤#������#��8�����P�����������
� �����������%���M������p�ͫ�����8���������,ɢ�Ŭ���׬�۬�������լ�������"�������8�ܭ��@������������
� �����������&����N���ճ�p��������8���������,ɢ�ݴ�����������������������"���ʵ��8����H������������
� ���������پ&����A�����#�����p���������8�̼�����,ɢ���������������������ǽ���׽"�������8�����H����������
� ���������&����A������#�����p���������8���������,ɢ����������������������������"�������8�����H������������
� �����������EE�G�4)~���L!�r������������&��̈I����������#�����p��������8���������,ɢ����������let a = AtomicCell::new(7u32);�Ӥ��� ������������"����׋��8�����H�������r�r�����
� �����Ì����&����I����������&���͒�p�ݒ������8���������,ɢ�Փ������ӤӤ�(�����������"����”��8����H�������r�r�����
� �����������&����N������p���������8�������ț,ɢ�����������ӤӤ)������������"�������8�����H�ȝ����r�r��ҝ�
� �ӝ��ٝ���'����O������p���������8�Σ�����,ɢ�����������ӤӤ)�����ɤ���٤#������#��8�����P������r�r�����
� �����������%���M������p�ͫ�����8���������,ɢ�Ŭ���׬�۬ӤӤ-)��լ�������"��������8�ܭ��@�������r�r�����
� �����������&����N���ճ�p��������8���������,ɢ�ݴ������ӤӤ>)������������"����ʵ��8����H�������r�r�����
� ���������پ&����A�����#�����p���������8�̼�����,ɢ�����������ӤӤP)�����ǽ���׽"��������8�����H������r�r����
� ���������&����A������#�����p���������8���������,ɢ�����������ӤӤb)������������"��������8�����H�������r�r�����
� �����������EE�G�4)~���L!������������&��̈I����������#�����p��������8���������,ɢ����������let a = AtomicCell::new(7i32);������ ������������"���׋��8�����H������������
� �����Ì����&����I����������&���͒�p�ݒ������8���������,ɢ�Փ�����������3�����������"����”��8����H������������
� �����������&����N������p���������8�������ț,ɢ����������������3������������"�������8�����H�ȝ������ҝ�
� �ӝ��ٝ���'����O������p���������8�Σ�����,ɢ����������������3�����ɤ���٤#������#��8�����P�����������
� �����������%���M������p�ͫ�����8���������,ɢ�Ŭ���׬�۬�����3��լ�������"�������8�ܭ��@������������
� �����������&����N���ճ�p��������8���������,ɢ�ݴ�����������3������������"����ʵ��8����H������������
� ���������پ&����A�����#�����p���������8�̼�����,ɢ����������������3�����ǽ���׽"��������8�����H����������
� ���������&����A������#�����p���������8���������,ɢ���������������4������������"��������8�����H������������
� �����������EE�G�4)~���L!������������&��̈I����������#�����p��������8���������,ɢ����������let a = AtomicCell::new(7u64);������ ������������"���׋��8�����H������������
� �����Ì����&����I����������&���͒�p�ݒ������8���������,ɢ�Փ����������N>�����������"���”��8����H������������
� �����������&����N������p���������8�������ț,ɢ���������������_>������������"������8�����H�ȝ������ҝ�
� �ӝ��ٝ���'����O������p���������8�Σ�����,ɢ���������������p>�����ɤ���٤#������#��8�����P�����������
� �����������%���M������p�ͫ�����8���������,ɢ�Ŭ���׬�۬�����>��լ�������"�������8�ܭ��@������������
� �����������&����N���ճ�p��������8���������,ɢ�ݴ�����������>������������"���ʵ��8����H������������
� ���������پ&����A�����#�����p���������8�̼�����,ɢ����������������>�����ǽ���׽"�������8�����H����������
� ���������&����A������#�����p���������8���������,ɢ����������������>������������"�������8�����H������������
� �����������	EE�G�4)~���L!������������&��̈I����������#�����p��������8���������,ɢ����������let a = AtomicCell::new(7i64);������ ������������"����׋��8�����H������������
� �����Ì����&����I����������&���͒�p�ݒ������8���������,ɢ�Փ�����������H�����������"����”��8����H������������
� �����������&����N������p���������8�������ț,ɢ���������������	I������������"�������8�����H�ȝ������ҝ�
� �ӝ��ٝ���'����O������p���������8�Σ�����,ɢ���������������I�����ɤ���٤#������#��8�����P�����������
� �����������%���M������p�ͫ�����8���������,ɢ�Ŭ���׬�۬����+I��լ�������"��������8�ܭ��@������������
� �����������&����N���ճ�p��������8���������,ɢ�ݴ����������<I������������"����ʵ��8����H������������
� ���������پ&����A�����#�����p���������8�̼�����,ɢ���������������NI�����ǽ���׽"��������8�����H����������
� ���������&����A������#�����p���������8���������,ɢ���������������`I������������"��������8�����H������������
� ����������Y
EE�G�4)~���L!�����������]&���YI����Z����Z#����[�p��[����[�8��[�����[,ɢ��\����\��\let a = AtomicCell::new(7u128);������!���\��\����\"����]��8��]��H��]�������]�
� ��]���]���c&���`I����`����`&����a�p��a����a�8��a�����a,ɢ��b����b��b����D�b���b��b����b"�����c��8��c��H��c�������c�
� ��c���c���i&���fN����f�p��f����g�8��g�����g,ɢ��g����h��h����D�h���h��h����h"�����h��8��i��H��i�������i�
� ��i���i���n'���kO����l�p��l����l�8��l�����l,ɢ��m����m��m����D�m���m��m����m#�����n#��8��n��P��o�������o�
� ��o���o���t%���qM����q�p��r����r�8��r�����r,ɢ��r����s��s����D�s���s��s����s"����s��8��t��@��t�������t�
� ��t���t���y&���vN����w�p��w����w�8��w�����x,ɢ��x����x��x����D�x���x��x����x"�����y��8��y��H��z�������z�
� ��z���z���&���|A�����|#���}�p��}����}�8��}�����},ɢ��~����~��~����D�~���~��~����~"������8����H����������
� �������Ʌ&����A����т#�����p���������8�������Ѓ,ɢ���������������D������������DŽ"��������8�����H�Ѕ������څ�
� �ۅ������YEE�G�4)~���L!�����������]&���YI����Z����Z#����[�p��[����[�8��[�����[,ɢ��\����\��\let a = AtomicCell::new(7i128);������!���\��\����\"����]��8��]��H��]�������]�
� ��]���]���c&���`I����`����`&����a�p��a����a�8��a�����a,ɢ��b����b��b����(
���b��b����b"�����c��8��c��H��c�������c�
� ��c���c���i&���fN����f�p��f����g�8��g�����g,ɢ��g����h��h����'
���h��h����h"�����h��8��i��H��i�������i�
� ��i���i���n'���kO����l�p��l����l�8��l�����l,ɢ��m����m��m����&
���m��m����m#�����n#��8��n��P��o�������o�
� ��o���o���t%���qM����q�p��r����r�8��r�����r,ɢ��r����s��s����%
���s��s����s"����s��8��t��@��t�������t�
� ��t���t���y&���vN����w�p��w����w�8��w�����x,ɢ��x����x��x����$
���x��x����x"�����y��8��y��H��z�������z�
� ��z���z���&���|A�����|#���}�p��}����}�8��}�����},ɢ��~����~��~����#
���~��~����~"������8����H����������
� �������Ʌ&����A����т#�����p���������8�������Ѓ,ɢ���������������"
����������DŽ"��������8�����H�Ѕ������څ�
� �ۅ�������EE�G�4)~���L!�[������������&��̈I����������#�����p��������8���������,ɢ���������� let a = AtomicCell::new(7usize);�â���"������������"���׋��8�����H�����ڡ�[�[�����
� �����Ì����&����I����������&���͒�p�ݒ������8���������,ɢ�Փ������ââ�g�����������"����”��8����H�����ڡ�[�[�����
� �����������&����N������p���������8�������ț,ɢ�����������ââ�g������������"�������8�����H�ȝ��ڡ�[�[��ҝ�
� �ӝ��ٝ���'����O������p���������8�Σ�����,ɢ�����������ââh�����ɤ���٤#������#��8�����P����ڡ�[�[�����
� �����������%���M������p�ͫ�����8���������,ɢ�Ŭ���׬�۬ââh��լ�������"�������8�ܭ��@�����ڡ�[�[�����
� �����������&����N���ճ�p��������8���������,ɢ�ݴ������ââ0h������������"����ʵ��8����H�����ڡ�[�[�����
� ���������پ&����A�����#�����p���������8�̼�����,ɢ�����������ââBh�����ǽ���׽"��������8�����H����ڡ�[�[����
� ���������&����A������#�����p���������8���������,ɢ�����������ââTh������������"��������8�����H�����ڡ�[�[�����
� �����������
EE�G�4)~���L!������������&��̈I����������#�����p��������8���������,ɢ���������� let a = AtomicCell::new(7isize);�����"������������"����׋��8�����H������������
� �����Ì����&����I����������&���͒�p�ݒ������8���������,ɢ�Փ���������r�����������"����”��8����H������������
� �����������&����N������p���������8�������ț,ɢ��������������r������������"�������8�����H�ȝ������ҝ�
� �ӝ��ٝ���'����O������p���������8�Σ�����,ɢ��������������r�����ɤ���٤#������#��8�����P�����������
� �����������%���M������p�ͫ�����8���������,ɢ�Ŭ���׬�۬���r��լ�������"��������8�ܭ��@������������
� �����������&����N���ճ�p��������8���������,ɢ�ݴ���������r������������"����ʵ��8����H������������
� ���������پ&����A�����#�����p���������8�̼�����,ɢ��������������r�����ǽ���׽"��������8�����H����������
� ���������&����A������#�����p���������8���������,ɢ�������������s������������"��������8�����H������������
� ����������2�E�����@���������#`�����E�E�����
� �����2�E�����@�������[���#`�����E�E�����
� �����2�F�����@���������#`�����F�F�����
� �����2�F�����@���������#`�����F�F�����
� �����2�G�����@�������|���#`�����G�G�����
� �����2�G�����@���������#`�����G�G�����
� �����2�H�����@���������#`�����H�H�����
� �����2�H�����@�������r���#`�����H�H�����
� �����2�H�����@���������#`�����H�H�����
� �����2 �I�����@���������#`�����I�I�����
� �����2!�I�����@���������#`�����I�I�����
� �����#`�����J�J�����
��D ��̑/�2:ôm��qa^ In concurrent programming, sometimes it is desirable to make sure commonly accessed pieces of���`] data are not placed into the same cache line. Updating an atomic value invalidates the whole���a^ cache line it belongs to, which makes the next access to the same cache line slower for other���^[ CPU cores. Use `CachePadded` to ensure updating one piece of data doesn't invalidate other���
 cached data.���Ċ # Size and alignment�����NK Cache lines are assumed to be N bytes long, depending on the architecture:�����1. * On x86-64, aarch64, and powerpc64, N = 128.���74 * On arm, mips, mips64, sparc, and hexagon, N = 32.��� * On m68k, N = 16.��� * On s390x, N = 256.�� * On all others, N = 64.�����_\ Note that N is just a reasonable guess and is not guaranteed to match the actual cache line���[X length of the machine the program is running on. On modern Intel architectures, spatial���c` prefetcher is pulling pairs of 64-byte cache lines at a time, so we pessimistically assume that���#  cache lines are 128 bytes long.�����`] The size of `CachePadded<T>` is the smallest multiple of N bytes large enough to accommodate���	 a value of type `T`.��	���	YV The alignment of `CachePadded<T>` is the maximum of N bytes and the alignment of `T`.��
�t�
���
���
 Alignment and padding:���<�����%������?< let array = [CachePadded::new(1i8), CachePadded::new(2i8)];���1. let addr1 = &*array[0] as *const i8 as usize;���1. let addr2 = &*array[1] as *const i8 as usize;�����! assert!(addr2 - addr1 >= 32);��
 assert_eq!(addr1 % 32, 0);���
 assert_eq!(addr2 % 32, 0);�<�
���
���
^[ When building a concurrent queue with a head and a tail index, it is wise to place them in���b_ different cache lines so that concurrent threads pushing and popping elements don't invalidate�� each other's cache lines:���<�����%����'������ struct Queue<T> {���'$     head: CachePadded<AtomicUsize>,���'$     tail: CachePadded<AtomicUsize>,���     buffer: *mut T,�,��<���#\�/���̟�/�J��u��� �D�/,�/����D(������̟m��D5�J�����RT���J�J����
��D,� ������̟��/�J 8������̟T�/�J���knNP�J��
��D ������̟��`�D6�J��`���UW����J���h�������������`���
��D��$�����H������̟��J��=A����̟��D�Dr�J���/2������J��J����
��DL���������̟���/�J�����N�UWZ\8�fjl���J�h����
��D���~.	��}U	R A guard used to release the shared read access of a [`ShardedLock`] when dropped.��4�~	has_significant_drop���~	��~	��~	)��~	�3��������	�P�3ĕ	���3�����4����nM���譎�3�PnM���譎����	�~$�	����3���������PX�z����P��	4�	����Q�Q��Q���<�Q
inner_lock��<K����e�3�h��,	<�	��������Rҹ��^=x�Q�Q��Q���<�Q���<K����e�3�P���/	���Y	V A guard used to release the exclusive write access of a [`ShardedLock`] when dropped.��4�	�����	��	��	*���	�3���������	�����	���4���������m�3�P���m�����	qsu$��	������߆-	<߆	��������Rҹ��^=x�Q�Q��Q��<�Q���<�����͹�3�P���t.bd�	��z���&a���a��Q
�(>���������a�������������}���Oa���a ��f�fStorage��f��f�f��fm�՟���Q�h���������!a�������������}���"Na���"a ��f�fՀ	�f��f�f��fm�՟���Q��������P,��G.+ Configures the properties of a new thread.��H���H(% The two configurable properties are:��H���HNK - [`name`]: Specifies an [associated name for the thread][naming-threads].���ITQ - [`stack_size`]: Specifies the [desired stack size for the thread][stack-size].��I���I_\ The [`spawn`] method will take ownership of the builder and return an [`io::Result`] of the���J/, thread handle with the given configuration.��K���K`] The [`Scope::spawn`] method uses a builder with default configuration and unwraps its return���K_\ value. You may want to use this builder when you want to recover from a failure to launch a�\�L thread.��L�t�L���L�<�L����L ���M���M����Mř��M:����N����N��<�N���N���N'$ [`name`]: ScopedThreadBuilder::name���N30 [`stack_size`]: ScopedThreadBuilder::stack_size���O)& [`spawn`]: ScopedThreadBuilder::spawn���O#ܫ��O0����P(��,��P�&��%����%�&ԂQ�%�%�T0��1��I��4�P$�P:,�Q����&��ĢQ<�Q����E�EBuilder��E�
��E�'��Eno_hooks��y�%�Y��P(��P��&��%����T��_�����EG�����T��^�^��^��[�^���[����e�S�������P�
��&�%,�P���H�3I�3dJ�3Z�3X[�3�\�3l^�3�_�3�b�3^e�3i�34j�3���3���3���39��3���3���3���3���3���3k��31��3���3H��3���3���3�7�3�7�3d��3�:�3�:�3���3���3��3[��3��3�?�3�?�3���3s��3���31�3(�3/
�39�3�3��3�-�3�-�3e�3S�3�?�3�?�3��3��3�3{�3��3��3�3��3e�3w��3�u	�3�u	�3f��3�y	�3�y	�3ŀ	�3��	�3S��3��	�3D��3Ă	�3؂	�3��	�3D��3Ƅ	�3ڄ	�3·	�3��	�3g��3��	�3g��3��	�3��	�3��	�3n��3��	�3Í	�3��	�3���3̏	�3��3>��3���3G��3���3��3��3�%�3���3�5�3�A�3�G�3���3�G�3�G�3�g�3�v�3�v�3�{�3���3���3���3���3M��3ŕ�3ٕ�3���3g��3C��3��3���3֚�3���3p��3���3���3_��3<��3��3���3Ǐ�3���3��3���3���3a��3?��3��3��3���3���3���3n��38�3~�3�|�3�{�3Dz�3|x�3)w�3�u�3�t�3�s�3Tr�3q�3�o�3n�3�l�3zk�3Dj�3i�3�g�3�f�3Pe�3�c�35b�3a�3�_�3�^�3`]�3\�3�Z�3Y�3�W�3�V�3PU�3T�3�R�3�Q�3\P�3�N�3gM�3DL�3 K�3�I�3�H�3�G�3dF�3�D�3pC�3NB�3+A�3	@�3�>�3�=�3t<�3�:�3W9�3"8�3�6�3�5�3�4�3=3�3�1�3.0�3�.�3�-�3p,�3;+�3*�3�(�3|'�3�&�36&�3�%�3�$�3_$�3�#�3%#�3�"�3�!�3N!�3� �3V �3��3]�3c�3B�3H�3��3�3�3��3(0PX[^������������i�������������3�#��atomic::AtomicCell�atomic::AtomicConsume���sync::Parker�sync::ShardedLock�sync::WaitGroup������%
thread::scope��#����ś	E�2�ܛ	��	��	�������	�%Ԝ	��#��2��ś	ܛ	��	�����	����	���%Ԝ	�2�����E������-	std::sync��$std::sync::atomic::Ordering::Release�AtomicCell::<T>�AtomicCell::is_lock_free�$std::sync::atomic::Ordering::Acquire��std::sync::atomic::Ordering���std::sync::atomic�pstd::cell::Cell�	std::cell��*G��	�AtomicCell::<T>::is_lock_free()����	����	ϟ	�	�����	Ġ	��	�0ޠ	�+pG�	��	�E��	���	ϟ	��	��	Ġ	�Xpޠ	�	G��	�0unpark()�std::thread::Thread::unpark�Ustd::thread::Thread��E��std::thread�std::sync::Condvar��Backoff::is_completed�
Backoff::spin�std::thread::park�Ġ	��	�std::sync::atomic::AtomicBool���	��	��U��	У	�	�;���	���	Ġ	��	�0��	��Ӥ	��	��	��	UУ	����	���	Ġ	�X��	��	��	�Ӥ	�Y	�#����#�#������$�Parker::park_timeout�Parker::park_deadline�Unparker::unpark�Parker::into_raw�Unparker::into_raw�������Parker::park����	��	§	ק	�	�������	��	���	§	ק	������	���	�����	�0std::sync::RwLock����֩	�<��	���֩	��<��	��	�std::sync::Barrier�Barrier���	�0���	�6ت	��	�ت	��	NScopedThreadBuilder::name�associated name for the thread��'
std::panic�pstd::thread::scope��У	std::io::Result����(ScopedJoinHandle::join�ScopedThreadBuilder::spawn���	�&�'std::panic::catch_unwind��	��	У	�
�5
io::Result��(here�Ĭ	߬	�&std::thread::spawn���	�+�	�*У	��
�5!desired stack size for the thread�ǭ	Scope::spawn��(ۭ	Ĭ	�&���	���	�
�5�ScopedThreadBuilder::stack_size���	ǭ	����&std::io��(��	ۭ	��	�(��	��	��	���&���	�	�	�(�(��	��	�'��	��	�����&��	�	��(�(߬	�H����������������������I�I�I�H�J�����������H����������������������I�I�I�H�J�������H����������������������I�I�I�H�J�������H����������������������I�I�I�H�J�������������H����������������������I�I�I�H�J�������H����������������������I�I�I�H�J�������H����������������������I�I�I�H�J������C��D�W
�w'm��*�:A��Q1ITO"To,����*��lި��k�V�3�I��'W<�ք0vC>����XzW���9e�>�ŕ�mL�rS���p�o)+SD}fi-���Ee�L}������ q>OX�L�J��g5V9o=����-����^��û)޺j`IͰ^�Z�|-|���07~�G}��!3TM���5�~�_X$c=�N��r{�5,9��ɝ����j;4���D�i��jF6����5o�����f�}D��������`wPUl!�sSv�
�
-������fJE�ݟ�/wٶ�^Fu�o���b�sI�K����i@g�
����krI�6��c����%��0I��x�Ň/�3 �C:�
��,�F@\�
�R����p{7��u-k�Q�`�	{��2=)��p�`5�„y"z/j�2����S)�}������:{�)uIL��P_�[8��I�S���'�G˲�N���wR������s�o��DR����5�&����9p%		i��v�\6�nP���Cۃ�4%��]`vLJ��-�et{O�Tߓd�J�z�T֤~+�Û
-40:�az�y~�R�O;��?�q=���	ԕ^��`�v�v=#;?Y_�����R
M�Y�#���Qn�gآޚmw�\{Wz��k|>�SZ�
;P��Kx���9�N�9�$xɁ��V������05iZ���Ԛ��(��P�!,O�Y҄���9u����7�B�H�mSȅ��N4#֖D��<O�М<@�ޜ�:�J`#��d��9dX�s�Y��قx����.��֜D��xѰ����Ǩ���ٺ�6�Ъg����]b�R�e`Vmt���U���+<P��qK��i��3إ��H��t�G�#���Z�R����48��n��"���9o�㥗�r<�a�����m]Gv�p6��^'�v9�yl�*p�-�E���m�\�9FpA�\�L>���9��Iz�YO��L���D��%�"G�)61��
�%�Y���	^��'�������G��Z�
)�fW����Z�qa	y��8��mi�M���@CB�V�p춣awY
6U�"	��0,������#��,�u6Q%ǸЪS�*�ʷr�x��ޞg��<vdž&�@�:��	+�����8���5d�D���8��FrQ��>DV��E����Y�}���,)�pu��	%�X��^Y���7�� ��-����}��>��8�J|W8y~����]AL����
�H�;�V���9�>{6�b�N��;I ksWy�.�-�����i��#�_eU0���ܗ�K���AI/��{�C	F�T���fG��Be]S����o�^�m�n5���� �%G�x�
���W`Q�/*�qd͵�ߎ�S�l��Ze��q$
�p
jYH��m���T^���9����	J摫,_���3c����xL���7�fϸq�:�p���a���9d��y�V~J@_����i�-^i��^��a݄����u�C��t��B�PY>���a�,:�����\�N��T�ƌ	�cE��������Hr�r��7k�i�zh������1��eh6�k������!�Ő������r5>����۞X_̛�K;�����֧�'f��v/��t=�.[?��k�9�p���M�����}�	@���ŲhA�����4ց��±�m��G\4�N�Ȗ�xj:�Nm&�吏��W�
�LF�S�;]X@��������Q��p�����Cs�iħ-aI�ϣ��0�'q�q�=��sĹ&���ܝ� $<]��>h;�!V��	���z#Q�Ȍƴ��0$������ƶ
YV���7~���=���x�8U��/��,\���=a�ܸ]�O�Ծ���.X��(�
�K�(uSQUl0	x��سӴ����#[�ņM>a߬�������`z��vW���ӛ}�Th�BSYV���Ψ`m6n/+GI��՟5�9{!j#��?������ui����u4�y��{~��d=���T�vG܂{�W��\�����͕M�r�3������ �qsJ�Z�͕N��m���&ˆ;(c ���wpޡEΣ�yUd�N֥Kk
��dj�$(L�ڈ;���]ݳ�Q�D*uw��\�B��.ޮ��y5칷٪)�|.h�!���ąϱB`)�<zR�8�4�Wt�pn?I~(�hz�)�r�Ј�m��̨�����ᅬx8�g��Ī�	 ~L�����q�	)4=��kޣ�-	�,=�Î���2�#qoJ�p6�:�r�����/(v�L�(��P�܁U��*�o�H��4/�c�O�Z��P���՚p�����V8����q�˵c=6E�����|с0�@���bK��KH� 8H!,J�E���N�#4ڙ��
D��2�Y}D(��赹s�E1+�o��f��E�
�}���ΝlQ�ZX�3�2���#C|��Ti��(�߄���
����x�f�P`���p9'ȳ��/�����V=�,�v���O�곑�󎮙��SL�$�����,ر�ܘDz�_2n��f|�����,��F�8�/[�&���DŽI��n#�8&�\�@��EL�kL
.
�3���C�գ��p{�X��7�kp��MD�~1�ɏ���4Y�&�Y]�g�p�.
�/����e,�S��ф�H�t
�S�Ƀ;�_x�K��tY��3��݃���e����	_AS���5�!_E��z��㤱K|��AW���������Ct���O�j�
�=����KՄ�:;��d���6t�Ց��{�0��_��'oϻw��}�x}�Ҝ�F�I��:��n8���W��P�]ϫH�xO!�0�^�$ej2�
7S/M���T($�aom?�����@�V
����|�G1�b��X�;T[�qv�
����0~4���e%���)�C7و$JB
���bza
��K��ٓ�*����������������"�rNJ�k��g�g�L����:��6c���S�1%�yz��oaEH����lMm��s�F2S��0������b��.�q��.��ٽ���q�D��l����n������2�H�:%N����ѐ�J��!zq�?�.9=C-� ;�BXp������
6��Όh+�d?�GY�o��)�!�.�2"�)w?5 L*�Η�-��
��
�X�m���O��_4���v��`œ�D�i�����b�n�����ч�n���4F��=��,:�0h9�$��e�,�
�<��
���=}����E�&�I<a7^�ӿ�'}����nw�C�5лCfEr�	�%���"%F\+��
υ�W fhm�}�l�UP�o��M�4Gc���U����d�R8j+��-��gj2��Y��G�E�Z^ @��`1��Vg^���%\�.ĵn�Mq�4Aa��6z[g-rha���%(�|Hb.>&V��Ňi9�1a���Y�V�'�'�y ��5A��bR������O��Gͽ��h����#ȟ#��C���H�߂��n��`n���0�ꦰ֭��po2"��:K�7��L�[8eM�5<@
���K8GI���3���s[E��q�{%x � �q=A`Xk��&��w������a�q2�|2KKꗜX��zBQIڅ�\��ͪ�w"u�)u)DU��F�g����3[��3&GZ����pۍ�1�(Yy�#��ɴ��F��������bX,���6��$�;�V���?�X���$�{J��`�]���$�=mk�,V�jU������ps�HYI���Ea��p*v�N�)�'r
+�-��������[����~���ek6b��|��*M悩�q���t�`Ka����
3@8�38BXuc��_��dm��{}u���?��i67�T���[9��]��%'X�%��=�-B�k4��U�O������l����差j���R|t���t|

_�4e=��`���gqP~D��,�x'�Dhr���6_�V�ji��q���-�P�x71�4�gI��R��*�|��N�+��,�;5d��1��Ɲ�#�j�mLUFc��wޓ��!Q�	�+‚v��\.�+��-Z/��9�
k�v���}V���0�1%g��Lv
s�l�6,Z��H+�"������(vL(���C����/tc�����f��?Z,t�
�`�R@��&����ky�!2w��y�˦v`O��d����2��&C,��`s[%��O�!���.:?��Q�ŧcG��<@d��8�l�Oդ~��BN.(�Z��챥����-/?�����`����
�+�"ͻ2	�#��'�彻|Z���,Q,�j�|���r_��@�u�F��:`���F��y�+u��psǻ1J�<&�4;��
�2�4��>d��Z>�4�ݫ�ӧ��K/S���U\�_WJ�[LŞ�NJ?����z��}�&c�����z,�)cY>q���f�z��=�<��(��;r�s��$�cw�׍��\rۣ�U�A���	h��/���|����pg��Ob7Iⴲ9�b_�Z羬��QbO��XV���3�x����\ŴH'��#<�����/��;�,;�.ֽ-�����(To�ނ�Gx��U#���e�8��CԆٻ���c���x����0,O'��� �+������M�H3חn۳���G����~w�ǐ�8��n���"��<�?�%��o,(��!�$�r��/vFN�>W���Z�4���OI��\�j�]��0C�*�'vk"�b�X�H��i�k��p��a�������L�
��c����ɺNy䡉4̎���q����N�q<!6݇�+W����t���R��H9�����—��:
�]���>�W���"��'N����7i_���u�z@��?jj���Q�,xP���m^J~��(�{!�+�棎�K����X�4�J���$�c�Vd��IIs�����
~�0c�L�Gz�_�6�~ܐ�lK��c*vsN�:C�3D(���y>�>h*����V�wpɳs��@jU_g��[*�x�N��´L�#��`��5Z)Z`֊JPÍ�F���Z��4����d$^���޿�5��\G�nv�:�5	�~#}[�f���ȝ������7�]
n��/2�*d�"���t�S�_���9/�$�¿�������Ch��VjOS��-	�p+<��`���sR��e9��F�~T�'E�@�qV#lx��l6mܡn�_����/��R�<t������������/�喿�ha>��o�0kО��C4skĒ¥E�������s"3�0�$���D>��ps�� ��^ @�]��zY�ý&�\��N�͹Isr?��p��~���� �^���מ�׬����'�H��2.��L�58�4��b,`r�!�ɔ�p,��|���g8�p��=5g�sF���Ojfk������Ƥ�p$�"��[@W/�]�X?��7���D��y�7���`B�X���� ����XY���T�V�VG����e��}����ϚI�ՠ�rI�<��2��4S�|�Ҡ!iGL+�����-o�""��b�O�n�{sT?.T�q=��l��b�s/��tD����X���n	�9o�to��>�z��@CB*1�]���g	��d����Ӌ�M��x�0p�b�Mls�[�'r��y�
?�6�<�~V�8����p[}?mQ�[i'�ahR�T��q��*��U2N' 	�B�v>���q�Pk`>������z{!
��~g0���x�ѨQ�v+�
(c�h�ù{B
C�	�}@�r~b�I��k�>
덛]�\��L�!�`�w�|�莆&��o�X��wrЙg~�]��*�ANm���z�v?���6�v�d�
7�`�y���kw�v�D"�ӈ,��F��O��Z�<�\Y�� �g%`�.�1<�]�P8wΑ��M�����-�2��B\�����!�Ӷg�o�7�*�Ӵ�m����\�
t��V�`�|���1���q`4�y�;����JX'��Z\���L~/�:n�ώ�&��niͻ�����N�7e��=�)��}(����c�2"f���3	Tw�Y���z��2j�?[��$$�GOv|͠�k��<)��o���0���ޓ;��6���4�Q�.SZG�^
�w�`j?e��$^��?��N��%��g�>�/r��o���F��
HrO���=���AD����H͖�d}$½���>�ԭHHE;`Y֟��t�ܗ�~`��Q�T�b̅�B;���Vi����K���#�"~�ؽQ�P�~�+~���Bi�E`V���;�sQkx__����=&f�K��N,)�qF�X��B?�W]�p��z��A��M<�k@���8B)K�I�g�2�q��0G���*&פ@�>0����u��@��Wi��f'(��J`��%�#p�o��s0$���^�?�Z,��#"����/�D��0�C4�~���d�
A����jr����'Z���Jɮ�)�Nՙ�ͥ���$#�kgbP2��U�x�Z[�i�?���80"��p��T���wJ�h�t}���*	A�U�C�#�6T��ШL�;�����=���*p�v8f:���J�X8�Ҥ����+Ʌw�F���ǩ���l����9*��X���3�7�5(�0���1پ<�S�*�����/‰�\��^��w��D�2�p�cՑ@1+��N����k��Y�m����)Y�4��0�_[�
�&y���0��4�lֿ�8��4Cr��e�?�F44�H�z�\.H~�Zn�y�N�7�?݈=��śsqP�<��E�Nmlj?F�S���Jb$Kmlg2�BR�c�]����*���}>&^������%��b�g�V
�LTN�Py|Y!G���I���:�^���q����‚��*ЇC���*
�@��J��B��F�U�yN�#�afh�;�]!�4�����%����
�O�O����c��q'	���֐�b�m���H�9<��)�
DL�V����2�N�<�W>;� �;�	�#WN-��u�Ѱ݀�>s��DSe,�5��ÇI�nF'�Π�����e�W���T��}UTE��Yf`i�?��sC-�ϝ����ϲ�F����2�
hV(�h']KU�#d��7S�/v��cʓ�����v��Pj�e6���7T��̜�E)�iE�}�C^��R��qœ]��+ӌ�/�i�}�	l��6��WD�O��~L,Bݢ��$u�VAz%fU���<,hy��[����-��%����ٱ�n"U�O�;�'7d�9���f��dp<D�f��٬��F/:Z襃6�I��������;B>�E����{M|M}M�M�M�M�M�M�M�M�M�M�M�M�MrD�DEZ
E�F)G�
J��"����~�bF�X�u��>�D�DERE�FG�G�G�GH8H�H(IgI�I�I�I�IJ.J{JL�O�O�OPSP�P�	P�Q�S�
X*
Zz[�\
]�^�^�_`�b�e�i�iNj�p����������]������^�����s�������u�������-�������W���?�����������������{�����9	�f������e����N��B�����������H�����	��
����1�(*�t���@�\���s���*�F�b�����'�j�&���Y�����M�.Ok���	5
	�	B
X
c8q(�C'8R���t���
Pk�4�)""7"�"�"�.#6,�,-J-�-�-�-7	./v/f2�2�5F8�$<BsE�H%I�I.JKJ�JCK|K�KL\L�L�L5M�M[N�NyO�OPsP�P�Q�Q�R�RSzS�S2TeT�TGUVjV�VW�WXEXbX�X�X�Xo*Yf_`/`K`�`�`�`	a�ad5d�d�d�de�pe=wDxy�~
&v.�����-��1������&�
���������1%�+�o�����~��������g���D���v���/�z�������@��������/
�h
�����X��������=
�t
�����c������� �H
�
���������U����
�
�`���/�������:�u
��
�
�`���2�m�����
�j
���
������S����
�
�^���-�������8�s
��
��\����/Y��
�
/��-	U
~��


P�!z��,g
�
�R�&a� �!
#^
$�%�%�%J&o&�&�&'0'�'�'�'3(X(v(�(�()y)�)�)*A*_*�*�*+b+�+�+,*,H,�,	:-�6�6(7~7�78C8�8B9{9�9;:�:�:B<�<=�=�>�>b?|?�?(@�@�@j A	F,F�F�FhD�D�DEZE�F'G�
J���� �����|�V2
�X�u��G�G�I�I JqO�OP@PtP�P�\�^�_�i�������������������� �����0�%���������L���������G��	="3D��F(�" ,7-}-�-�-.�2IJ:J&K�KHL�L}M�N�O�O�P�Q�R�S;U9X�X]_'`�`	a%d�d�d�~������������^�M���������������?�����<�d�1�%V&�&�'?(�(�)(*�*n+,�6
7�7�7w8i9�9h:'<�>�E�F))

&
))







&

&











gD�D�DEXE�F%G�G�GHMH�H=ImI�I�I�ICJ�J4O�O�Q�S�X�Y4[�\J^�_�b�d�hjRj�p����c����1�������������|�������C�������m���U���_�����������8�y������c�W�������������������:���q���y���.�J�C��;�n�S)So��	���B�=GC�~����%To�I�/&"="�"#�+:,�,�.�1d5{7S;A_D�G:I�IJ`JXK�K�L�L�M�N*P�P�Q�R'S�SHT�TLUVoV�VW�WXJXgX�X�X?_j_`3`O`�`�a�cJd�d#e�uAwHx�|�~�~;܂1��5���h�2�f��ݗœ������ٞN������E�ߧ�7�a�������R�	�M�u���Ƹ�%�\��X���������0�g�2������=�x������5�p�����"�m��������V������b�0������;�v������3�n����� �k���r�����
3\����
/W
���'b��_�z�J �!�"$V%�%&u&�&'G'�'�'^(�()0)�)�)G*v*�*+�+�+0,_,�,r6�6;78�8�9�:�;F<�<=>�>�>g?�?@@A�E
F0F�F�>�D�D�D�D�D�DENEQFVFZF^FdFhFlFpFtFxF|F�F�F�F�F�F�F�F�F�F�F�FG�G�G�G�G�G�G�G�G�GH3H�H#IbI�I�I�I�IJ*JwJ�K�K�K�K�K�K�K�K�K�K�K�K�K�KLLLtO�O�O�O�O
PPAPNPuP�P�P�P�Q�S�X%Zv[�\�\]�^�^�^�_``�b�e�i�i�i�iJj�p��º˼Ѿ��W���������X�������S�`�m�������P�^�p���������'���������D�Q�����,�9������������������������
��f�k�n�r�v���������'�4�b��������`������<�I���1�>���������������������
������������#�p���<�X�����o����������&�A�]����������"�e��!�����T�������I_chmquy}�����Kf���	1	�	=S
^3l#�?#4Nz���p���Lg�/�%~!�!�!�!�!�!�!�!�!�!�!�!�!�!�!�!�!�!�!�!�!�!�!""""""3"�"�"�#$,1,�,-8-E-~-�-�-�-�-�-%.2.
/q/b2�2�2�5A8~<BnE�HI I�IJ)JFJ�J2K?KwK�K�K�KILVL�L�L�L/M�M�MUN�N�NsO�O�OPPmP�P�P�Q�Q�Q�R�R�RStS�S�S,T`T�TAU
VeV�VW�W
X@X]X{X�X�XVYZY^YbYfYkYb_�_+`G`�`�`�`a�ad1d�d�d�d	e�e�e�e�e�e�e�e�e�e�v�v�vw	wwwww#w'w-w3w9w3x@x�x
y�~�~�~�~�~"r*�����"�(��.�|�����Ą����
������Ύ�	��̑+���'�j�������f�l�y�����О�T�a�ϣ>��[�b�h�l�p���ʦ)�t���ç��֨9����ԭ��(�a����Q�������6�m�����\��������A�x����}����M������Y���'�������2�m����X���*�e������b����{����K������W���%�~�����0�k����U�����(R{��)}�&	N
w��
�I�r��$_��J�Y� �!#V$�%�%�%C&i&�&�&')'�'�'�',(R(o(�(�()r)�)�)*;*X*�*�*�*[+�+�+�+$,A,�,-�6�6�67&7x7�7�7�7	8=8�8�8/9<9j9y9�9�95:t:�:�:-<3<@<�<�<�=�>�>�>�>Z?t?�?�? @�@�@eA�EFF(F�F�F�F�F�G�G�G�G�G�G�G�G�G�G�G�G�G�G�G�G�G�GHHHHH H&H,H2H8H?HFHLHSHZH`HfHlHrHxHH�H�H�H�H�H�H�H�H�H�H�H�H�H�H�H�H�H�HIIIII$I+I1I8I?IEILISI[IcIiIqIwII�I�I�I�I�I�I�I�I�I�I�I�I�I�I�I�I�IJ
JJJJ%J+J2J9J@JFJMJTJ[JaJhJoJvJ}J�J�J�J�J�J�J�J�J�J�J�J�J�J�J�J�J�J�J�J�JKKKKK#K)K/K5K;KAKGKMKSKYK_KeKkKqKwK}K�K�K�K�K�K�K�K�K�K�K�K�K�K�K�K�K�K�K�K�K�KLL
LLLL%L+L1L7L=LCLILOLUL[LaLgLmLsLyLL�L�L�L�L�L�L�L�L�L�L�L�L�L�L�L�L�L�L�L�L�LM	MMMM!M'M-M3M9M?MEMKMQMWM]McMiMoMuM�D�D�D�DEETEXF\FfFjFnFrFvFzF~F�F�F�F�F�F�F�F�F!G�G�G�G�G�G�G�GH8H�H(IiI�I�I�I.J}J�K�K�K�K�K�K�K�K�K�KLLL0OvO�O�OPCPwP�P�Q{S�X�Y[n\�\5^�^p_`�b�d�h�i�i�iNj�pu�{�M������
��������U�b�{�������w�������-���������F�W�����.�?���������[��������������i�p�t�����)�#�d����������>�N�3�B���������������������������j���%���\�����u����������*�F������.�j��&���Y�����Oeksw{����%Ok��	�
���-�(C.�i����
!Pk�4�+�!�!�!�!�!�!�!�!�!�!�!�!�!�!�!�!�!�!"	""""""9"�"�"�+&,6,�,:-�-�-�-'.�.�1�2O5f7>;�@JD�GI%I�IJKJ4KCK�K�KKL�L�L�L�M�M�N�N�OPP�P�P�Q�Q�R�RS�S�S2T�TGUVjV�VW�WXEXbX�X�X\Y`YdYiY;_f_`/`K`�`�a�c5d�de�e�e�e�e�e�e�u�v�v�vw
www!w%w+w1w7w=w5xDx�x�|�~�~�~�~�~&؂&�-��1�„x������S����
�Q�ړȗ�������j�n�~�����՞V�8�����`�j�n���Ц/���ɧک �J�u���ɯ�;��6�^�����׹�E���A�i��������P��s�����%�`��������X�����
�U���n����>�y�����J��q�����#�^��������V������S���[������E}����	@h
���J���G�b��2 m!�"�#>%�%�%o&�&'0'�'�'X(v(�()�)�)A*_*�*+�+�+*,H,�,n6�6�67(7�7�78�8�819m9�9�9w:�:�;1<5<B<�<=
>�>�>�>�>b?|?(@�@�E�EF	F,F�F�F�F�G�G�G�G�G�G�G�G�G�G�G�G�G�G�G�G�G�GHHHHH#H)H/H5H<HCHIHPHWH]HcHiHoHuH|H�H�H�H�H�H�H�H�H�H�H�H�H�H�H�H�H�H�H�HIIII!I(I.I5I<IBIIIPIXI`IfInItI|I�I�I�I�I�I�I�I�I�I�I�I�I�I�I�I�I�IJ
JJJJ"J(J/J6J=JCJJJQJXJ^JeJlJsJzJ�J�J�J�J�J�J�J�J�J�J�J�J�J�J�J�J�J�J�J�JKKKKK K&K,K2K8K>KDKJKPKVK\KbKhKnKtKzK�K�K�K�K�K�K�K�K�K�K�K�K�K�K�K�K�K�K�K�K�K�KL
LLLL"L(L.L4L:L@LFLLLRLXL^LdLjLpLvL|L�L�L�L�L�L�L�L�L�L�L�L�L�L�L�L�L�L�L�L�L�LMMMMMM$M*M0M6M<MBMHMNMTMZM`MfMlMrMxM�b�G�G�G+H�HISIuI�I�I�IJJhJIO~O�O�O�O�OP4PKPhPP�P�P�Q�S�XZ\[�\�\�\p^�^�^�_�_`�bbei�i�i�i8j��������>�r��������D�s�����#�]�j��������Y�i�����������p�6������N������6�|���t������������������1�L���������L�|������F����;�k�����h���	��������������_�|�#�H�����#�:�V�y����������V����w���(�������50_{��		�	,3
="V��&S/@i���W|��.`{�#�/"F"�"#�+.,F,�,#-B-a-�-�-�-�-�-./.�.P/N2}2�2�5-8j<BZE�H�HI�I�I"J6J�JK<KjK�K�K�K#LSLL�L�LMXM�M2N~N�NPO�O�O�OPSP�P�PaQ�Q�QxR�R�RSZS�S�STYT�T�TXU V{V�V%WX"XVXsX�X�XF_v_`?`[`�`�`a�ad!dpd�d�d�d�eYw=x`xy�}�~�~�~�~a�p���=�'�A�����5���Ս����������!�m�����ԛ��v��������A�^����٥��Ǧ�Z�����_����b�������D�}���4�x���ɷ��P�����?���������$�[�����^�����.�i�����:�h��a������N���������F�������C�����\�����,�g�����8�f��_������L����������5^��
7�		1
Z��
�*X�S��@����:v �!�"7$�%�%�%0&R&&�&�&"'v'�'�'(;(h(�(�()_)�)�)*$*Q*�*�*�*H+j+�+�+
,:,�,�,�6�6�6�6#7d7�7�7�7808_8�8�899^9v9�9�9:W:�:�:�;=<R<�<=7>�>�>�>p?�?�?@I@�@A�EF<F�FoG�G�G�G#H�H�HKIoI�I�I�I�IJ\J6OxO�O�O�O�OP!PEPUPyP�P�P�Q�S�X�YP[�\�\�\d^�^�^�_�_`�bVe�h�i�i�i,j������}�1�_��������<�`������W�d��������S�a�~���������b�(������H�|�����0�g���`�	���������}���������+�C���������?�g������@����5�b�����[�����������������R�v��B�y����1�M�d����������M����[�����������(*Vr���	�	&
0M�
� J):\���Jv���(Wr��)"@"�"#�+(,=,�,-<-L-�-�-�-�-�-�-).�./E2h2�2}5 8]<�AME�H�HI�I�IJ0J�J�J6KaK~K�K�KLML^L�L�LM7M�M$N]N�NBO{O�O�OPEPuP�PSQ�Q�QjR�R�R�RLS|S�STSTvT�TOUVrV�VWXXMXjX�X�X@_m_	`6`R`�`�`�`�a�cdcd�d�d�d�eDw7xKxy�}�~�~�~�~T�?���ނ4��8�����
����ȍ����Վ����Ř	��<�q������Ŝp�������ܞ �X����˥x����Q�|���Q���
�S�}���Ү��5�n���%�i������
�A�x���0�t��������L�����N������Y�����*�b���Q������>����������6�r�����3�~���L������W�����(�`���O������<�����	�������&Ox��1��"
Ks�
�R�C~��0{����*f �!�"'$r%�%�%!&L&v&�&�&'g'�'�'
(5(_(�(�()P){)�)�)*H*�*�*�*9+d+�+�+,1,,�,t6�6�6�67U7�7�7�78'8J8�8�839I9p9�9�9:B:z:�:�;7<I<�<=>�>�>�>j?�?�?�?C@�@A�EF3F�F`G�G�G�G1H�HIWIwI�I�I�IJJlJ[O�O�O
P>PrP�P�Q�S�XZ`[�\�\t^�^�_�_�bfe�i�i<j��������B�������H�����I��������[�m����������u�;���0����������
������S������Q�����.���#�p���m�����������������d�~�(�J�����?�[������]�����-�����:2d���		�	18
B'[��(X 1Bn���\~��0e��%�1"H"�"#
,K,�,5-{-�-�-.�.U/S2�2�528o<B_E�HI�I�I'J8J�J$KoK�K�KFL�L�LM{M7N�NUO�O�OXP�PfQ�Q}R�R
S_S�ST[T�T�T]U%V�V�V'WX$X[XxX�X�XH_{_`D```�`�`a�a	d#dud�d�d�d�ecwjxs~�~f�u���B�,�F�����ԋڍ
��������ۙr���ޛ��������K����ޥ���_���d���!�g�������I�����9�}���η���U�����D��������)�`�����c�����3�n�����?�j�
�f������S���������K�������H�����a�����1�l�����=�h��d������Q����������:c��9�	6
_��
�/Z�X��
E���?{ �!�"<$�%�%�%5&T&�&�&�&''{'�'�'(=(m(�(�()d)�)�)*&*V*�*�*�*M+l+�+�+,?,�,�,�6�67i7�7�758u89g9�9 :f:�:�;W<�<=K>�>�>r?�?�?@K@�@A�EFAF�FtG�GHOH�H?IoI�IDJ5O�Q�S�X�Y5[�\K^�_�b�d�hj����d����2�������~������E�������o���W���9�z����d�X�������������;���r���E���>�q�*��	���C�> D���(L�@"�+�.�1e5|7T;A`D�G;I�IJaJYK�K�L�M�N+P�P�Q(S�SKT�T�V�WX�X@_	`�`�a�cKd�d$e�|�~�~<����i�3�g�������O�����F�����8�b��������S�
�N�v�������&�]��Y���������1�h�3������>�y������6�q�����#�n��������W������c�1������<�w���
���4�o�����!�l���s�����4]����
0X�
���(c��`�{�K �!�"$W%&�&H'�'�(1)�)w*+�+`,�,s6<78�8�9�:�;>�?�E�FHOH�H?I�IDJ�Q�S�X�Y6[�\L^�_�b�d�hj����d����3����������E�������p���X���:�{����e�Y�����������;���r�F���@�r���	���C�>D���L��.�1f5}7U;
AaD�G<IaJZK�K�L�M�N-P�P�Q*S�SKT�V�W�X�`�a�cKd�d$e�|<��j�4�i���Q����H���8�b�������S�
�N�v���Ǹ�&�]��Y���������1�h�3������>�y������6�q�����#�n��������W������c�1������<�w���
���4�o�����!�l���s�����4]����
0X�
���(c��`�{�K �!�"$W%&�&H'�'�(1)�)w*+�+`,�,=7 8�8�9�:�?�F	H<H�H,I�I2J�QS�X�Y#[r\9^t_�b�d�hjz���R���� ���������������2�������\���D���'�h�
���R�F�������n���)���`�2�n�*���]�����	�
���1�,2�m��8��./�1S5j7B;�@ND�G)IJOJGK�K�L�M�NP�P�QS�S7TeT�VW�W�X�`�a�c9d�de�|�~*v.���|�W�!�U�ޓ̗+�=�ԣ��զ4�Χ�&�P�{���ϯ�A���<�d�����ݹ�K��G�o��������V�!�z�����,�g�������$�_������\���u���	�E������Q��x�����*�e�������"�]������Z���a������"K�����	Fn
���Q��N�i��9 t!�"�#E%�%�&6'�'|()�)e*+�+N,�,*7
8�8�9�:�?�?/@�@�@�F�!�!�!�!	"""("5"�$J%U%_%i%s%}%�%�%�%�%& &*&k&u&&�&�&�&�&' '+'6'@'l'v'�'�'�'�'�'@(J(T(^(h(r(�(�(�(�()0)�)�)8*B*L*?"t"�"�"#P#�#�#�#,$c$�$
%%%(%3%@%�)�O�OPMP�P�P]�^
`�i�i�����_�l���P���8���������3�����H�=���%�����!� �����0,D-�-�-�-1.�2I>K�KUL�L�M�N�OP�P�Q�R�S?x	y�~�~���#����x�`�ɦ§�6%7�78�8;9x9�9�:?<�>�,�-6/�/*1�1Z2�238�8�8>9u:�:!;w;�;/=�-5/�/)1�1Y2�238�8�8=9t:�: ;v;�;.=�>/H�Q�XG���Q�[�z1R2�2�2�859�:;o;�;'=�>~1V2�23�899�:;s;�;+=�>3H�HI[IJpJ�Q�S�XZg[�\{^�_�bme�iCj������F���O���S������z�@���8��������[���Y�����x�u��������i�-���e������B	�	6=
G,`��s��a��/[2�5:8w<BgE�H�I�JwK�K'MDNbOePsQ�RlS$T`TW
X�X�`�adzd�d�e�~k���������������!�l�q�&�l��������N���>���������#�Z���I��������.�e���h�����8�s�����D��k������X��������P������M���f�����6�q�����B��i������V���������?h���	;
d��
�4]��J���	D� �!�"A$�%:&�&�'#(�(i)*�*R+�+�,�,q7=8"9(:�:�?�G�IrO�=X__�~�>�cW�@WA��eD�D�DERE�FG�G�GgI�IJ{J.O�O�OPSP�P�\�^�_�i��]���^�u�����Y����{�������e�����������t�@���s���b�������M#��	'8�t)7"�+-J-�-�-�-f2�H�I.J�J|KL\L5M[NyO�OsP�Q�RzS�TX�X�X9_`�`�`d�d�d�u�~
ւ�����ӎo��������v�z���������`�
���^��/P��%J&�&�'3(�(y)*�*b+,l6�6�7�7G8F99?:�;>�E�F�G�IiO����
�@6?�",�I4U2XV_ `�~�V��6<�>�E�GyI]O������4*3�",�I(U&XJ_`�~�J��6<�>�Enqx|����������������������������
!%3:>E[o{��������������������	
%,07;BFMQX\cj{��������������� 6:J[jz~����������������"*2:T\ckrz���������
		%	*	2	:	>	Q	V	[	`	e	j	r	w		�	�	�	�	�	�	�	�	�	�	�	�	�	�	�	�	�	�	



$
)
.
@
S
b
n
s
{
�
�
�
�
�
�
�
�
�
�
�
�
�
�

&+38@EMUhp�������������������!05:AFNZn�������������




)
7
G
T
\
d
p
u
}
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
 %7DL_rz�����������������%1BJOW_x}�������������������!).6>CKSX`hpu}��������2:KPXjoty~����������������
#(/49>CHMRW\afkp��������������(08=BJWemu�����������������'5=EMRZfks{�������������	!2CGOW_gow�����������������#+3;CKSW_gow�����������������#+3;CKS[cgow�����������������'/4<DIQY^fns{������������������19AFNV[chpw|��������������4<DLTh�����������	%+17=CIOU[agmsy������������������	%,3:AHOV]dkry�������������������!(/6=DKRY`gnu|������������������$+29@GNU\cjqx������������������ '.5<CJQX_fmt{������������������     # * 1 8 ? F M T [ b i p w ~ � � � � � � � � � � � � � � � � � � !
!!!!&!-!4!;!B!I!P!W!^!e!l!s!z!�G�IlO����
�B8A�",�I6U4XX_"`�~�Y��6"<�>�E�G�G�G�G�I!J�P�P�P�P�P�P�\�^�_�_�_�i����������������������������$�%�������2�'���	�
���
���N��������)	*	+	,	-	.	/	JKL��,-".#.�2�2�2�2�2�2	I<J(K�K�L�LM�N�O�P�Q�R�R�S�X�`
aa'd�d�d���������Q�R�������ͨΨϨШѨҨӨԨ������������������������������������������������O�P�Q�R�S�T�U�V��������������������������������L�M�N�O�P�Q�R�S�tuvwxyz{��������ABCDEFGH�%�%Z&_&�&'�'�'C(H(�(�(�)�),*1*�*�*r+w+,,��7�7y8�9j:�FTj�p���մMUO}OvQKS�S�T4U�U�X	 YnY�Y("Z�Z�Z]�o��G�I&J�OP@PtP�P�\�^`�i�����������������&�����7�,������S����������0	"3M��.7-}-�-�-$.�2IAJ-K�KHL�L�M�N�O�O�P�Q�R�S�X�`a,d�de����������S�����ը�������W����T�|�I�%d&'�'M(�(�)6*�*|+,7�7�7~8i9�9o:�F������	��!��
������
��"������� �3�3���P���Z��C��D�W
�VEr�"������ �����C��D�W
�_��j����#��O\core_intrinsics����C��D�W
��r
�ŏ6����B��Y�sh4C��D�W
�%�c�|i1������C��D�W
����x��v����U6��O�	g4C��D�W
�e9GY<�=����H�h4C��D�W
��j����x�������C��D�W
�
TF�d.$crate::thread::local_impl::thread_local_inner�����uQb��athread_local_internals����
�f�fC��D�W
�n� jrWK��ߎg4C��D�W
��l��r�ud�x�����C��D�W
��
������ @��C��D�W
�k����dO�#�u�=����`�`C��D�W
�3�H! �c����B-h4C��D�W
���&����������C��D�W
��|������U5+g4C��D�W
��qy�6�����C�h4C��D�W
��9�* �x��)��C��D�W
�]O��p{6$crate::thread::local_impl::thread_local_process_attrs�+����Gb��/$b����C��D�W
���Q2\F���x�����C��D�W
���!���kclippy::has_significant_drop����3C��D�W
�cQ��#�n`���h��C��D�W
�	�9�P?�#<���j����C��D�W
��꟦�a8����BTh4C��D�W
�������#�������C��D�W
�&���T	�����T/Rg4C��D�W
��=����d����C�h4C��D�W
��ͧ�C�n�x��P��C��D�W
�~��<?����4���C��D�W
��;�`�5z�x�����C��D�W
��hr�v�o�M��3C��D�W
�8FiG�7�,~#$�u�����derive_clone_copy���C��D�W
��S+P�8������?h4C��D�W
�D/���2n������C��D�W
��)]�������B`h4C��D�W
�3��D�m
��|����C��D�W
�5f]�QB�x����C��D�W
�JA��-�t#��}�J�������C��D�W
�H��
غ����?!h4C��D�W
�<�q�I
h��Ծ���C��D�W
���u���\����B{h4C��D�W
�bx��������C��D�W
�#�Zg�����W6yg4C��D�W
� �W�٩r�x��J��C��D�W
���5�D�e�!x��y��C��D�W
��1ݿ���3�3�C��D�W
��X��W���Ԣ���C��D�W
�WVc��B^��#��e�f\��	derive_eq�����C��D�W
����������B�h4C��D�W
�u�Y�P�����	��C��D�W
�V���Ur������V6�g4C��D�W
�rv��c7ѳ����H�	h4C��D�W
�N��͍����x�����C��D�W
�+�_Fx�@��,��}����fmt_helpers_for_derive��_�_C��D�W
�Z��΋��� x��t	��C��D�W
��eQ�F��@+std::thread_local��М�	�߃b����C��D�W
�
'�`��o����������W�ϼ2����Ǽ�ݼ��M����[�
��Ӽ��$����;����?�����I�����R��¼`��˼��)�ؼ��-����D�����6��d���O�4���[�.�)�����
���������!�������|�a�����^�V�����f������������������7�����1�������ʿ[�`����N�&����?��
�x���l�Q���x�N�F�����'��׾����>��ٽ����~�����z�s����������������������!�V�/�	���P�������z��?�$�r�K�������K���ODHT ����y�N�7�?f�t�`Ka���_��'o�b�kp��ML���	J��!Q�	�+��*����w�l��Q�9�p�����X���Gͽ�������p{1����4�ٻ���J�g�g�L�{��0���>0����u3'ȳ��/<���� �qs��%�#p�o7ۃ�4%��]D�	%�X��� �g%`�.�ɮ�)�N�@��*ЇCu����,ر�A�BN.(�Z�y"z/j�6��L~/�:��s0$�8Û
-40:�Iw�C�5лC��Z>�4��-<!6݇c���48��nq��,:�0h��М<@��`��y>�>{ąϱB`)��38BXuc�8��CԆI�E�
�4���Ch����Y��G�E��{B
C�	�y�V~J@_��>OX�L�J�<zR�8��T($k�_eU0��W���T��#���Z�R�plQ�ZX�36�S�;]X@��5�~�_X$c��P_�[8:F��:`���'��V�`�|����eh6���Qn�gآ�Q@jU_g~���i�-��Wi��f5�*�o�H�$Q��p�����Hr�r���{}u���i��v�\6Bn��f|���C�%(�|Hb.���q�D�������Na	y��8���mSȅ��N4^��ܝ� $<�QIڅ�\��
(c�h���?I~(�hz�wΑ���T��̜�E)��'}����n�lި��k�'N��j�@���b,��[*�x�N$�¿������`���sR�~g0���x����,)�pu���ŲhA��X��(�
�ۍ�1�(Y���K���q�E������=�N��r{-�����(TF���8����~w�ǐ�8Q��-�P��B;���!)�r�Ј��`n���0��#qoJ�p6� �=a�ܸ]��N�Ȗ�xj:�~ܐ�lKx���'�H�����ͥ���A�Q�`�	3rS���p��8U��/���%��0I�,�7e��=�����=�KX�m���OŔF�U�yN�xaz�y~�J*uw�����*	A�UH��d�
A��=���o�������$u�VAz%�>q���f5Xp�����Vd��IIst�I��k��)u)DU�,�)cY46U�"	����q'	��~�nF'�Π��l�6,Z��iħ-aI��|�G1�b�o�g�2�q�0:�5	���;I k����;�s'{��2=)��4O���=�����?����!zq�?�.9��Z^ @��`��{sT?.T��N�<�W>��fJE�ݟ%�iE�}���ps�HYI���b�sI�K�(n�Mq鱱��ɺNy�`�H�xO!�0h�,xP���n*�ANm���g5V9o=@�qV#l�y��[�������	_ASW���6_�V����F�g���[g-rha���Yf`i�?�YH��m�����*p�v8L�ՠ�rI�<��赹s�E2?Z,t�
��9�$xɁ�V���y5�F��y�+u(��|с0+}���Ν5S�1%�yz�~�lMm��s������q�	�Ct���O�\�'7d�9���I��:�e.h�!���(��P�!,Z�;�V���?�.:?��Q��tY��3�UD�~1�ɏ�M:�r����!#֖D��<O_�V������W?�q=���	L�T���wF0�������~����]�iGL+����dX�s�Y��c�p��a��]#��`��N�>W���ZW���5�!_X!G���I��rx���9�NUց��±�m����D�i����sĹ&��O�Ծ���.���jr����>�N���wR=���ǩ��PEΣ�yUd	M悩�q���jU������v�N�)�'�݄����u�����ٱ����P�܁U�#�ji��q��fEr�	�%��%�Y���	��0�1%g	��}�	@��m�\�9Fpyۣ�U�A��:��Ti��(�8�K|��AW�Z��,_����?��i67��qK��imH'��#<C����Z�q���Z�����a�q2���
��+��-Z/,��#"��:�
hV(Ñc�����z3�9{!j#�3 �C:�.��z{!
������!��C7و$JB
t��d}$½��-��%��[i'�ah��5Z)Z`ւ�_4�����d�R8j+����9*��R�(��;r�s7�"��<�?S=�.[?��k���@CB*1��8��FrQ��'�G˲<ŧcG��<����O���Z�
;P��KTC^��R��q�/‰�\��W^i��^��a��n�_�����b,`r�!����bza
u��bR���/v��cʓ���-��gj2��$#�kgbP2B$Kmlg2�k����krI*v9�yl�*wW fhm�}̧E�Nmlj?Fiq$
�p
j�͹Isr?�:{�)uIL9�sSv�
#قx���dʷr�x������x�f:4�H�z�\.d����2���-o�""��' 	�B�v��!�Ő����Ъg����ip$�"��[@����ȝ�!3TM���o�X��wr���N����k[ⴲ9�b_>ЪS�*��S�|�Ҡ!��|���r_%�p��z�,����r5�4Aa��6z�'(��J`6��ѐ�J����QbO��XV@�j���R|t���J��B��w`�R@��&���u�z@�l�Th�BSY�Y���z�
o2"��:K��Tߓd�J�zG�e��}����:�J`a��ٺ�6hL,Bݢ��W���"��i�X�4�J��r�/��R��	l��6��C��t��B���H+�"���%��b�o�Î���2�PY>����&��w�����1+�o��f�3�S���Jbj����*��O����c}F��
Hr��X��zB�j�e6���7�P�~�+~�%H~�ZneH9���f����-��t�S�_�o)+SD�p�.
�/�P����
3@8������x��I�S��;<t����ʜ�4/�c�O%M�r�3��}������8&�\��N���VG����#��d��9b���z#Q�VjOS����*�����V�$�c�s=C-� ;�B�v�v=#;?YN&ˆ;(c ��0C�*�'vZr
+�-�����|2KK�����6��$�ޓ;��2j�?[���i�?��D7�B�H�]8��4Cr�b�}UTE���M�4Gc��_̛�K;����N֥Kk
�
���SL�$�@�Ӌ�M��x��b�O�n�W��P�]�g�?��N��%�X�;T[�qpA`Xk����mw�\{WzR9�1a��޶x8�g����Όh+�d�����j;4-	�p+<��'q�q�=����s[E��4�Wt�pn�K�(uSQU�,��`s[%���c*vsN�yѨQ�v+����U�x�Z[C^��w��X��sC-�S��ф�H�R�ڈ;���]M�����-��
-�����$�ƌ	�cE��Y�4��^�곑��?�q�˵c)�=&f�K��)���ӛ}�NJ?����1GI���3����Cs�-��
��
ޓ��3إ��n����� q�
��c��_`B�X�����`vLJ��-�EӴ����#[��wpɳs��}~�0c�L�vv|͠�k�
:;��d�_�'�彻|Z#�k@���.;� �;�	�
M�Y�#��P2����S)�7�2���#C|7Y]�g�O���K8���psǻ1)H��i�k��\_�����ROk��������C�գ��J3חn۳�O�����
u�������!��#��,���T���[9����v/��t�
.
�3�I(����cf:���JM>����۞X���n��R#��C��ݽ�zY�ý��\��L�vL(���C�D"�ӈ,��8�����)4=��kޣ,�5��ÇI��������[h����#ȟ�v�
����q�����[�|��N�+���w'm��*�T�b̅� ��3	Tw�	���*
�@vmk�,V����ШL�;J�,\������t|
�0kО��C�sqP�<��h/��tD��1پ<�SU)�
DL�V�m��̨�ITO"To,�N�#4ڙ/�2"f����"%F\��/[�&��E`Q�/*�qd����+<P�l�� �+���M�5(�0���T���3�x�A:C�3D(�z8eM�5<@
���6t��`Z襃6�I��a���9d�����H�9<����cՑ@1+Z�2��B\�����/�D��;=6E���*�0G��1"�rNJ�k�z��EL�kLH���M�HN�A��M<-���,Q,�j$S���U\�_/h']KU��X'��Z\�0�_[�
�_��G\4��Qkx__���(
7�`�y�HE;`Yek6b����0p�b�Ml�,�;5d�����e,�Q����i��#��7k�i�zh�4skĒ¡�ŕ�mL�
�j�mLUFӶg�o�7���ɔ�p,��r��o������ky�!�2�Y}D(�1���7~�����V8���(��>�ԭHO�Y҄��[fU���<,h�}fi-���
Z�<�\Y���|����pg<ϣ��0�������L^œ]��+Ӛ��$�=��DŽI��n#Fg�V
�LTNp�`��� v`O��d�mt���Uk��_��dm��E��z���Yx71�4�g��<)��o��5,9��ɝAD����H��U#���e�H��޿�5��c���}��Ν��G����Ea��p*���!�$�U�dj�$(L�8&�\�@Gv��`œ�D�߄���
�9�0,�����}�Ҝ�FdF2S�Ɂ���KՄ�^�.��֜eޞg��<vǎ�`z��vW�l�Oդ~��*&פ@�2�X8�Ҥ��N�o��DR�?��1����3c����xL�J�h�t}G;�]!�4��z>s��DSe�x�
���W�
��,�F/�l������Ojfk�����6���4���K��ٓv֟��t���f��dp���m����/(v�L�("ԕ^��`�MJ�<&�4*7��L�[���—��:g?e��$^�GZ����p������V==�+W����td\�����͕��e9��FĖY���T�V��nP���CC	��d�����`wPUl!"՚p���'2.����|���g��Be]Sͩu�Ѱ݀����awY
�AL���ϝ���:��6|��9�>{�~��d=����������y
_�4e=���^�$ej2i:��	+�냐�{!�+��p7��u-k2sWy�.�-עG�)61��
~��2��4��D�2�pYW���9e�>	p[}?mQ��g�sF��ƴ7~�G}��K��KH� 8-�oaEH���WJ�[LŞ�0mi�M����#WN-����Z��P���&u6Q%Ǹ�;�!V��	�p{�X��7K�l��Ze���I<a7^�ӿ��p�`5��56�b�N����f�}D ��/�i�}ݛ��9p%		AH��t�G�o��6�v�d��^
�w�`j�;�_x�K�Tc���x��K����v��P��Py|Yq�w��}�xc����~����?�GY�o����M�����4F��=�m^J~��(o݈=��śg����%�{�ņM>a��x�Ň/�-�� ��-���H!,J�E��.;��
�+Йg~�]���R�T��q��^��'���w�׍��\r9�y ��5A��n����Ƙb��.�q���=���x��9u����\0�$���D>��Nm&�吏�0$��������9�
k��^ @�]橦*�Ӵ�m��>&V��Ňi��*��U2N��O�!���BR�c�]��l8�p��=5���"���r���������^Y���7��ƶ
YV�I��R��*��9�$��e��}>&^����nj�
�=��]���������Bi�E`V&��� �%G��1��Ɲ�#���\�
t�]b�R�e`Vj�T^���9��J�Z�͕N~�ؽQ�$�.��ٽ�������(
����ᅬ��D��%�"}e%���)�s��@�u�&�>
덛]�q`4�y��������7�%��=�-B�|-|���0
�]���>�h&y���0`r��/vFV`>��������)]{�C	F��ͻ2	�#�"�����e����
6�k"�b�X�[h*����V|�U����,�
�<�R�O;��K�E�&��x��l6mܙ|��*�'Z���J?��$�c8Ī�	 ~L�x � �q=���s"3����d$^���H�:%N�����û)޺j�)��}X���3�7S��y�7��ź�z��=�<�6�&�@��p�-�E���x�m]Gv�puV�3�I��'A�\�L>��z��Lv
s
�WD�O��~�@CB�V�p���>DV��E�����Y�}��Q�.SZG��v��\.�`IͰ^�Z�Gz�_�6�w�� �^��ܗ�~`��Q#�afh�y1��Vg^���&��ni���4�lֿ�aч�n�����5o��q�:�p������wpޡ>���q�Pk��}@�r~b�N,)�qF�X*c��wޓ��u4�y��{�2w��y�˦��k|>�SSEe�L}�v���}V���3[��3&����5�&��@�莆&�����z�v?����F����2����2��&C<D�f�̧���Ƥ���JPÍ�F׃�P`���p9;����^05iZ��X�YO��L�|��ܗ�K����4Y�&�N��ps�� ���\�N��T�������2� ����X�q����‚t L*�Η���p��~����]���g��T֤~+�H�,�v���O>z��}�&2@d��8����7�fϸ��X���$��0�C4�~�<�Ȍƴ�����´L����7���D��)�!�.�2�H�߂��n��6��^'�v�i�����b�\�B��.�T���fG��V���Ψ`��%\�.ĵ�0~4���r;�,;�.ֽE�4̎���qa4���6�<�~V��/wٶ�^&�e�?�F4c٬��F/:�͵�ߎ�S������f���Ԛ��Y��G���P�/�喿��\G�nv���Z羬�?ha>��o��C�#�6TIqP~D��,��`���g���b�s��^�m�n5����,��F�8D��}��>���4���OIX�ϝ����Ϗ2�4��>d�,��g�>�/2�*d�"؎�q=��l�$$�GO���ϚI���*���mFu�o��'ݳ�Q�D
@\�
�R0��W�
�LF�+��
υͦ~T�'EǗ�y�
?��et{O�F������1�s�[�'r����@�4�ͪ�w"u���7i_�k�aomlK���#�"#�]��%'X���Z�
)�fW���٪)�|"�)w?5��-	�,=�
�+�"!��0,O'�LL�58�4�����9/᷐�n	�9o�t�
�H�;�V�o��>�z����i@g�
)�5d�D�Ւ��
D�0�x'�Dhr���AI/���8B)K�I/����N�qbn"U�O�;����R��et
�S��S�
7S/M�j��Y�m�\�~#}[�f����\ŴBW/�]�X?��1<�]�P8��:�^���s{J��`�]������bX,��6��c���+��Ob7I=�֐�b�m����ui������\�j�]�Y���kw�v�m6n/+��]
n��/��T�vG܂ܘDz�_2B���{�0a�8�J|W8y�a�,:�������l����n�Vi����"W<�ք0v��+Ʌw�FOr<�a����t�80"��p�E��q�{%�#d��7S˓o�ނ�Gx�Gn�ώ�{�W���:A��Q1�����Ǩ�gO��������=}����9o�㥗�s��챥������֧�'f���ӧ��K/.�!�`�w�|�ꦰ֭��p�l�UP�o����%��o,(T�����/��D�	h��/��;?�����mD��x�f���
�O�|C>����Xz��F��O����݃���e�V��F������-/?����������s>�?jj���QmGI��՟5���מ�׬�;����J�l0	x��س�����/tc߬�������Y�V�'�'�y�#��ɴ��n8���fjF6��]��>h�@�V
����n�9��Iz{C��D�W
���B?�W]+�k4��U����^�?�Z90g�����sa	����IW��=HY:���9��7�.C�j!�X�-I{��w!nC7�4�o����O1CwT"�^�M������Xq���m�@�1Vk��P�o3����O�c�������U�
'Z���E���������a����\��@������7S��1'U)������`sC�����������=*�{��W�����vK�L�������T�i�������%X�������o��zy������gb������D|D��*O�������7q�3��]95�*,���{����~P���L_���z\��t�����59xyI0*�OI�VZ���XPXw����6���`���
w������{G���B���"h���{v:������N�������L���Bih�}\N�d����'a����U.�D���Ar��F�������-��/s��'6fJr)[�2EW����������_�q��@�����3�U�����8C������]\��u��
�8`��������	�	����Fa��=�T�����ul�q
4�k����������~���`z�9��5�����(Y������Z%�8���������D�0P�QN��~b�$	f#�5���&�{?3������[���������;��z���X �N�G���95���������p/~�	=������0���O+����:u��@�R�,X��x���=}�����0����w�iq�������H�K�������{d\[lY19��i7����/��
u[e�'QgN�\
z||��!��,����N�;��s����u�������
���n
�nC�?�y���xrE<7g��8���Q���=����o�����B2�
�����O�"7*qRz-@��������F�.kAV�W��1���������R�>a��
���oG�8F[��O�-����r���x
�Y��-�oHc�>�u	y����������hP����V����|I]:J�%,Pn^!EQ��$�l�O{
o��������u���f ������S���~!rC)+��P��L@.X���2MR�����WnjJ�ME������e�}�F��X�&$��5���/���q��r<v6Xl���4a�G#Hh����������`m���x$t4�Z\������������3�V&i�'g�E�*��{��R3��j��Nf���G]	�DL& �����"��������������gU#dc+OA{I&t2����+#[mIy8�mI-C8:����Jb+�!�����m��^��
��f~�g=A����t_����������AQk������������g������cxW��Tt[�n\������M���_�a�'���"��n���������q�|5Jt(�<n_M�0JezI���s���9� c�T�<vGfbT4�'�a��`�z������+@��]t�v����+�J:�+|��'����������`~��������[����.�����J!��M��������#���O��FP�Q��+v|On	���%��1�LF�X@���5>�����������b�����t������g�8���E9�?������v"�N\��VSs(I����O�f��{�}M5,��b�=S�)�����pP_�!fVk�����KNK],A��wW�3Q���'��U��\��NfE��"�@��{1�������o�������~0Z^�8�+/���)�kO�qxMy�*�������T$���g��{l6�$WU"�#fc������g@E�:���	����N���+>{���������R[:y��
����j
9��{�$��8��ndT����^�3ZfI�{$F���fb;��������A���<����N7`;#�������Vu�e��`�fS���v�����G}�	n3���>8�~���������`Iyh��f=��P��[���������9(ty�Y1�����c���Z�Z����4��z��=�����@�.�a�-0g�����sa	���c/home/palash/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/crossbeam-utils-0.8.21/src/lib.rs� =�	S�U����䌆6�n4=Z.PQ:WR'-'#

*?	#. 1_GJ;QU?H
:. K-1`-TG-*TG
 9*
!{��lqK �����4�	go/home/palash/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/crossbeam-utils-0.8.21/src/atomic/seq_lock.rs� ������|�5/�M��l��p7'a4((
2><8
Aa\?*4$>&B2+ %
P&": >C&"5C
-4
$
3Nc���G���_��rYvn/home/palash/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/crossbeam-utils-0.8.21/src/atomic/consume.rs� �]*�JoX�H?{����o!"T)INQLOPO'MO#)!T>WRB37?.@7/
!7?.)
")=
=
 ""HHHH!==N���T���}G�8�S��f/home/palash/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/crossbeam-utils-0.8.21/src/thread.rs� гU��j�މ�P��|����6O! 0
L"-,
 b5	%L0	GbPd[_``cc,`_*!H24c=! L4
(..a^b]]w!C4"!%'
 ' :MBW1+S<2.KA/#&
"->65." dd>d!HJrD&V%%'78.!R
&5G%BP-
 ?/)OU`0a`!;(4*$1)/ 7*5N%"/L5O0
7-W%'?-T6
8d!\BF(E%%;8.!N
&2.H!.L(:;&!(b4()E9NRB8/-2=>F"339B+)-2/(9&"?aac4%JFC&"C&#-a?BNC3%MI.
!<8/cC64
0 
!!G6/cC65
80!
1?)cd��on<?������r/home/palash/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/crossbeam-utils-0.8.21/src/atomic/atomic_cell.rs� �GC��?��2)�\T�����	>62.+^a^/^B66bdg?6Yd'//(+:1$0;
=Z01$ #,W'W9(K[a1Z&?,
N=@<aQE*#+1$!!"$"2
J1$!"!&3J1$%%!W1$'&,1$!.#Rc 1$1!1!/;>4
RaZ1$6!5!IMQgli'1$6<<!<
"$)6'4
Q8!$sW</
de@,
aV?=CDD-D,H 
(V09/*5C>"2V39/)5C>"2[9/)5C>"\9006C>"'Z9/*4C>"[9/)5C>"N09/)5C>"-N09/)5C>"-
-V09/*5X;KF*:V39/)5X;KF*:[9/)5X;KF*'\9006X<KF*/Z9/*4X:KF*'[9/)5X;KF*'N09/)5X;KF*5N09/)5X;KF*5
AADDDD!D!D&C&C JJEEJJS1'-$.%1S3C>"
T1'/$.%0$2S4C>"'
R1(.%-$0S2C>"
S1'.$-%1S3C>"
-$&$':?%*T)\b_d_^Y
+\#[`C_*	aa]F:d`(32C,#&c+

1<
+3:dcbaW_L/.Q&&]
&c1
1C
5"
/b5
1a
5#
bPb!_
1A5/!&'0+K91a_`&,4
4(+*a
g�J� �C֮��wl/home/palash/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/crossbeam-utils-0.8.21/src/cache_padded.rs� 2y�}ǯ��E�n��;�";bab_O28`\d$aZ&@22"_c&(((5`Eymq@+rz	 !!#Goprsxz	" "!%v3'qw5?opxx;
 !!#" "!00?*0/&!*0/##&(4?&)%8?*�|ݫJ�Riʼ~��>\g/home/palash/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/crossbeam-utils-0.8.21/src/backoff.rs� �37;�HI�\�Ya��A�0Sdb_
%"(-7&&V
4"'-'&$
]b"'-+&$( "
,/$2.!&&'&&'bJ)&,1;**Z  
%)(;
+0
&]`@L`V 08&+1!+*("
6$ 7(/.�6+/#)/#$(
,0
`a&+1!/*(,$&
6$( 7(/.�6)&?"'9���=��w�<��\T��n/home/palash/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/crossbeam-utils-0.8.21/src/sync/once_lock.rs� .=��\�K�]�,��X*} 'J#4-"(;
LHLKHL64
&<4
8("
%!;&+1'&<?
q�e�V�E{�HB�t�X�k/home/palash/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/crossbeam-utils-0.8.21/src/sync/parker.rs� ����o��)կw���e�E3$ X_7b c`c'"!436�+-!%!(4**"
 +E+&%8(b!+Z444<!
b,+DZ#51;`+&%8/*0+'41*0X+'27/"
?:!!Ca
!+& 7:�/37&)63/3Z7&)497
?!"'

0`?

L+,
;/KUa_ddK:NH
E!4$.(cb8M\?9SC&dQ
"cbdS264<9
^c`badO) p��xk�w��+.}Ue�q/home/palash/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/crossbeam-utils-0.8.21/src/sync/sharded_lock.rs� �!�.�Pmtj���TD��!-GC#&C4&3d0D"bbcI\dOV^``3,$5''/1+%"$6'9@1420(-$-/<(+
;d04
/(
</.-)
!0cI02#(10.(*<Yd0,'/6.7)
?bb^-d0( (&Kbb:C93&23 .*EL
]`cd0Kd_02#& # Dbb:C53&D*&
Cbab-d0(&,M" 0;7$6%%3'/R<%
#>:@0!*0&A'&
a`cd0Nd_0(++F"0*3$%%/=R<%
9&'&
=? -)2-2/*8O0.7
.%-%V 1%2F8+A?/'N?Z 23G8:5<,
B?0'O?9+<(/:aX^
&0I1' >7M(#%#%.G<1,*0<4,)2
3�o�)ڳ�.�kE!Źj/home/palash/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/crossbeam-utils-0.8.21/src/atomic/mod.rs� d[�;<h�`
�lR��~�
 =Z"_\\,�C"PMV"!
�|lKF[�?��8��h/home/palash/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/crossbeam-utils-0.8.21/src/sync/mod.rs� 6�ե����	W"_��x�'.PQ*X̫6����K�uݿWu�o/home/palash/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/crossbeam-utils-0.8.21/src/sync/wait_group.rs� k�D��#��J{5���3MQf`&eH* 7 59�$"$&&
I.#O.#!C;�4
(55
:*
#:'
 ?@C��cC�f9���8�GFUGqH�I�L�QeS)U,VtX�[i\]x86_64-unknown-linux-gnu�ɟ��P�#�}
�Gr�crossbeam_utils�-30ff13b172e89a74�C��D�W
�ϼ��;����������:�����������������������������a���������������
����
��
���������
�
���������������������������
������)�����
ɀrust-end-file