📄 libcrossbeam_epoch-898edee4616dca8c.rmeta
/home/palash/git/iron_learn/target/debug/deps/libcrossbeam_epoch-898edee4616dca8c.rmeta
Language: rmeta • Lines: 3869
rust
+�#rustc 1.92.0 (ded5c06cf 2025-12-08)���	ⷄ�ۆ��p��-225863f279df55c4��١�	�T�6a��D�
-5080178c80bf7a93��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�crossbeam_utils�ɟ��P�#�}
�Gr�-30ff13b172e89a74�loom�$�crossbeam_loom�t�	primitive�L��t�tests�,��$ɤ��,��$���,��$��MAX_OBJECTS�\�crossbeam_sanitize����
$�����,���$����,�P�$�P��$�=�$�=��,��$�
��cell���
with�R�impl FnOnce(*const T) -> R�with_mut��
impl FnOnce(*mut T) -> R�����	

strongest_failure_ordering�/CompareAndSetError�1'g�1�1P�CompareExchangeError�5�
5�5�
5current�5�
;�;�
;�CompareAndSetOrdering�?success�?failure�B�B�E�E�low_bits�H�ensure_aligned�J�compose_tag�L�
decompose_tag�N�	Pointable�PALIGN�PInit�Pinit�P�T'a�P�V�P�Y�Y�Y�Y�Y�^�Y�`�Y�Array�c�c�	celements�fh�hlayout�k�k�k�k�k�p�k�r�k�Atomic�u�udata�u_marker�y�{�}�}�
	����������	��
�load_consume���
����
�swap���
��
����
��
�	�	����
��
�	�	����
�F��compare_and_set���
�O���
�compare_and_set_weak���
����
�	fetch_and���
�fetch_or���
�	fetch_xor���
�
into_owned��try_into_owned�
������������
���>��������������
������������
into_usize���Owned����������������from_raw��into_box���
�����into_shared���
�tag��with_tag����������������������������������borrow����
borrow_mut����� ���as_mut�Shared���
������!����"��#������$��
���as_raw�%��
�����is_null���������������&����'��
����(��)��
����*����+����,����-���>	collector��������	Collector��global�����>���
�register������������LocalHandle���	����	is_pinned����	���
��deferred���������
DATA_WORDS��Data���Deferred������������NO_OP��
no_op_call���
������������epoch������starting������pinned��unpinned��	successor����
��	����guard��������Guard���	��defer�����
�defer_unchecked�����
�	�
defer_destroy����	�flush��repin��repin_after�����
�
ScopeGuard��
��������	�������unprotected��GuardWrapper��
����UNPROTECTED������������	�
���
��������������������	�Bag��	deferreds����	����
�is_empty��try_push��seal���>����������
is_expired��Global��locals��queue���"��
COLLECT_STEPS���
�push_bag��collect��	�try_advance��Local��entry����bag��guard_count��handle_count��	pin_count���"��PINNINGS_BETWEEN_COLLECT��������	����#�	��$�	������$�acquire_handle��release_handle��finalize��	�	�	�entry_of��
element_of���,��list�����������	�	IsElement�����,��,��,�Iter���
���j��#�pred��curr��head�����>��delete�����j��
�insert���
��	��
����j�����
���j�����	once_lock�����OnceLock����once��������������
�get_or_init����
initialize����	�
get_unchecked��������)����������	�
��Node������������������
�
push_internal��push��pop_internal��	�	�pop_if_internal����	�	�try_pop��
try_pop_if��������	

>���������	COLLECTOR����	���	�default_collector��with_handle�����
�	�	
UnsafeCell��
���������Epoch���������>�����������AtomicEpoch����	�>�
���	SealedBag���"�_bag��
�>����Entry�������List����j��.������j���	IterError��Stalled��
�����	���Queue�����.�tail�������HANDLE��__rust_std_internal_init_fn���	�__RUST_STD_INTERNAL_VAL��	��:88;8>8>8>8@8A8C8D8F8G8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8?P���_����5���)��dN|j��_55�
9�
:�
��d�M�8��
?����������������G����F�����,^����?�G�GP�GP
����MaybeUninit���uninit�������B1}-�hn�G��uu�w�x����#k��G��I�_�I�_�I��I��I��I�������{� p0�`k�G��I���Box�������lf���]v�G�B�B�B�)����I����I�G�uu�w�x����#k��G�������U$��;	�
�G��I�G��J�G��J�_�J��J��J��J��J�G��J�J��J�G��J�G��J�G��J�G��������U$��;	8�G��N��N�G��N�G��L�L��N��L�L��N�_�N�_�N��N�������xᓄ1~~���O��O��O�_�O��O�O��O������	@��\�?���_�P�_��� ���������;���(������6���(Y^�lG���Q��Q�_�Q��Q���Q��Q�Q����7���n�%���_�R�����%����z7�m�o����#��	e7,*J���_�S�����%�����[��x*�����'��'���	�@֙�t<���T��T�_�T����7��"���7�c�d�����_�T��T����*��*������*��*���*���*���"�f�1m�l�U�_���8������i�C�A�_���8��.����ewK'�0��Gj������8Ŭ�1�N�&��W�W�_�W��V��V�J���-��#���.���.���.����4Ci���
�Gj����0��0����ç�p����G���Y��Y�_���9��.���9�Q)�����<�G��Y���Y��Y��;5�u����������������������������B��E
Yk	yu��������{u�����������u���u���������u���������������u�u�u�u�u���������������������������������������������������������������������_�?tP���!�_(�
�"�7�3��8��������������J��%#$�%
#�%
�-�G3E�%��$/
��G�%�%��$��Fl�$�G$�$�-�-�5�-��*��]����G��G��Gv��3
	��3
��G$��3*[,�3$_��<
�bg+�b6=0�ܱ>
	̱>
�cc�e�	f��J��Йb��GW��>1m�b,�>$_���U
��U
���V�b>\�V
��G��UY
u�G�V�V���U��IL�U����b��v��XU�t~�-�����PhantomData�Rҹ��^=x�e���
�b����b,�$3�T�
��b�&�b18<��b
DATA_WORDS�T�
�0�h�h���
��
��b�b9\�
��h��y
��	�����P$��h�h�����G���H������B1}-�hn�i����eRҹ��^=x�i��_��
@�b���b,�$64�\�
��b�&�b18<��bMAX_OBJECTS�\�
��b�&�b18<��bMAX_OBJECTS��,
�b��,��b,�,%8��V
��b��V,��b,�V%128�\�
L�
�6'��&��
��
��G+8
?|�
�-�HO`���j
��G�������Y$��5�5Once��5inner��5=d0ݞh.��-�-�5�-��*��]����H)�H(��R��a

�R�a
��P�R��a�����������������;t�������������������;t����P�P�r���Q�t�b������p�3#;Z:��`�P�Q�tbW��r�r_��R�a
�R�a
��P/5�R��a
��r�s�h/�r	R�a�R��a�R�!�a
��u�u�h#�r	R�!aM	R�$a�R��a��r��u�u�h���u�u�h�S_���
��G�)�F4�a;B��q	
��%�R0�U9@���	
��&�S1�S8?���������,�+���/1����0?��4�1u��
��15��,�1���L�1P��<�1���4�1���L�1���\�1���%\�1���#,�2���5��2���L�2����3����3�#  Epoch-based memory reclamation.�$��(\Y An interesting problem concurrent collections deal with comes from the remove operation.���b_ Suppose that a thread removes an element from a lock-free map, while another thread is reading���`] that same element at the same time. The first thread must wait until the second thread stops���=: reading the element. Only then it is safe to destruct it.�����]Z Programming languages that come with garbage collectors solve this problem trivially. The���a^ garbage collector will destruct the removed element when no thread can hold a reference to it�d�	 anymore.�����a^ This crate implements a basic memory reclamation mechanism, which is based on epochs. When an���`] element gets removed from a concurrent collection, it is inserted into a pile of garbage and���c` marked with the current epoch. Every time a thread accesses a collection, it checks the current���a^ epoch, attempts to increment it, and destructs some garbage that became so old that no thread���" can be referencing it anymore.�����b_ That is the general mechanism behind epoch-based memory reclamation, but the details are a bit���`] more complicated. Anyhow, memory reclamation is designed to be fully automatic and something���	C@ users of concurrent collections don't have to worry much about.��
�t�
 # Pointers��
���
b_ Concurrent collections are built using atomic pointers. This module provides [`Atomic`], which���^[ is just a shared atomic pointer to a heap-allocated object. Loading an [`Atomic`] yields a���a^ [`Shared`], which is an epoch-protected pointer through which the loaded object can be safely�L� read.���l�
 # Pinning�����b_ Before an [`Atomic`] can be loaded, a participant must be [`pin`]ned. By pinning a participant���
XU we declare that any object that gets removed from now on must not be destructed just���\Y yet. Garbage collection of newly removed objects is suspended until the participant gets�l�
 unpinned.���l�
 # Garbage�����a^ Objects that get removed from concurrent collections must be stashed away until all currently���^[ pinned participants get unpinned. Such objects can be stored into a thread-local or global���RO storage, where they are kept until the right time for their destruction comes.�����kh There is a global shared instance of garbage queue. You can [`defer`](Guard::defer) the execution of an���_\ arbitrary function until the global epoch is advanced enough. Most notably, concurrent data���74 structures may defer the deallocation of an object.���T� # APIs�����a^ For majority of use cases, just use the default garbage collector by invoking [`pin`]. If you���IF want to create your own garbage collector, use the [`Collector`] API.�����8�$���8�|�$�8�$���8�$���8warnings�D�$�8rust_2018_idioms���$�8�,���8�L�$�8unused_assignments���$�8unused_variables��������������W�X�W1��V?��Uu��
T5��S���RP��Q���P���O���N���%M���#L���5K���J���I��psvl�L��d�*���$�����#����G�$�F
��$1�$�G�F
�G�6��%@$�%���F�
�
�
	�

	
�%�����%������%����L��&��������&
�G����$�%��%_a[]��&BD�'���F����
�

�'˚�'����Ė'����e��'��ܜ����'
�G����$�'��'_a[]��'$�(I�*�5��(4�(�t�(�Z�,�)�Z\L�)�Yb\�)���D�)����(lacRTDF68&(��)���*$��+�T�+4�+/15?HJLNPcu����I��4(�g4C�hLK��a��p�[ �e\��!�e�!mem�$��#�G\���$�,��&DerefMut�D��'���(�,��a)�#,��*b\���,�D���-
AtomicConsume�l��.�o�c�4!X[MPL[DLj8�y,��
�������L��\�Ĝ����7������&~��8ԙ�G�G
/ord��t���%��;8 The error returned on failed compare-and-set operation.�"Use `CompareExchangeError` instead���:�����
2�3�
4423���G����G�55�
9�
:�
��d�M��
�G�G�TVQS��I��<9 The error returned on failed compare-and-swap operation.����
6�7�
8867���G���P�GL���G�GT��G�
������d�M�9:�Z\_aԪ	��HE The value in the atomic pointer at the time of the failed operation.�<�	55�LT�
��	74 The new value, which the operation failed to store.��
55�G��
Q8��<�
=�=<٤�
��
��T�
�_�GT�
�G>�_>/146��
8�
�����G��^�^��^��[�^buf��[����e�S����������������������q�aX�hÅÅą��:����;�
;
>8�G�G$�
��
����41 Memory orderings for compare-and-set operations.�����
[X A compare-and-set operation can have different memory orderings depending on whether it���
\Y succeeds or fails. This trait generalizes different ways of specifying memory orderings.�����A> The two ways of specifying orderings for compare-and-set are:�����^[ 1. Just one `Ordering` for the success case. In case of failure, the strongest appropriate���    ordering is chosen.���\Y 2. A pair of `Ordering`s. The first one is for the success case, while the second one is���    for the failure case.��`compare_and_set` and `compare_and_set_weak` that use this trait are deprecated, use `compare_exchange` or `compare_exchange_weak instead`������Ӱ??�����?����@A@AA@����30 The ordering of the operation when it succeeds.�<�Ӱ�����G?�?
@��$�����0- The ordering of the operation when it fails.�����]Z The failure ordering can't be `Release` or `AcqRel` and must be equivalent or weaker than��� the success ordering.�<�Ӱ�����G?�?
A��$���'�GCD@ADC�<����G�GB�B
C$���<����G�GB�B
D$���3�HFG@AFG�<����H�GE�E
F$���<����H�GE�E
G$���-D��b�II���G�P�GL�
H�G��4t��b�h�KK���ºL�
J�G@���G\��b�b�b�MM���ºL�
L�G�$���#%��Fl��b�b�b�OO���ºL�
N�G�$���'�� /, Types that are pointed to by a single word.�� ��� b_ In concurrent programming, it is necessary to represent an object within a word because atomic���!_\ operations (e.g., reads, writes, read-modify-writes) support only single words.  This trait���!>; qualifies such types that are pointed to by a single word.��"���"\Y The trait generalizes `Box<T>` for a sized type `T`.  In a box, an object of type `T` is���#c` allocated in heap and it is owned by a single-word pointer.  This trait is also implemented for���$da `[MaybeUninit<T>]` by storing its size along with its elements and pointing to the pair of array���$ size and elements.��$���%]Z Pointers to `Pointable` types can be stored in [`Atomic`], [`Owned`], and [`Shared`].  In���%GD particular, Crossbeam supports dynamically sized slices as follows.��&�<�& ```���& use std::mem::MaybeUninit;���& use crossbeam_epoch::Owned;��&���&JG let o = Owned::<[MaybeUninit<i32>]>::init(10); // allocating [i32; 10]�<�'��L�'PP����'�P����QRSTVXQRSTVX����RT�(��XVTS��(��' The alignment of pointer.�,�(PP�bL�(��( The type for initializers.�$�(PP��)*��(-* Initializes a with the given initializer.��)�d�)	 # Safety��)���)/, The result should be a multiple of `ALIGN`.�$�)���bPP
S���$�)��,,��*#  Dereferences the given pointer.��*�d�*���*���*LI - The given `ptr` should have been initialized with [`Pointable::init`].���+DA - `ptr` should not have yet been dropped by [`Pointable::drop`].���+XU - `ptr` should not be mutably dereferenced by [`Pointable::deref_mut`] concurrently.�,�,�b���P�UUP
T�����,�,��/4��,+( Mutably dereferences the given pointer.��-�d�-���-���-L����.D����.ZW - `ptr` should not be dereferenced by [`Pointable::deref`] or [`Pointable::deref_mut`]���/   concurrently.�L�/�b���P�WWP
V�����/�/܁3��052 Drops the object pointed to by the given pointer.��0�d�0���0���0L����1D����2Z����2��$�3�b�hPP
X����3��3�ZZ���3�G[\]^`bQRSTVX^]b`13��3,�3YY�bL�3$�3YY�G��4)$�4�GR�bYY
]�G�$�4��4+,�4�b��GY�__Y
^�G���4�4��53L�5�b��GY�aaY
`�G���5�5Ԝ6$�6�b�hYY
b�G��6|�;,�;�dd���;�c�J��Йb�efT�;�;cc�b��;D�;cc�H�b�0�b��<�ii���<�cj	��<4�<�b������}���}/i݄���
hh
j�G�	�<��=&�ll���=�HmnoprtQRSTVXtpro13��>,�>kk�bL�>$�>kk�b��>($�>�HR�bkk
o�G�	�>��A+,�A�b��Hk�qqk
p�G���A�A��B3L�B�b��Hk�ssk
r�G���C�BԩD$�D�b�hkk
t�G��D��I(��E@= An atomic pointer that can be safely shared between threads.��F���Fb_ The pointer must be properly aligned. Since it is aligned, a tag can be stored into the unused���Ga^ least significant bits of the address. For example, the tag for a pointer to a sized type `T`���GGD should be less than `(1 << mem::align_of::<T>().trailing_zeros())`.��H���HPM Any method that loads the pointer must be passed a reference to a [`Guard`].��I���IOL Crossbeam supports dynamically sized types.  See [`Pointable`] for details.�4�I�vv���IºL�I�I���#k�wx$&��J$�Juu�e�J<�Juu�f��JC�zz���JºL�J���G$�J��G$�J�I.0��KC�||���KºL�K��$�K��$�K�I!��K�~~���K�I	��N ��KRO Allocates `value` on the heap and returns a new atomic pointer pointing to it.��L�t�L # Examples��L�<�L����L  use crossbeam_epoch::Atomic;��M���M let a = Atomic::new(1234);���M41 # unsafe { drop(a.into_owned()); } // avoid leak�<�M���N�G�I}}
�G�$�N��N%������NºL�N�I�����������������BD��Q'��NR���O�t�O���O�<�O����P ���P���P&# let a = Atomic::<i32>::init(1234);���P4��<�Q��$�Q���I��
��G�$�Q��R"T�R�b�I��
��G�$�R��U ��S&# Returns a new null atomic pointer.��T�t�T���T�<�T����T ���T���T" let a = Atomic::<i32>::null();�<�U��$�U�I��
��G��\D��X-* Loads a `Shared` from the atomic pointer.��X���XZW This method takes an [`Ordering`] argument which describes the memory ordering of this�t�Y operation.��Y�t�Y���Y�<�Y����Y1. use crossbeam_epoch::{self as epoch, Atomic};���Z,) use std::sync::atomic::Ordering::SeqCst;��Z���Z����Z let guard = &epoch::pin();���[" let p = a.load(SeqCst, guard);���[4��<�\��$�\����I�G��S�������U$��;	��G��\�
��G$�\���\�\(*��d=��]OL Loads a `Shared` from the atomic pointer 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���aJG would expect in practice since a lot of software, especially the Linux���a" kernel, rely on this behavior.��b�t�b���b�<�b����b1���c��c����c����c" let p = a.load_consume(guard);���c4��<�d��d�d����I��S�������U$��;	��G��d�
��G$�d�d!��j9��eA> Stores a `Shared` or `Owned` pointer into the atomic pointer.��f���fZ��t�f���g�t�g���g�<�g����g1. use crossbeam_epoch::{Atomic, Owned, Shared};���g,���h���h����hZW # unsafe { drop(a.load(SeqCst, &crossbeam_epoch::pin()).into_owned()); } // avoid leak���i$! a.store(Shared::null(), SeqCst);���i&# a.store(Owned::new(1234), SeqCst);���i4��<�j��,�j���I�
�G�h��
���j������j����GT�j
��G��$�j�
�j���j;=��p[��kXU Stores a `Shared` or `Owned` pointer into the atomic pointer, returning the previous�l�l
 `Shared`.��l���lZ��t�m���m�t�m���m�<�m����m96 use crossbeam_epoch::{self as epoch, Atomic, Shared};���n,���n���n����n����o2/ let p = a.swap(Shared::null(), SeqCst, guard);���o41 # unsafe { drop(p.into_owned()); } // avoid leak�<�o��$�p����I���G��S�������U$��;	��G��
���p����p��T�p
��G��$�p�
�p���p�pDF;=��~���q`] Stores the pointer `new` (either `Shared` or `Owned`) into the atomic pointer if the current���r^[ value is the same as `current`. The tag is also taken into account, so two pointers to the���sGD same object, but with different tags, will not be considered equal.��s���s_\ The return value is a result indicating whether the new pointer was written. On success the���t[X pointer that was written is returned. On failure the actual current value and `new` are�l�u
 returned.��u���uEB This method takes two `Ordering` arguments to describe the memory���vQN ordering of this operation. `success` describes the required ordering for the���v[X read-modify-write operation that takes place if the comparison with `current` succeeds.���wZW `failure` describes the required ordering for the load operation that takes place when���xRO the comparison fails. Using `Acquire` as success ordering makes the store part���xNK of this operation `Relaxed`, and using `Release` makes the successful load���yPM `Relaxed`. The failure ordering can only be `SeqCst`, `Acquire` or `Relaxed`���zB? and must be equivalent to or weaker than the success ordering.��z�t�z���z�<�z����{@= use crossbeam_epoch::{self as epoch, Atomic, Owned, Shared};���{,���|��|���|���|����|%" let curr = a.load(SeqCst, guard);���}OL let res1 = a.compare_exchange(curr, Shared::null(), SeqCst, SeqCst, guard);���}QN let res2 = a.compare_exchange(curr, Owned::new(5678), SeqCst, SeqCst, guard);���~74 # unsafe { drop(curr.into_owned()); } // avoid leak�<�~����~�����I�������U$��;	��G���G�G��S��������������������q�aX�������U$��;	��G55�
9�
:�
��d�M���G����
���������T�
��G��$��
<��
��<��<���UWLN���<closure_kind>��<closure_signature>��<upvars>������G���b�������U$��;	�G�bL҂�������Ւ�����G����55�
9�
:�
��d�M��G��ɔ������`�����^����Gǂ������_\ Unlike [`compare_exchange`], this method is allowed to spuriously fail even when comparison����_\ succeeds, which can result in more efficient code on some platforms.  The return value is a����ZW result indicating whether the new pointer was written. On success the pointer that was���TQ written is returned. On failure the actual current value and `new` are returned.�����ÉE�����Q܅��[���ËZ�����R�����N؈�̍P�����B�������2/ [`compare_exchange`]: Atomic::compare_exchange����t�����<ʏ���֏@�����,��̐��Ԑ�������������#  let mut new = Owned::new(5678);��ʑ(% let mut ptr = a.load(SeqCst, guard);����HE # unsafe { drop(a.load(SeqCst, guard).into_owned()); } // avoid leak�TĒ loop {��ӒHE     match a.compare_exchange_weak(ptr, new, SeqCst, SeqCst, guard) {����         Ok(p) => {�Ļ�             ptr = p;��ؓ             break;�l�
         }�̅�         Err(err) => {����"             ptr = err.current;��ʔ             new = err.new;�l���L��     }�,�� }�������)& let mut curr = a.load(SeqCst, guard);�T͕���ܕTQ     match a.compare_exchange_weak(curr, Shared::null(), SeqCst, SeqCst, guard) {�ܵ�         Ok(_) => break,��Ֆ+(         Err(err) => curr = err.current,�L����,�������7�<ٗ���������I�������U$��;	��G���G�G��S��������������������q�aX�������U$��;	��G55�
9�
:�
��d�M���G����
�����������T�
��G��$���
<���
���<ј�<���\^RT���������Ւ�����G����ɔLϛ�������Ւ�����G����ɔ�������TQ Fetches the pointer, and then applies a function to it that returns a new value.����^[ Returns a `Result` of `Ok(previous_value)` if the function returned `Some`, else `Err(_)`.�؞����^[ Note that the given function may be called multiple times if the value has been changed by��ß^[ other threads in the meantime, as long as the function returns `Some(_)`, but the function����96 will have been applied only once to the stored value.�����JG `fetch_update` takes two [`Ordering`] arguments to describe the memory����MJ ordering of this operation. The first describes the required ordering for����FC when the operation finally succeeds while the second describes the��آLI required ordering for loads. These correspond to the success and failure����;8 orderings of [`Atomic::compare_exchange`] respectively.�����FC Using [`Acquire`] as success ordering makes the store part of this����KH operation [`Relaxed`], and using [`Release`] makes the final successful����HE load [`Relaxed`]. The (failed) load ordering can only be [`SeqCst`],��٥KH [`Acquire`] or [`Relaxed`] and must be equivalent to or weaker than the���� success ordering.�æ��˦" [`Relaxed`]: Ordering::Relaxed���" [`Acquire`]: Ordering::Acquire����" [`Release`]: Ordering::Release����  [`SeqCst`]: Ordering::SeqCst���t�������<�������1���ʨ,�������������ɩ��ѩNK let res1 = a.fetch_update(SeqCst, SeqCst, guard, |x| Some(x.with_tag(1)));�Ԥ� assert!(res1.is_ok());�ê��˪?< let res2 = a.fetch_update(SeqCst, SeqCst, guard, |x| None);�܏� assert!(res2.is_err());����4��<���d�����I�G�G�
�S���������������������q�aX�������U$��;	�
�G���
�������������������̭-���������������������;t������
��G�
��$��	set_order�L��
fail_order�TĬ�#,�func�$�����������ݰ`���±^�����Gǂ�����_���ݳ[��l���ϴ��״UR This method takes a [`CompareAndSetOrdering`] argument which describes the memory���� ordering of this operation.�յ��ݵ%" # Migrating to `compare_exchange`�������XU `compare_and_set` is equivalent to `compare_exchange` with the following mapping for��� memory orderings:�������  Original | Success | Failure����  -------- | ------- | -------��ط  Relaxed  | Relaxed | Relaxed����  Acquire  | Acquire | Acquire����  Release  | Release | Relaxed��Ǹ  AcqRel   | AcqRel  | Acquire��� SeqCst   | SeqCst  | SeqCst����t�������<����ܿ� # #![allow(deprecated)]��߹@�����,��պ��ݺ�����������%���ջFC let res1 = a.compare_and_set(curr, Shared::null(), SeqCst, guard);����HE let res2 = a.compare_and_set(curr, Owned::new(5678), SeqCst, guard);����7�<����Use `compare_exchange` instead����6|���������I�������U$��;	��G�G���S��������������������q�aX�������U$��;	��G55�
9�
:�
��d�M���G�G����
���Ͼ�����Ӿ�־?�������G�GT��
��G���G$��
<��
�������#,����qsuw�������`�����^�����Gǂ������^[ Unlike [`compare_and_set`], this method is allowed to spuriously fail even when comparison����_�����Z�����T�������Uͺ�����������0- [`compare_and_set`]: Atomic::compare_and_set�������*' # Migrating to `compare_exchange_weak`�������b_ `compare_and_set_weak` is equivalent to `compare_exchange_weak` with the following mapping for������������ ����� ҽ��� ����� ����� о��� ����������t�������<������������@�����,���������������������#�����(�����H�T�������?<     match a.compare_and_set_weak(ptr, new, SeqCst, guard) {���������ĝ����l������������"�����l����L����,����������)ɟT�������KH     match a.compare_and_set_weak(curr, Shared::null(), SeqCst, guard) {��������+��L����,�������7�<����#Use `compare_exchange_weak` instead����;����������I�������U$��;	��G�G����S��������������������q�aX�������U$��;	��G55�
9�
:�
��d�M���G�G����
��������������������T��
��G���G$���
<���
�������#,��jl`bdf���U���'$ Bitwise "and" with the current tag.�������^[ Performs a bitwise "and" operation on the current tag and the argument `val`, and sets the����85 new tag to the result. Returns the previous pointer.�������Z��t�������t�������<�������9�����,��������<9 let a = Atomic::<i32>::from(Shared::null().with_tag(3));���������74 assert_eq!(a.fetch_and(2, SeqCst, guard).tag(), 3);����/, assert_eq!(a.load(SeqCst, guard).tag(), 2);�<����L������I�b�G��S�������U$��;	��G����
��G$�����������57���T���&# Bitwise "or" with the current tag.�������]Z Performs a bitwise "or" operation on the current tag and the argument `val`, and sets the����8��������Z��t�������t�������<�������9�����,��������<9 let a = Atomic::<i32>::from(Shared::null().with_tag(1));���������63 assert_eq!(a.fetch_or(2, SeqCst, guard).tag(), 1);����/, assert_eq!(a.load(SeqCst, guard).tag(), 3);�<����D������I�b�G��S�������U$��;	��G����
��G$�����������57���U���'$ Bitwise "xor" with the current tag.�������^[ Performs a bitwise "xor" operation on the current tag and the argument `val`, and sets the����8��������Z��t�������t�������<�������9�����,��������<����������74 assert_eq!(a.fetch_xor(3, SeqCst, guard).tag(), 1);����/��<����L������I�b�G��S�������U$��;	��G����
��G$�����������57���*���#  Takes ownership of the pointee.�������YV This consumes the atomic and converts it into [`Owned`]. As [`Atomic`] doesn't have a����VS destructor and doesn't drop the pointee while [`Owned`] does, this is suitable for����#  destructors of data structures.����d��	 # Panics�������;8 Panics if this pointer is null, but only in debug mode.����d����������WT This method may be called only if the pointer is valid and nobody else is holding a����! reference to the same object.����t�������\�� ```rust���� # use std::mem;����" # use crossbeam_epoch::Atomic;���� struct DataStructure {����     ptr: Atomic<usize>,�,����������! impl Drop for DataStructure {���     fn drop(&mut self) {����^[         // By now the DataStructure lives only in our thread and we are sure we don't hold����/,         // any Shared or & to it ourselves.����         unsafe {����OL             drop(mem::replace(&mut self.ptr, Atomic::null()).into_owned());�l����L����,����<����T���I�J��
��G$�����6���52 Takes ownership of the pointee if it is non-null.�������Y�����V�����#�����d����������W�����96 reference to the same object, or the pointer is null.����t�������\������������"������������,����������!����������^�����]Z         // any Shared or & to it ourselves, but it may be null, so we have to be careful.����B?         let old = mem::replace(&mut self.ptr, Atomic::null());���������74             if let Some(x) = old.try_into_owned() {����                 drop(x)����             }�l����L����,����<����t�I����������������;t����J��
��G$Ӏ���4�������ºL���I��_���8������I��^�^��^��[�^���[����e�S�������
��G$������6�������ºL���I��_��…8Ņ�����I��^�^��^��[�^���[����e�S�����Ʌ�
��G$ʅ�Ѕ���/�������ºLÇ�I��������'$ Returns a copy of the atomic value.�������[X Note that a `Relaxed` load is used here. If you need synchronization, use it with other���� atomics or fences.�,�����I�I����
��G$�����1�������ºL���I����Ɋ<̊�I��
��G���8�������ºL���I����ڍ ���52 Returns a new atomic pointer pointing to `owned`.����t�������<�������)& use crossbeam_epoch::{Atomic, Owned};�֌��ތ2/ let a = Atomic::<i32>::from(Owned::new(1234));����4��<΍��$ݍ�J�I��
��Gowned�,����"�������I���ԉ�$���J�I��
��Gb����ҏ�����׏�I������$���G�I��
��Gt������A�
�����Ԧ���L���K�����#%�ڒ#���30 Returns a new atomic pointer pointing to `ptr`.����t����Ǒ�<ϑ���ۑ*' use crossbeam_epoch::{Atomic, Shared};�������74 let a = Atomic::<i32>::from(Shared::<i32>::null());�<Β��$ݒ�L�K��
��
�G�����$��������I����ƕ�ד30 Returns a new atomic pointer pointing to `raw`.����t�������<������� use std::ptr;��Ԕ ��������41 let a = Atomic::<i32>::from(ptr::null::<i32>());�<����$ɕ�L�I��
��G@Ε�̖(���41 A trait for either `Owned` or `Shared` pointers.�<֖��������̖�Ԧޖ�L����-��3������=?춗���63 Returns the machine representation of the pointer.�T�����b��
����G$ė��*�ٗ@= Returns a new pointer pointing to the tagged pointer `data`.����d����������_\ The given `data` should have been created by `Pointer::into_usize()`, and one `data` should����DA not be converted back by `Pointer::from_usize()` multiple times.�T���b����
����G�$�����'���#  An owned heap-allocated object.�����š*' This type is very similar to `Box<T>`.�����b���ԛ*' least significant bits of the address.�,���������ºL���J{� p0�`k���+-\��$�����b侜<��������eRҹ��^=x�J�ߜ3������ºL��J������')䧝T���J�b��
��G$�����)���@��ܞ�d���������-* Panics if the data is zero in debug mode.�Tǟ�b�J��
��G�$ҟ�����������J������/���2/ Returns a new owned pointer pointing to `raw`.�С��ء\Y This function is unsafe because improper use may lead to memory problems. Argument `raw`����]Z must be a valid pointer. Also, a double-free may occur if the function is called twice on�̛� the same raw pointer.����d����ң��ڣ,) Panics if `raw` is not properly aligned.����d����������`] The given `raw` should have been derived from `Owned`, and one `raw` should not be converted����/, back by `Owned::from_raw()` multiple times.�ť�tͥ����<��������������FC let o = unsafe { Owned::from_raw(Box::into_raw(Box::new(1234))) };�<���D���e�J��
��G@��������,) Converts the owned pointer into a `Box`.�Ũ�tͨ����<�����������젩 let o = Owned::new(1234);��©#  let b: Box<i32> = o.into_box();��� assert_eq!(*b, 1234);�<����D���J�J��
��G$������«QN Allocates `value` on the heap and returns a new owned pointer pointing to it.����t�������<�����Ǭ��������<�������G�J��
��G�$����$������ºL���J�������&���Qğ��t������<���������������%" let o = Owned::<i32>::init(1234);�<���$�����J��
��G�$���ٳ;�ް1. Converts the owned pointer into a [`Shared`].����t�������<�����ñ0- use crossbeam_epoch::{self as epoch, Owned};����쀲��������Ų! let p = o.into_shared(guard);���4��<����\���J��S�������U$��;	��G���
��G$���"$Ԥ��۴.+ Returns the tag stored within the pointer.����t�������<�������������*' assert_eq!(Owned::new(1234).tag(), 0);�<���������J�b����
��G$�����-���ZW Returns the same pointer, but tagged with `tag`. `tag` is truncated to be fit into the����&# unused bits of the pointer to `T`.����t�������<�����Ǹ������ let o = Owned::new(0u64);�ܕ� assert_eq!(o.tag(), 0);�Ե� let o = o.with_tag(2);��Թ assert_eq!(o.tag(), 2);�<����D���J�b�J��
��G$��������-�������ºL���J����Ի$׻���J�h�ܻ�
��G$��ݼ3������ºL��J��_����8�������J��^�^��^��[�^���[����e�S��������
��G$��������!���������G,���J���#%���,�����J�J����
��G$�����.�������ºL���J�����#%\��4�����G���,�����J��G����
��G$�����1�������ºL���J������!L�����J��G����
��G$������������J������$���G�J��
��G�������!��������J���������0- Returns a new owned pointer pointing to `b`.����d����������>; Panics if the pointer (the `Box`) is not properly aligned.����t�������<���������������Fٛ<����$���J�J��
��G�������2�������ºL���J������4�����J��G����
��G$�����5�������ºL���J������"T�����J��G����
��G$�����1�������ºL���J������4�����J��G����
��G$�����1�������ºL���J������4�����J��G����
��G$�����1���52 A pointer to an object protected by the epoch GC.�������?< The pointer is valid for use only during the lifetime `'g`.�������b�����*��4���
�����Ԧ����S�L���LU$��;	����68�\��$�����b���(<��������eRҹ��^=x�
�h�N���38�����Ԧ���L���N������,�����N�N����
�8�G$�����28�����Ԧ���L���N���88�����Ԧ���L���N������')��T���N�b��
�8�G$�����)T���b�N��
�8�G�$������
�����٤���L������ ���<9 Converts the pointer to a raw pointer (without the tag).����t�������<�������85 use crossbeam_epoch::{self as epoch, Atomic, Owned};����,������������� let raw = &*o as *const _;��� let a = Atomic::from(o);������������"�����  assert_eq!(p.as_raw(), raw);����4��<����4�����L�N����
��
�G$�����-�
�����Ԧ���L���L�����������35������ Returns a new null pointer.����t�������<�������  use crossbeam_epoch::Shared;�������" let p = Shared::<i32>::null();���� assert!(p.is_null());�<����$���L��
��
�G������*' Returns `true` if the pointer is null.����t�������<�������8�����,�������� let a = Atomic::null();���������-* assert!(a.load(SeqCst, guard).is_null());����&�����.+ assert!(!a.load(SeqCst, guard).is_null());����4��<����<�����L����
��
�G$�����#��� Dereferences the pointer.�������NK Returns a reference to the pointee that is valid during the lifetime `'g`.����d����������UR Dereferencing a pointer is unsafe because it could be pointing to invalid memory.�������[X Another concern is the possibility of data races due to lack of proper synchronization.����1. For example, consider the following scenario:�������HE 1. A thread creates a new object: `a.store(Owned::new(10), Relaxed)`����KH 2. Another thread reads it: `*a.load(Relaxed, guard).as_ref().unwrap()`�������]Z The problem is that relaxed orderings don't synchronize initialization of the object with����]Z the read from the second thread. This is a data race. A possible solution would be to use����&# `Release` and `Acquire` orderings.����t�������<�������1�����,������������������"��d��	 unsafe {����%"     assert_eq!(p.deref(), &1234);�,�������4��<����,�����L�
�G����
��
�G$�����/����������VS Returns a mutable reference to the pointee that is valid during the lifetime `'g`.����d����������_\ * There is no guarantee that there are no more threads attempting to read/write from/to the����%"   actual object at the same time.�������YV   The user must know that there are no concurrent accesses towards the object itself.�������JG * Other than the above, all safety concerns of `deref()` applies here.����t�������<�������1�����,��������*' let a = Atomic::new(vec![1, 2, 3, 4]);������������&# let mut p = a.load(SeqCst, guard);�d�������     assert!(!p.is_null());����     let b = p.deref_mut();����)&     assert_eq!(b, &vec![1, 2, 3, 4]);����     b.push(5);����,)     assert_eq!(b, &vec![1, 2, 3, 4, 5]);�,����������"��d�������41     assert_eq!(p.deref(), &vec![1, 2, 3, 4, 5]);�,�������4��<����L�����L�
�G����
��
�G$�����,���(% Converts the pointer to a reference.�������_\ Returns `None` if the pointer is null, or else a reference to the object wrapped in `Some`.����d����������U��������[�����1��������H�����K��������]�����]�����&�����t�������<�������1�����,������������������"��d�������,)     assert_eq!(p.as_ref(), Some(&1234));�,�������4��<����4�����L����������������;t���������
��
�G$�����*���#�����d����������;�����d��������€W�����!��ā�t́��߁�<�����1�����,��ڂ�����d�������*'     let guard = &epoch::unprotected();��Ń&#     let p = a.load(SeqCst, guard);����     drop(p.into_owned());�,����<����T���L�������{� p0�`k�G��
��
�G$����6�؅52 Takes ownership of the pointee if it is not null.����d����������W�����<9 reference to the same object, or if the pointer is null.�Ї�t؇����<������1�����,��������d�������*���щ&�����-*     if let Some(x) = p.try_into_owned() {����         drop(x);�LNJ��,Պ��<ߊ��t���L����������������;t�������
��
�G$��������.��ٌ�t�����<�������8���ō,��������>; let a = Atomic::<u64>::from(Owned::new(0u64).with_tag(2));��������"��܋� assert_eq!(p.tag(), 2);����4��<��������L�b����
��
�G$���Ε3�ڐZ̩���&����t������<�������1���ɒ,������ let a = Atomic::new(0u64);�������ȓ#  let p1 = a.load(SeqCst, guard);��� let p2 = p1.with_tag(2);����䙔 assert_eq!(p1.tag(), 0);�五 assert_eq!(p2.tag(), 2);��۔)& assert_eq!(p1.as_raw(), p2.as_raw());����4��<•��DՕ���L�b�L�ޕ�
��
�G$ߕ���Ӗ(8�����٤ؖ�N�������,) Returns a new pointer pointing to `raw`.����d����̗��ԗ,�����t�������<������� ��٘���DA let p = Shared::from(Box::into_raw(Box::new(1234)) as *const _);�Ԫ� assert!(!p.is_null());��ə4��<����$���N�N��
�8�G@�����J�
�����Ԧ���L���L�����#%���"������L��L����
��
�G$���,���œ08�����Ԧǜ�LӜ�N���K�
�����Ԧ���L���L�����#%�ɝ<\̝����L��L����������������;t������Less��������Greater��ji�/޾�؝�
��
�G$ٝ�,ߝ���18�����Ԧ���L͞�N������,������N��N������
�8�G$���,���ϟ88�����Ԧԟ�L���N��_����8�������N��^�^��^��[�^���[����e�S��������
�8�G$��������:8�����Ԧ���L���N��_��â8Ƣ�����N��^�^��^��[�^���[����e�S�����ʢ�
�8�G$ˢ�Ѣ�̣58�����Ԧѣ�Lݣ�N������<���N��
�8�Gl�,L�,�����[���#,�����)4�����*,����I��5��L�l��]�� OQ>@��2����%" An epoch-based garbage collector.�L��Oxᓄ1~~����4����5�5I�5��4�5phantom��4�5��4榦��������)��)���)���"�D�:h��K���O���O���O�����<��O��
�t��O������ Creates a new collector.���O��
���%��-* Registers a new handle for the collector.�D����O�P���
�$��O�������<9 Creates another reference to the same garbage collector.�,����O�O���
�$��	�O��_���	8�	�����O��^�^��^��[�^���[����e�S������	�
�$�	��	�
�O�����
%��
74 Checks if both handles point to the same collector.��
����O��O��
�
�$�
rhs��
���O����$! A handle to a garbage collector.�\��P@��\�?������,����x���P���Ԋ
�� Pins the handle.��
���P�S��
�
�$�
����
+( Returns `true` if the handle is pinned.�L����P���
�$���%��85 Returns the `Collector` associated with this handle.�L����P��O���
�$�̚�P�����$����P�h���
�$����P��_���8������P��^�^��^��[�^���[����e�S�������
�$���d�,D�,����I����!�[���e\8����e�����$U����G\[�����s�����L��*q�ILO=?Lm/��T���bL�$���b�Q3�bԕD��P;���(�����Ķ$�����h��$���������G���H������B1}-�hn����<�����k��P��_���C������P��^�^��^��[�^���[����e�S�������
�$���l��P�����,����P��T���h�h�h_raw�$���	,�	��P����������	����hD�	���h��h
�����	;=��)$���h�h���̢�ݢD��
���@�"$��)$���h�h���̢�ݢD��
���@�"$��$��P�h��
�$�L�-,�-��b\�
�����D�
������7
46!T�
�Q�������� 
D�
�Q��
���
4
d�

�Q�Q��
�$�

���

��%
L�
�Q��
�$�
��#
4�
�Q�Q��
�$�
��%
D�
�Q�Q��
�$�
��&
L�
�Q�Q��
�$�
��
�R������'
�
�Q�R��
��",�
��1
$�
���R�G�Q��
�
�$�
���
��7
,�
���R�Q�G�h��
�
�$�
�",�
���
��!�
��!
���R�Q�Q�G�G��������������������q�aX�Q�Q��"
�
�$�"
�
<�"
�
�"
�<�"
�<�"
L�-,�.���
	�[����	����42	����LP	���� Dp	����*,�	���L	zL	j�#	[�>	L�_	=�~	.��	��1	. A guard that keeps the current thread pinned.��	�l�	���	���O	L The current thread is pinned by calling [`pin`], which returns a new guard:��	�<�	����!	 use crossbeam_epoch as epoch;��	���b	_ // It is often convenient to prefix a call to `pin` with a `&` in order to create a reference.���\	Y // This is not really necessary, but makes passing references to the guard a bit easier.���	��<�	���	���L	I When a guard gets dropped, the current thread is automatically unpinned.��	�ܝ	 # Pointers on the stack��	���W	T Having a guard allows us to create pointers on the stack to heap-allocated objects.���	
 For example:��	�<�	����1	����,	���	���&	# // Create a heap-allocated number.��	 let a = Atomic::new(777);��	���	 // Pin the current thread.���	���	���J	G // Load the heap-allocated object and create pointer `p` on the stack.���"	���		���	3	0 // Dereference the pointer and print the value:���	.	+ if let Some(num) = unsafe { p.as_ref() } {���	+	(     println!("The number is {}.", num);�,�
	����
4	��<�
	���
	���
	 # Multiple guards��
	���_	\ Pinning is reentrant and it is perfectly legal to create multiple guards. In that case, the���b	_ thread will actually be pinned only when the first guard is created and unpinned when the last���	 one is dropped:��	�<�	����!	���
	��
	 let guard1 = epoch::pin();���
	 let guard2 = epoch::pin();���
 	 assert!(epoch::is_pinned());���
	 drop(guard1);���
 	���	 drop(guard2);���!	 assert!(!epoch::is_pinned());�<�	���	���	 [`pin`]: super::pin�,�	�Se7,*J�����	,�	���xT�	�S���������^	��Y	V Stores a function so that it can be executed at some point after all currently pinned�̞	 threads get unpinned.��	���]	Z This method first stores `f` into the thread-local (or handle-local) cache. If this cache���X	U becomes full, some functions are moved into the global cache. At the same time, some���Z	W functions from both local and global caches may get executed in order to incrementally���(	% clean up the caches as they fill up.��	���Z	W There is no guarantee when exactly `f` will be executed. The only guarantee is that it���[	X won't be executed until all currently pinned threads get unpinned. In theory, `f` might���W	T never run, but the epoch-based garbage collection will make an effort to execute it���	 reasonably soon.��	���W	T If this method is called from an [`unprotected`] guard, the function will simply be�̯	 executed immediately.�,�	���S���h����
����	�̢�	˚�	ݢl�	���h����	����$�	��<�	
�����$�	��	bdgi��8T	��Y	����	���	���]	����X	����Z	����(	���	���Z	����[	����W	����	���	���W	����	���	�d�	���	���\	Y The given function must not hold reference onto the stack. It is highly recommended that��� W	T the passed function is **always** marked with `move` in order to prevent accidental�d� 		 borrows.�� 	�<�!	����!!	���!	���!	����!	 let message = "Hello!";�d�!	����"K	H     // ALWAYS use `move` when sending a closure into `defer_unchecked`.���"'	$     guard.defer_unchecked(move || {���#$	!         println!("{}", message);�\�#	     });�,�#	��<�#	���#	���#^	[ Apart from that, keep in mind that another thread may execute `f`, so anything accessed by���$	 the closure must be `Send`.��$	���$_	\ We intentionally didn't require `F: Send`, because Rust's type systems usually cannot prove���%\	Y `F: Send` for typical use cases. For example, consider the following code snippet, which���&Y	V exemplifies the typical use case of deferring the deallocation of a shared reference:��'	�l�'	
 ```ignore���'5	2 let shared = Owned::new(7i32).into_shared(guard);���'R	O guard.defer_unchecked(move || shared.into_owned()); // `Shared` is not `Send`!�<�(	���(	���(]	Z While `Shared` is not `Send`, it's safe for another thread to call the deferred function,���)_	\ because it's called only after the grace period and `shared` is no longer shared with other���*<	9 threads. But we don't expect type systems to prove this.��*	�t�*	���*	���*V	S When a heap-allocated object in a data structure becomes unreachable, it has to be���+^	[ deallocated. However, the current thread and other threads may be still holding references���,`	] on the stack to that same object. Therefore it cannot be deallocated before those references���-\	Y get dropped. This method can defer deallocation until all those threads get unpinned and���.8	5 consequently drop all their references on the stack.��.	�<�.	����.8	����/,	���/	���/	 let a = Atomic::new("foo");��/	���/M	J // Now suppose that `a` is shared among multiple threads and concurrently���0	 // accessed and modified...��0	���0	���1	���1	���1M	J // Steal the object currently stored in `a` and swap it with another one.���2H	E let p = a.swap(Owned::new("bar").into_shared(guard), SeqCst, guard);��2	���2	 if !p.is_null() {���3<	9     // The object `p` is pointing to is now unreachable.���3R	O     // Defer its deallocation until all currently pinned threads get unpinned.���4	
     unsafe {���4O	L         // ALWAYS use `move` when sending a closure into `defer_unchecked`.���5+	(         guard.defer_unchecked(move || {���5D	A             println!("{} is now being deallocated.", p.deref());���5\	Y             // Now we have unique access to the object pointed to by `p` and can turn it���6T	Q             // into an `Owned`. Dropping the `Owned` will deallocate the object.���7%	"             drop(p.into_owned());�|�7	         });�L�7	��,�8	����84	��<�8	��|�8	���S���h����
����8	�̢�8	˚�8	ݢl�9	���9	
�����$�8	��8	8:=?<�:	�������Ւ���������h�h����U9	��:]	Z Stores a destructor for an object so that it can be deallocated and dropped at some point���;4	1 after all currently pinned threads get unpinned.��;	���;]	Z This method first stores the destructor into the thread-local (or handle-local) cache. If���<Z	W this cache becomes full, some destructors are moved into the global cache. At the same���=Y	V time, some destructors from both local and global caches may get executed in order to���>6	3 incrementally clean up the caches as they fill up.��>	���>]	Z There is no guarantee when exactly the destructor will be executed. The only guarantee is���?]	Z that it won't be executed until all currently pinned threads get unpinned. In theory, the���@]	Z destructor might never run, but the epoch-based garbage collection will make an effort to���A	 execute it reasonably soon.��A	���AY	V If this method is called from an [`unprotected`] guard, the destructor will simply be�̑B	���B	�d�B	���B	���B]	Z The object must not be reachable by other threads anymore, otherwise it might be still in���C!	 use when the destructor runs.��C	���C_	\ Apart from that, keep in mind that another thread may execute the destructor, so the object���D&	# must be sendable to other threads.��D	���D_	\ We intentionally didn't require `T: Send`, because Rust's type systems usually cannot prove���E\	Y `T: Send` for typical use cases. For example, consider the following code snippet, which���FY	���G	�l�G	����G5	����G;	8 guard.defer_destroy(shared); // `Shared` is not `Send`!�<�H	���H	���H^	[ While `Shared` is not `Send`, it's safe for another thread to call the destructor, because���IW	T it's called only after the grace period and `shared` is no longer shared with other���J<	���J	�t�J	���J	���JV	����K^	����L`	����M\	����M8	���N	�<�N	����N8	����N,	���O	���O	���O	���OM	����P	���P	���P	���P	���Q	���QM	����QH	���R	���R	����R<	����SR	����T	����T#	          guard.defer_destroy(p);�L�T	��,�T	����T4	��<�U	��l�U	����S�������U$��;	��G�h�����U	����U	
��G$�U	��U	<�U	�������Ւ�����G�h�J����\	��V_	\ Clears up the thread-local cache of deferred functions by executing them or moving into the���V	 global cache.��W	���W^	[ Call this method after deferring execution of a function if you want to get it executed as���W\	Y soon as possible. Flushing will make sure it is residing in in the global cache, so that���XD	A any thread has a chance of taking the function and executing it.��Y	���Y\	Y If this method is called from an [`unprotected`] guard, it is a no-op (nothing happens).��Z	�t�Z	���Z	�<�Z	����Z!	���Z	���Z	��̒[	 guard.defer(move || {���[@	=     println!("This better be printed as soon as possible!");�<�[	 });���\	 guard.flush();�<�\	��,�\	���S�h��\	�
�$�\	��e	��]3	0 Unpins and then immediately re-pins the thread.��]	���]Z	W This method is useful when you don't want delay the advancement of the global epoch by���^^	[ holding an old epoch. For safety, you should not maintain any guard-based reference across���_^	[ the call (the latter is enforced by `&mut self`). The thread will only be repinned if this���`4	1 is the only active guard for the current thread.��`	���`]	Z If this method is called from an [`unprotected`] guard, then the call will be just no-op.��a	�t�a	���a	�<�a	����a1	����b,	���b	���b	����b!	 let mut guard = epoch::pin();�,�c	 {���c'	$     let p = a.load(SeqCst, &guard);���c6	3     assert_eq!(unsafe { p.as_ref() }, Some(&777));�,�d	����d	 guard.repin();�,�d	����d'	τ��d6	��,�e	����e4	��<�e	��,�e	���S�h��e	�
�$�e	��pR	��f[	X Temporarily unpins the thread, executes the given function and then re-pins the thread.��g	���g[	X This method is useful when you need to perform a long-running operation (e.g. sleeping)���h`	] and don't need to maintain any guard-based reference across the call (the latter is enforced���i^	[ by `&mut self`). The thread will only be unpinned if this is the only active guard for the���j	 current thread.��j	���j^	[ If this method is called from an [`unprotected`] guard, then the passed function is called���k*	' directly without unpinning the thread.��k	�t�k	���k	�<�k	����k1	����l,	����l	 use std::thread;���l	 use std::time::Duration;��m	��m	����m!	��,�m	����m'	τ��n6	��,�n	����nC	@ guard.repin_after(|| thread::sleep(Duration::from_millis(50)));�,�o	����o'	τ��o6	��,�p	����p4	��<�p	��\�p	���S��������
����p	�̢�p	˚�p	ݢl�q	���q	
�����$�p	��p	8:=?�;T�r	��R�z7�m�o���x�R��;8��x�R��
�d�r	����xĨr	�R�����r	$�r	���R�h��r	�
�$�r	��{-	��v7	4 Returns the `Collector` associated with this guard.��w	���wK	H This method is useful when you need to ensure that all guards used with���x2	/ a data structure come from the same collector.��x	���xT	Q If this method is called from an [`unprotected`] guard, then `None` is returned.��y	�t�y	���y	�<�y	����y!	���y	���y	����z	̺��z6	3 assert!(guard1.collector() == guard2.collector());�<�z	��L�{	���S����������������;t�����O��{	�
�$�{	<�{	�������Ւ�����U�O�h��|	�S�����|	$�|	���S�h��|	�
�$�|	̪}	�S��_���}8	�}	�����S��^�^��^��[�^���[����e�S������}	�
�$�}	��}	���-	��~W	T Returns a reference to a dummy guard that allows unprotected access to [`Atomic`]s.��	���_	\ This guard should be used in special occasions only. Note that it doesn't actually keep any���Y	V thread pinned - it's just a fake guard that allows loading from [`Atomic`]s unsafely.�€	��ƀ]	Z Note that calling [`defer`] with a dummy guard will not defer the function - it will just����%	" execute the function immediately.�ʁ	��΁`	] If necessary, it's possible to create more dummy guards by cloning: `unprotected().clone()`.���	�d��	����	��ĂZ	W Loading and dereferencing data from an [`Atomic`] using this guard is safe only if the����C	@ [`Atomic`] is not being concurrently modified by other threads.��	�t�	����	�<��	�����1	�����-	* use std::sync::atomic::Ordering::Relaxed;��	���	 let a = Atomic::new(7);���	�d��	�����7	4     // Load `a` without pinning the current thread.��˅.	+     a.load(Relaxed, epoch::unprotected());���	����5	2     // It's possible to create more dummy guards.����)	&     let dummy = epoch::unprotected();�ކ	���	     dummy.defer(move || {����8	5         println!("This gets executed immediately.");�\��	��Ň	��ɇQ	N     // Dropping `dummy` doesn't affect the current thread - it's just a noop.�,��	�����4	��<ֈ	��ވ	���^	[ The most common use of this function is when constructing or destructing a data structure.���	��ʼn^	[ For example, we can use a dummy guard in the destructor of a Treiber stack because at that����U	R point no other thread could concurrently modify the [`Atomic`]s we are accessing.���	����c	` If we were to actually pin the current thread during destruction, that would just unnecessarily���b	_ delay garbage collection and incur some performance cost, so in cases like these `unprotected`��Ō	 is very helpful.�ڌ	�<ތ	����1	�����	 use std::mem::ManuallyDrop;����-	���	���	 struct Stack<T> {��	     head: Atomic<Node<T>>,�,��	����	����	 struct Node<T> {����	     data: ManuallyDrop<T>,��ݎ	     next: Atomic<Node<T>>,�,��	����	����	 impl<T> Drop for Stack<T> {�䦏	���Ï	���؏$	!             // Unprotected load.����M	J             let mut node = self.head.load(Relaxed, epoch::unprotected());�ː	��ϐ3	0             while let Some(n) = node.as_ref() {����(	%                 // Unprotected load.����J	G                 let next = n.next.load(Relaxed, epoch::unprotected());���	����X	U                 // Take ownership of the node, then drop its data and deallocate it.��Ԓ2	/                 let mut o = node.into_owned();����4	1                 ManuallyDrop::drop(&mut o.data);�伓	                 drop(o);�ٓ	��ݓ 	                 node = next;����	��l��	��L��	��,��	��<��	����	�캔	 [`Atomic`]: super::Atomic��ؔ	 [`defer`]: Guard::defer�\��	�S
��;d��	��S��[��x*���S�S�;6��S�S��
�,��	����S���!	�S�— 	\ɗ	��S�d�.D�.������5T�����$����D�����p$��+����$����ManuallyDrop�d������D�������������[�������CachePadded�\�����,�����4�����L�����\����� D�����7\�����6,�����%\�����#,�����8,�����-L�����8L�����8$�����9,������",��04����������������������x{il��*_bPS��E��"8;),��""��6	������̍�ą\���b����T@֙�t<������"L�����P��5�bT������bĕ�TD��T��������T��
���%D����T���
�$���TD����T�P��������������������q�aX�h�P���
�$�� D���($���T�Q�T��
�$��",����T�����<��T��
�6���b���T����� $� ���T�h�� �
�$� ��"�T��_���#8�#�����T��^�^��^��[�^���[����e�S������#�
�$�#��#��&�Tt�&�T���'1T�'����T�Q��'�
�$�'global_epoch�d�'��)4�)���D�:h������*4�*������8��.����ewK'�0��U�U��+,�+������9��.���9�Q)�����<�T��+*,�+�����������u��� �R\�+�������Ԣ,l�,����b܏-�-����
���/;D�/��������T��S�h��/�
�$�/�*�/�#,�/��4+<�4�������S�h��4�
�$�4�#,�5ĭ7�������Ւ�����u���T�Q��;8\�;�������S�Q��;�
�$�;�#,�;��K,�K�Uf�1m�l�������d�L,�L����V��M.L�M�������5���)��dN|j�����������2ҏ���Z�O��N�N������5���)��dN|j�TĊO\�O����+�+p�+��*�@��n�*{�b��Od�O�������P L�P����+�+p�+��*�@��n�*{������������:�"���b��Q,�Q�����T�U�U���������������V%īV����b��W<D�W���O�P��W�
��L�W��^&4�^���U�����^�
�$�^��_,L�_���U��O��_�
�$�_�`�������Ւ��������h��a&L�a���U��a�
�$�a��cH,�c����U�P��S�h��c�
�$�c� D�c�#,�c�c�������Ւ�����T�T�h��e),�e����U��S�h��e�
�$�e�#,�e�e�������Ւ�������h��g!�g���U�S��g�
�$�gԎ~,�~���U�h��~�
�$�~Ԛ�,�����U�h����
�$���Ή#t܉���U�h���
�$����#tϋ���U�h�ދ�
�$ߋ�ӎD֎����U�h�ߎ�
�$�����������Ւ�������hΖ�������Ւ�������h���U������������#D�����U��V����
��	,�����,T�����V��U����
��*,����0D�����V��S�h����
��*,���#,��D�/$�/����!$0������e\�����e���G<�����G�����<�����������<�����������%\������4�u����#,������4���������9��������+}hjTV?A��L�����������٤����"��(���������<>�D����G��V���
����G���&T����V��G���
����G���)D�����V��S�h���
����G����.$��
���j����٤����Y���Y�Gd����� �X4Ci��������UWRT��,�����
�S��$�����
uu�w�x����#k��V��$�����������U$��;	�
�V��$������0<��������eRҹ��^=x���Y�� �V����� <�!�V��
�T�!�V���$14�$����V��S�h��$�
�$�$�#,�%��%#��j������%���W�%��W�Gd�%�V���24/1ܞ&�&�V��
��G�W��*U4�*���V�������U$��;	��G��S�h��*�
��G�W$�*	container�L�*�#,�*46��7D$�7���V��S���-��#���.���.���.����4Ci����G�W��7�
��G�W$�7�#,�7#%��9,��j������9���9��d�9�V���"$')��:$�:���V�h��:�
��G�W$�:��=<�
���j����٤�=���=���=��d�=�X���J�J��=79�?AL�>$�>����������������������q�aX���W��>($�>���X����������������;t����X�J��>�
��
�G�Y$�>�jLy��5T��-���G\������p$��5����A��2|�"��D��������Yç�p������!#T�$�����p��!,�����q��0��������$���$��Y��)��������$��Y���������Y������!-\���Y��
��G��S\����Y���G���������������hl����h��G�
��G��$���GI��AT�����Y���h�����������l����
��G��$���/1��������Ւ�����G�������H��$l�����Y��G���
��G$����������Y�����$����Y�h���
��G$���,����G\�����G<�����G�����<�����������<������������\�����%\������4�u����#,������,������4�������+��9!��������2����uw`bKMt�$�����������2������NKjW����GNKjW�����WY��$�����H��$����uu�w�x����#k�����&��������$��Y��
&������
��$�
�Y��
������
�Y���������
�
�Y��
��G���l��������Y�������U$��;	����������U$��;	�����S���
��G$�onto�$��
��#,���.$�����Y�G��S�h���
��G$�����#,���!>d�!�����Y��S��������������������q�aX����������������;t����G�h��!�
��G$�!�#,�!�$�������Ւ�����G�������U$��;	�����Y�S������)�������Ւ�����G55�
9�
:�
��d�M�����h�h��+�|�+�����Y����SΉ�����+����+��$�,������Gt�,������$�,
��G��$�+	condition�L�+�#,�+vx�/�������Ւ�����G������4�������Ւ�����G�����h��58<�5����Y��S����5�
��G$�5�#,�5��8�T�8����Y����S�������9����9��$�9������Gt�9������$�9
��G��$�9��L�9�#,�9np̆;������;�Y�����;$�;���Y�h��;�
��G$�;��/:U<U<f<f<��0�w<w<�<�<�<�<�<�<�<�<�<�<,�<�<�<�<:====\�2<�2�������L�����\�����#,�����d�����0D������*oq^`��Q��B�� 0��$L���O
���%L�����0��0����ç�p����OC��������	��	 Pins the current thread.��
�S
�D�
�������Ւ�����P�S�h��
��
30 Returns `true` if the current thread is pinned.�L�
�D��������Ւ������h��0��)& Returns the default global collector.�����
���J\���������
���̢�˚�������P�����������

�������acfh�
�������Ւ��������������
�������Ւ���������E�E�EAccessError�N����Av�����23(=(=:=:=L=L=7;T� ������ �F�)��dN|j���a�F7;M�a�F��
��Gbdܕ ���a(��������_�G3�F��_���PR�����F��^�^��^��[�^���[����e�S�������
��G,�����
,�
�Q(Y^�lG��\�
$�
����b !�
$�Q("�
%�Q���!#���Q�Q�"�
�
�,�
8#�
&�Q���!#�Q��
�($�
'�Q��_�!#�����Q��^�^��^��[�^���[����e�S�����$�
�
�,�
��%�
(�Q���!�(*-/8�9=?���Q�h�%�
�
��
H&�
)�Q)�Q���46����Q��Q�&�
�
�L�
���
\�
�Rn�%�����
$�
����e8'�
*�R���!#�R��
�((�
+�R��_�!#�����R��^�^��^��[�^���[����e�S�����(�
�
�,�
�Ʉ�%	L�%��Tc�d������d�%,�%����QL�%$�%����T8)�$,�T���!#�T��
�(*�%-�T��_�!#�����T��^�^��^��[�^���[����e�S�����*�%�
�,�%�ɼ�,��V���i�C�A���$������(A�:�V��_�!#�����V��^�^��^��[�^���[����e�S�����A��
�,�����.$���j������������d��VewK'�0����136��G��$�������<��������eRҹ��^=x�G�W(B�;��j�����������@�_�WM����V��_���������V��^�^��^��[�^���[����e�S�����B��
��G�W,��/��L��WŬ�1�N�&���<� ���W���WHC�<�W<�W���46����W��W�C��
�L���(D�=�W��_�!#�����W��^�^��^��[�^���[����e�S�����D��
�,���ԑ,��������YQ)�����<���!#��"$�������������u��� ȃ��"$������(N�B��������,�Y��_���IK�����Y��^�^��^��[�^���[����e�S�����N��
��G,����Q�t.b4�	��t�R�&a�R�a��P
��:�������R�a�������Ւ����v�R�Oa�R�a ��f�fStorage��f��f�f��fm�՟���P�h��������R�!a�������Ւ����w�R�"Na�R�"a ��f�f۽�f��f�f��fm�՟���P��������L�M�

�U�
��Y �Z%\[*�[/\4e\9�\?�dES}J�pP�V�\��c��jכo�v��}���������������v�������{��Ӆ���������������������G��������+�����
������#��+�1Ӹ7
�=W�Ck�I��O��U��]��c��k�sA�y����������������������������Ԣ���������O������	��	����זY�Õ]� ��&�-�4)�:�A�Hn�N�T^�Z�`Nqf�fl�U	s�by_�Z��Y�W�7V�yU��}	��}	�ZC��B��A��@��#��#�t@�Z>��/��/��7�>��5�,=�;w::�99$�8*�c1�77�e>C7D�6J�6P[6V6\�5bx4h4n�3t��|v1�1��0���.��%��*�X)��&�7&�@%��$�V ��������������!��,$�+��5�9#)�90'6�=CI�O?U/[5a�g�m&s,y�����b
�h
��b�h�
�b
�h
�}�e	�k	�����a	�����h}��������������������Guard::defer���#���#�������#��u�#������#���#�E�Ordering::SeqCst�Atomic::compare_and_set����Pointable::deref_mut�Pointable::deref�T�?��G��Ordering::Release�����Pointable::drop���V������G�Ordering::Relaxed��������Pointable::init���X���#��P�Ordering::Acquire���������S���#����Atomic::compare_exchange������������#������������������u�������G��
super::pin����%
super::Atomic��#�#������%��u���#��#������%����#��#�?P���������H���������������I�I�I�H�J��������3�����?P���������H���������������I�I�I�H�J��������3��������H���������������I�I�I�H�J��������3��\q��]]��`jo;
����H��+s�{����k���8ѩ��6��e�﩯�'�<8��Cx�j�=����=bP՘�� ���v�
R���JW_��9��b8��.�i���p~�h7Qɚ�����+r�<@ߑ#?�:���~U,C?%�cޥDH?]/�$��C��”A$NCx�W,����ۏmg�����A��P=���`� '�$���b�5�U�G���d��
����ܵcANt�����M�	��z���i����E�
��+��1$���WҦ�ݑ`6���K�P[m����V�W���^�5™GG�mD�gӻt:H�G�l�<l�3��"p�L��*'[7�#3���2�
c+����[$-<a�Z9�g�; �<Q�+8�$F�g%��/����L�L�/�[?�8��%��
N��
���'�b����s�`��
Z�P4�C���y��ѻ�P���������}�#�gdp/
�K���R�[��0ѷCb����'_U��d�+
�3!�R�
�G`d���M^BWCV�{�Y-�&�k1�����(����Rm�	����^��9�!�t[�~����F"�b�s���D}ked�8D�n*-(��&!���<}��Ko�7�,���������I�
xRS�4޽��S^z7��g�-?�3�|Q!�`��jO�<D�ys�\<��t!�&�?�&�	��!+��*!�ɞ��"��3諸v���^����0���j�B���&�D��Ie�'��n�D�&��C�>��9��Ʌ|�h�ǩ�(A�b�4�VD�TK�q�����d8�gΤ�Nh۝w�grp!)�	~h/W�Fx�-�F�}��ll�V��F(
��q"/�B��~]W���G��`E����%:������=@���O���^%/F0��j���ӎ�f(z;aP�õ众��D����ءp운��?��e���T��D�����t	x�D7��64`�}����������1���u�6��� KaP�e��������?��Z"NrS����oo[��-�	����j́����a�)��6@�=O�]�ѵ��:$P!G�m�	�r
�
%ﶞ7�ƿ������3ͪ-x��?ztn4&>C��s��f����+v썷(�k�l���
�H�;��o%ʡ�0`����͘�`�$Q��ug��)�Ͳ�ͿĘ��PK1���u�.`ٵ���`��@	����d�����m��>]�����?��8T=c��Y��C9��A��a=�@s��|��`�~q�L/��P��M�v�����`Du�8w'S���"�c}�4x��zڌ�s8�B7�7�R&}خ���y�g|���b�5_��4�X��EȬ�:��.����S,P�l׋���]�m���Ή�jrB?`�С�:���Re�\Z��0`��X`	��gL:�����C8Lwq!<3���;U57#���	`�]�'������T�Bjh����%a̠��p�v�CY�������D��m��
��~I�\�A]�~�j'���p7��WӬ$����hh㯋NJ\b��F�o�*�4���c�<Y�,R�9߲e�\��q�e���<���"m���کĞ~��Pj5r`;z\m�Y���*su4�U��Bj�T!CM��6+�ʿZ�+�vn�3�u��]�g�YIrf�y����R�N?XQ7Ln	�ȋIa�
����^0)G�����������s^e�?�_R��ɯ%�v߂zH(mjipm"�Y���N��g���՛��0O�:�ئ��w�Y�=6K��G�{H����2���&5�L��꬏�ק�{ �{H�i?�6��OWa{1Rrp��_^6>�_��M�bVGc]X��;��VD��׀��K�9~��R��[sX��Ū�=I��?�ՋR3lX��rM�/&V�����r;�.Ԗ�~��ƃלfcD�
��@��'b﩮��Iz��-#���Y=[�=��霋��C�5�>@�2���d��=���Q��4��f�A����]�U6�`;��~bы�M$xYN}-�R��Qߓ�;��
�yƲg�F�$Q����0�v ��]I>����h��eH�&=�ջ�n�n����@�}2�4�X�H�G�Dů�k����X2# ���'�Fq���l��
V-N��5L���q�m������T>�GglĪ0�%�q������{\;=b����)m������>��8&�R�0�Ւ*sJ���zJ@/d��RI�^*f<�r=&�Ţ��a����>��3�)VU���)ŋ��6����Qx0b��w4d��x���h��A��
��Y�������P��7C�eh�$��%f�
i�g�"ݱ��kih�7C�bnҫނK�6$��څ�@�v�f��a�]�q��i��O2p� #m��*¿�p��sߔ�{��x�-ٶN	��K"�p�J.)1"5*�|w˓���iw.?VE�qO�p�R�W
]�`��m��;�F�\	���P��1��P��ҳ'�X�����	I�.�Jg��O�{V?�U��
��.�|�zZ�PU$�.�r;�u$�f�)���"�y}�mҔ“�uO$�9�Տݤ6q��9Α���p^(��Ez�v������I�FSU�!4��L��
�D���O�Hҡ�)��?�I/C^�V�X3� �_�ʶo
Xx�<Ef<=Z�F�"��>��Zݩ����h����������O�����]�߳m?	�0R�=��?�lC�]��5������Ư��O+���=�#���tlo�y�S�?���A�����«�uTk[�O��Y'�/y����jpUh,��P�����͔:�X	:Zh������U�0�'��U���UW�QL�Ѐ2�n�Y�O������*�����/�ޱ|OYE�	wn��v�9���ϕ#%��!����%\�N���V�ܧ�i�Ѐ�Cq>}/M�%}d�>b�y��]c���
�醢�d@6VM��k�7�-���K������ހ��x�1Ks�(���ʄ �|�VWF{�m�ӌ�f�5ݐ�E�p����2�;���E���Q��V�^�R��t�|>�M�G�쮆3�-���N�ހ+}�O�>��9;6��3��Sn����Q���ғ���8aS2����nik)`�d|Z�+;)��N������_`�{`pl����}��a+@���z�-���m�#5)�ھ��:�!hؑS�w|�.S�(?V�X��V9�,:�ƹ�;���X;���3Fͧ+�L���������Y9<`���*��aX>�XWݪ��ʅ��&�r���ʳ1yS!�Z�?w�F�5in�s
_ɅA6q};�j�c�yݭ��i�Ѷ������坼�9׫:3� {�1�Ϸ���/��[�y$N�q��x-�!BG���UV	s�>^YDQ����&*����Y�%�z��-�mpn��sXg
!�^�孒w�͒�aj~3���Wo"��}�:�<f��:W����#mP�s�7=�SLZ4�6n�6 �V�o/�Y3�KU���1��~Ì>���P��fwȜ��',r�D��BiT�R�c��]��/��{,*��;�R�N��In���Q����GqVj�ƅ�CJ�Ѓ�}S�3�'G�	M�$��^�q~�(��� �?����`&�t�׉��@1C��2�^V' �eg0S�y���QW�h���ȁN�C�Za��RF6�9B���xm����Om��h��
j��\�`	Ƚ�j; d�	ae3-�u$|*-VY��/P�㶧h!Y�8yo����K�~��=2�}6ԞJ�:�:�����#Z�Дs�L�7����o�}��Y`���P��ɟ�R51<�a�F��c?��DdnC6���O������M�3���������u�N�MVqG)��\N
h]�b�'��WKE��
���4_*��W��˅@�ʅ�i	x���&`�42�C����!�+s�t}&�.�y���8
�^9Ԥ��vȳ�v�:�{)Ď�� ;{���ɰ]���_s����l�DD����E���.�M]'}
��̀�=.�b������f��#G�pt
o������2�v��Z�3�e�g2"t>BȝFz��5+�aS�=C5��~"$�p�E�0 �N|���.�kb%��&���"��XJB�Q�w�=�o�g����C�/U5G��~g���V���!U�՘�m=B&����Bj���G��씲�qz��Z�~�ө���"GL��e��h��emy�����\�d.��S��n�i3��!�^R;���*�#uЊ��A�:A��
�sr-���cC�r��j���4����°DQ;U�>��,��5x��`�0&?�ݿ挃�UC^"�J��<�_W��h&X�g1aZ��A;
��BmK�4JU�c�^~�����6�`1���\`�BÁj���Ob�"���{���"���� �����
���b�-X����!���N~��Nl�y;2,�)�Z�οj'l��#[P�����>e�3<��ڛ#�&��`2��\Oi�@���+J	6�F�2��[�Yl��Ș.K��b���^W}t쉇�J;&n}�F1�y�Z&��XK57��Z���$�2{���n{%�h�|Z�'g2�c_�`g�@.1KW춸������*�TX1�4~"73_��!������J�{@+�ӑ�&�_Jr+e>8��yi�
��z�n�&lJ�	j݈Ooݿ�w��H�b�N,�#�;�e�İȷ:;�|���kx��i���yAT�R GO��†�kl�&H%�XŇiG
8�]>�y��;�P��N���>�k.6��@�Wlw=Y�&5�G�R�p�g��4ƪzl�6�������z1�7�JI��Gb��_�A���h���
Jt����##��h�-˟U/�h�4�)�"?cΛk������#�0�u�V\��,&�|Ba���'�..�ϣ&s����◴
�a� [i�!������~n2S��[ݽ��D":�3z�P�\:�~���Hʂ��<�3�����(C��^g�"k��ѯ�f��uo{��-��=\6#�v]�������
|�Ն�3/)�K���R�Ի���t7��emZ���7�׫��T���RguHF8E��:ls�%��бm%}*C�@�ZDJ��
p��L�$HB	�}��L5���d�Rx�)�9p(Z��E>
�uR6����P�s5��nť�y���ڦO����p�q�H���G6K͞�Rb���j<�"�1���2��LV�d�����eo�)<˽_u�c�ى������+1�~"��+�l����ѦF��vE%���R�|Y���=�<�l)Q�����j�9Q�]W�ǫ^�[�@n}�H��L�K%-c��oML?ɮX4Ć�C���>�@F
z���fQ�EF��:d��i�2�4���CV���\zdR6�e�*ɗ9f:�n���ߗql	��׹Ȥ��D����q�����fn��f�`�Q5���9s�Y%�)��.>����V�*�Ni\��N4�$�'��@q���L�?�|^����ni��6)��B�KZ��E���\��7��6/� �Ԟ�л�VP�rA���%[-�o۰��#�il�hî�6�`�R��W(@��_���h�s�U�O���k��M+gItδV�-<�%��9+x���K/��,��`����pz��+ܗ���=ׅW	��~@��3�#'o�3EEs�$c�`�}��
sΤ���@��"R+��I���(jt)������x�4��u�ξ����,�٫^���9ݞ�s&�#���'���~v�tuh�\V���s����U�K�	-Ύ[3�"��DNˈ��w�O�e�ᶽ�D�R���S����7m|�����������s��v֝��?s�A
���$���(����nĄc���O��s���t�����L��%�]����x2�_��t� ��A!V3�0Ϝ�&�a��Sl�<���hآ{Ӥ(>��j^����T�Vw���
>
�g��瞿���y5e�c;�Rw�O2]�4"\{9�"g���޴m{Qv\<�p��x]q��4)��\�JHB���l\�|�Zp����]�[J�6*�eI��ǩzކ� $s���
����HOԝmq�����9��^f�2��z������Fn�~ݯ�X����J��Y�:Mpj��dlꇉ������͢�d��`tD��5_K�O�yJ�Z]�6hu�L0�9�`�ψن����*r)8�mC�ae�
8��c�-���yoB�O��dif=I�z��f�gU�ޞ9����b'��	͢g���i�=_�7��ա�wn�4?�n4��ίui��Da�6 Q����B~�)^����#�͚^�cqV4�,�|���,��u;׍�S D �j+.|�H���JJ�s����ޅ��
7^`��Q���-i����Y�����
_)�|�F�hc��~#�x�~�
"�$2�Q�
�GDӱ�-N"�C##D4�,|�E\
��"S�P_i5#x�ϻ�U��D��%�e�6�~gN�I���Tp���u)�1��:���Jg�,��9�����?Gbo���%����P���бb����X|2(QA�����<��P��:C�-�w�P���߯�8w��W6�Fc������$T�PG���)�y�9���S	L��"Ą��B�8N:�W�������'��\���Q��3��#�;[N���*���WqЭ1K)@A��q
W�l9//?�\�F^��%j��ȁr��Y$q��M�)C�T�{r/�u��ݿ�ZV�J5!$�\
�&1����x�Q�y?27^�9�p�q�%���*��kPf�p����=���wCv?i��b�^�*_]S�y@��1�n�;��$�d�������V�D���z�A&U�ݝ�5�ζQܬ"��L�z6����܉��h,\��H���ܒ�XkD� r�`P���>iI���̭�41��Y��|%;�;��1��#R��<�/K��Ɂ]�qc�$��x'�s729�l����*;��L�q��Z�0H�:�L����� 2����t�[�Ť[�\`�t�ٶ��ZrRJ��ªh݉�7��G"s�U��f"��>�{4�r���gJ�fG�D���s�&��[��6q��:�Oj���-,�!IF2�r xi`�:\�[��7��CLhe�A:RȠ��@Y���*�2���"J�RpY�G~����,���2Pc����O�p�6a)R����:������C�VG'��Z��1�h��h�����*�-Q���/�BPßD4�7����`h?���3����#��d�����i�h;Rk伣�$Sŀv��S3�D��8Q\�E�5���#���S��ғ^x&��j-������3���A_��?�g��}��M!�>*ғͤܤ�"���6����?Q��]*���z6̋%��ʹ0��^��$�?�M���*ۅ��A���$5:���j_�it��b�bSTs,Y�b��wq2Y�b��}q�����������������������������������J�KAN_NO��
P).[�okz$
��`2=�K�K�K$LfLUM8NWN�N�P,QWRWS�ST�T�UIY�Y[&[s[�[�[/\}\�\N]�])^c<cxcRdfRg%h�h�h�h�hVi�i�iBjZj�j�j?k�k�k�klpl�l	m�o�o�o0p{p�
p'r�
rws�	s�t6w2{�}m����w6���4��(��(��?��������"�
!�������������	�T����
�-�o�����>��	���*
�]�&���#�?�[�����8���(�p��	���
	����	��
�����3��8�����5�P�����a�����,
�����/�{���)�����:�s�����4�����B�����'� ��
���r �>%�� ���	�\�������������1O�!y8�O��������	b���e	�	-
>
�
�
�
9�Xt���
Rg���3Nk4N�%�D���6t��0N��S�<^x�JY#c1�E1�;3<�?vCH}H�H�HI�K�KLaL~L/VMPZ�Z�Z�Z[^)^Z^�^�^�^�^_Y_`O`k`�`�`a<a�a�abxb�b�bTc�c�c�cd�dewe�ef5f�f�fCg`g�g�g/hKh�h�hVi�ij�j�jVk�klTl�lmUm�mnan�n�nWo�o�o(q�qrzr�r�s�stpt�t�t�t u5u�uvYvw�wdx�xMy�ybz�z{3{O{�{�{|W|}�}$~�~�~���3�������I���������m�`���$������l��F��������N���~�����8�Q���N�y��������7�j���5�S�������U����������������:�m���7�b����J�����1���b��������k���5�������;����_���*�z�w	J�K�K@N_N�N8Y�b���
L%$[�o�o�qiz t���L1SpT:Y[�[�bFh/j�j`k�opip�pRr������6���Q���x���&��������`�l���������\����S�����	�Z	�������Zq��������q	9
�
�
d��Z&�<U�4H�HLmLzZ�ZN^�^�^[`�`+a�ab�b�cf
hmn�qss�t,u�u:xy�z�{�{�{�~�����!�������s�����)�z�E�����z�������,�}�\�������������{�s� �




%%

%(
vJ�K�K9L{LjM>N]N�NQ�Q�R�ST�T�X�Y�Z;[�[�[D\�\�\c]�]�b)cfc%d�eg�g�h�h�hiki�i�iFj^j�j�k�k�k&l�l�lTo�o�o�qHs�s|t�v�z}�<����s�����ίF�۷'����ƾj�����
���.���|�����D�`�	���A��������~�U�������:�f����P�����?�����x���J�X�������)�����]�����|�|�v�!�G��������B�^��	q
�
�
����
Vk���7�8c�:�J�K��c�h#7bw"�0;N?:CcGHXHH�HK&L�L5ZWZ�Z�Z["[^/^^^�^�^_n_`�`�`Qa&b~b�bcXc�c�c%d�d�e�ef9f�fgGgdg�g3h`h�hi�i$jk�kljl�lmkm�nomo�o�o.q�q*r�r�r�s�sttt�tuJu0vnv3wyxQy�ygz�z{7{0|l|3}9~�~���7�^�����&���9���ԉr�'�[���Ҍ��ō���:���T�}�ܑJ������[���͔�����M���=�f���P�Ԙ���h��������;���ܜN���ƞ��[=�K�K�K�K�KLLaL6MCMPMN'N4NSN�N�N�N�N�N�N�N�N�N�NwP}P�P�P�P�P�P�P�P�P�P�P�P�P�P�P�P�P�P�P�P�P#Q'Q2R8RERRR3S9SFSSS�STzT�T�T�UEY�Y["[o[�[�[+\x\�\�\<]I]�]�]^%^�b8cscMd�e�eHgNg!hqh~h�h�h�hKiQi�i�i�i1j>jVj|j�j�j�j:k�k�k�k�klelkl�l�l	m�o�o�o�op+pjpwp�p�p"r�r�rrs�s�t-w1w){-{�}�}V�Z�g�����Љp�����̒/�����ÜМl�p�}���z�~���������{��������ӻ���ؼ���ݽ��B�O���ȿտ'�]�j�������8����������%�W��!����-�:�V�������2����"�j����������������������-�l�y�2�x�����#�0�K�������\��������'�{�����)�h�u����$�������4�W�^�n�����"�/�������0�=�����
��!��v�}�����l�8������W�����
���������~�����+I��fs2}�I���\bhmqu{�|����]���a	}	)
:
�
�
�
4�Tp���
.38=@EINc~���/Jf0J� ���@������1o��,I��M�������Zt�+#8#E#E1R1_1�1�;�;/<�?qC�G�GHBHyH�H�H�H�K�K
L]LyL)MMZ�Z�Z�Z�Z[X]`]e]l]r]y]~]�]�]�]�]�]�]�]�]�]�]�]�]�]�]�]�]�]�]�]�]�]�]^^
^^%^U^w^�^�^�^�^_T_`K`g`�`�`�`a7a�a�abtb�b�bOc�c�c�cd�d�dre�ef0f�f�f?g[g�g�g*hFh�h�hRi�i
jj�jRk�k�kOl�l�lPm�mn\n�n�nQo�o�o�p�pqqqqqqq q$q�q�qrur�r}s�s�s�s�stlt�t�t�tu0u�u�u
vvTvww�w�wFxSx`x�x&y,y<yIy�y_z�z�z�z�z{{.{J{�{�{�{�{||R|}}�}�}~�~�~�~N�U�Z�`�d�h�n�s�w�{��������/�~��������7�D�~�����˅g�O�\������n�{�������� �&�(�.�4�:�@�F�L�N�T�Z�\�b�h���������
�A����}��I���`�m�z�������������'�4�L�����J�u�����Ǒ�5�e���0�Q���Г�Q�|������	�������8�h���3�^�z���E�����̘�,�������^�����Ϛ��f���1�z���Ӝ�,�9����4�Y���$�s����������
����!�&�,�2�7�=�C�I�P�W�\�c�j�q�x���������������������� ǠΠՠڠߠ��������	����%�+�1�7�=�C�K�Q�Y�a�g�o�w�}�������������������ɡϡաۡ������������"�(�/�6�<�B�H�N�T�Z�a�g�m�s�y����������������������ŢˢҢ٢�������������%�,�2�8�>�D�J�P�V�\�b�j�p�v�|�����������������������ȣϣգܣ��������
����$�+�1�7�=�C�I�O�U�[�a�g�m�s�y������������������������ǤͤӤ٤�K�K�KL$LfL8MEMUMN)N:NYN�N�N�N�N�N�N�N�N�NzP�P�P�P�P�P�P�P�P�P�P�P�P�P�P�P�P�P�Q6R:RGR�R7S;SHS�S�S|T�T�T�X�Y�Z&[s[�[/\}\�\�\>]N]�]�]^�b%cbcd�e�e�fLg�gsh�h�h�h�hOiVi�i�i�i3jBjZj�j�j�k�k�k�klilpl�l�lPo�o�o�o plp�p�q�r3swsgtzv/w�z+{}�}tX�\�'���������ߚ��Ŝ]�n�r����|����������}�0���ŷ�ջ�ڼ�߽��D�T�ʿ��_�o����������������f�����/�?�[��������+�t�z���������h�?�����n��z���%�5�P����������:�����j�{��)�������\�`�s���$�4���2�B�������{��{������G�����f�f��`�������� 1��hy����`fosy���-�I��	m
�
�
m�t��
16;BGLRg���3k4N�%���F����6t��N��S������3^b"-#:#�0G1T1;�;9?%CNG�G�G
HEH}H�H�JL~LZRZ�Z�Z�Z[]]h]o]v]�]�]�]�]�]�]�]�]�]�]�]�]�]�]�]�]^^^^^+^Z^�^�^_Y_`k`�`<abzb�b�bTc�c�cd�dwe�ef5f�f�fCg`g�g/hKh�h�h�ij�j�klTl�lmUm�n�nWo�o�o�pq	q
qqqq"q*q�q�qrzr�r�s�s�s�s�stpt�t�t5u�uvvYvww�wHxUxdx*y.y>yMy�ydz�z�z�z�z{{3{�{�{||W|}}�}$~�~�~R�]�b�f�l�u�y�}�������	��3����9�I������m�Q�$���p�������+�1�7�=�C�I�Q�W�_�e�n���������F��������b�o�����������)�8�����P�y�ɑ7���o��W����������:���9�b���L�����И�������d��������7�|���؜.�;�����z��������������$�*�0�5�;�A�G�N�U�Z�a�h�o�v�}�����������������������Š̠Ӡؠݠ�����������"�(�.�4�:�@�H�N�V�^�d�l�t�z�������������������ơ̡ҡءߡ������������%�,�3�9�?�E�K�Q�W�^�d�j�p�v�|���������������������¢ȢϢ֢ݢ��������	����"�)�/�5�;�A�G�M�S�Y�_�g�m�s�y�����������������������ţ̣ң٣ߣ�����������!�(�.�4�:�@�F�L�R�X�^�d�j�p�v�|�����������������������ĤʤФ֤ܤ�Q�X�Y�Zt����KLML�L@MMM�M$N1NQ�QBROR�RCSPS�STET�T�T�UY�Y�Z
[`[�[�[\i\�\�\]F]�]�]�]"^�b2coc9d�e.g
h:h{h�h�h�h2i�i�ij;jPjhj�j�j�j'kTk�k�k�k�kLl�l�lio�o�o�o�o(pEptp�p�pr>r�r]s�s�t	w{W}�}�d�����n��d�ɒ�v�ܛ͜��z��������s�K�ò����ݻ{���������� �L�|���ҿ�D�g�������!�b�������"�B���������7�O�k�����������U����������}���k������J�v��O�������-�D�������G�x������$�d������F�r�����!�q������"�h������,�s������:�m��������D�����Q��������<�������������Z�������(%r��Dp[�&r���������S����H	m	
5
x
�
�
#�C`��t
_t����CV�"Cu�\���/��^��8w�+�>m��"5#B#1O1\1�1�;�;<t?`C�G�GHHmH�H�H�HwK�K�KLLiLMFZ`Z�Z�Z�Z[!^7^j^�^�^�^�^�^C_�_2`W`�`�`�`
a'a�a�abOb�b�bccc�c�cdod�dBe�e�e)fEf�fgSgpg�g�g?h�h�hAi�i�i^j�j9k�k�k>l�l�l>m�m�mHnin�n>o�oSq�q�q]r�r(s�s�s�s�s(t�t�t�tu(u�u�uvvDv�v�wxPx]x�x�x6yFy[yBz�z{'{C{f{�{�{�{�{|C|�|}o}�}�}l~�~�~���(�C�����؁���A�q�b����W��ІY����s���x�������:�d�
�W�ߌ,�����j�w���3����1�E�l���0�\��������%�[�v��A���˓ޓ:�c�����ޔ����ƕ���(�^�y��E�r���.�w���ǘ����Z�����@�p���Ț���O�w��S�������6�͝��-�O���Ϟl����KLEL�L:MGM�MN+NQ�Q<RIR�R=SJS�STT~T�T�U�X�Y�Z[T[�[�[\]\�\�\	]@]q]�]�]^�b*cgc1d�egh'huh�h�h�hi~i�i�i5jHj`jj�j�jkAk�k�k�k�k9l�l�lVo�o�o�o�o"p2pnp}p�pr)r�rTs�s�t�v{;}�}�^�������G�Ò�E���ǜ��t��������e�=����v���׻m���ܼr������F�s���̿�/�a��������@��������9����������1�F�b�����������L�����������o���b�����
�5�p��:�|�����'�;�������9�c��������[������1�l������c�������b�z�����&�e�������4�d��������"�����C��������3��������������L�������"Q��#j:�Q���������J��w�;	g	
/
r
�
�
�6Z��g
Yn����:P�:o�G���&��U��2n��8dz�"/#<#�0I1V1t1{;�;�;g?SC�G�G�GHdH�H�H�HjK�K�K?LcLM@ZZZ�Z�Z�Z[^1^a^z^�^�^�^�^6_�_)`Q`�`�`�`�`!a�a�a�aBb�b�bcZc�c�c�cbd�de�e�e f<f�fgJggg�g�g6hzh�h4igi�iQj�j,kgk�k1l�l�l0m�m�mncn�n0o�o0q�q�qPr�r�r�s�s�s�stwt�t�t	u"uuu�uvv;v�v�w�wJxWx�x�x0y@yRy5z�z
{{:{Q{�{�{�{�{|:|�|}S}�}�}_~�~�~�~����:�����Á��;�h�U�ڃ�&�����S�q�Ӈf�ۈr������4�^��&�ٌ����Սd�q�������+�<�W���"�V����������R�p��;���œؓ,�]�����Ք�������"�U�s��?�i��� �T�����ט�7�����2�j�����ښ�A�q��>�~���ߜ��0�����'�7�p�ɞ;���	LSLM�MQ�QS�STnT�U�Y�Z[d[�[�[ \m\�\.]�]	^6c=d�e2ghDh�h�h�h6i�i�ijTjlj�j�j+k^k�k�k�kPl�l�l{o�o�opgp�prPrbs�s�tw{�}+���s��{��{�g�0�>�x�P�Ȳ����Ż��ʼ��Ͻ�4������O�����&�v���
�G�����T�p���"���	�Z�������������p����^��j����I�����L������i����Z���	�v���$�=������x����r�����X���V�"�������A�����������_���	*��Xo+���������X����M	o	
7
z
�
�
(�Hb��y
av����HX$Hwt�4��c�� :|�0�@r�#)1�1�;<y?eC�GHtH�H�H�H|K�K�KQLkLMHZbZ�Z�Z�Z[#^9^o^�^�^�^�^�^H_�_7`Y`�`�`�`a)a�a�abTb�b�bchc�c�cdtd�dGe�e�e.fJf�fgXgug�ghDh�h�hFi�i�icj�j>k�k�kCl�l�lCm�m�mMnkn�nCo�o�qbr�r]s�s�s-t�t�t�tu*u�u�uIv�v�w8x�xy`yGz�z,{H{�{�{�{J|�|�}�}q~�~��-�H�����v�g����\��#���	�x�J����<�f��\��1���K�Ŏ8�ɏ�J���5�^��������'�`�x��C���͓��?�e����������ȕ���*�c�{�!�G�w���3���ɘ����E�r���͚���T�y��]�����ҝ��/�T���ўq���;L}LlMQ�R�T�Y�Z<[�[�[E\�\�\e]�]&d�eg�g�h
ili�i�i�j�k'l�l�lUo�qIs�s}t�v�z}�=����{�������G���(������k��������/�}�����
���B���������V�������g����Q�����@�����K�Y�������*�����^�����}�}�w�"�H������C�_��	r
�
�����f�=��M��	e�j8x"�0;O?;CdGH[H�HK'L�L6ZZZ�Z1^�^_p_`�`�`Ra)b�b�c'd�d�e�ebh�hi�i&jk�klll�lmnm�nooo�q,r�r�ruLu2vpv5wzx�y�z2|n|6}<~�~��`�����)���;�����*��������������V���K������]������N���?���R���j������=�O� �<L�LoMQ�T�Y�Z<[�[�[E\�\]f]�]'d�e
g�g�hini�i�j�k)l�l�l�qJs�s~t�v�z}�?����~�����ЯH�ݷ)����Ⱦl��������0�������C����������W�������h����R�����A���M�[�������,�����`�������y�$�J�����C�_��	�
����f�>��M��	e�jz"�0;O?;CfG6H[H�HK'L�L6Z|Z�Z�^_p_`�`�`Ra)b�c'd�d�ebh�hi�i&jk�klll�lmnm�nooo�q.r�ruLu4vrv7w|x�y3|p|8}=~�~a�����*���<���։*���ӌ��ʍ����ݑK������Δ�N�����Ù���P� �(LjLYM�P�T�Y�Z*[w[�[3\�\�\R]�]d�e�f�g�h�hZi�i�j�kltl�l�q7s{skt~v�z}x+��Չ�ђ4��b������5�ʷ�����Y���t������k�������0�y�����m�D�������U����?�����.���9�G������������L�����k�k�e��6�~���1�M��	�
qx�oR�)�
��:x��R��Wf"�0c1	;�;=?)CRGGH�H�J�KL�L$Z�Z�Z�^_]_
`o`�`@ab�cd�de{eOh�h�hVi�ij�j�jVk�klYl�lmZm�mn�n�n\o�qr~r�t9uv]v"whx�y|[|"}�}(~�~M�������υq�`�‡(���É�J����������~�����ˑ9���q����
�<������������=��_���*���#S#�#�#�#5$s$}$�$�$�$�$�$[%h%�%�%&&&&)&3&@&M&Z&g&t&�&�&�&�&�&�&'''%'/'9'm'w'�'�'�'�'�'�'�'�()R)\)�)�)�)�)=*G*�+�+�+,N,Y,�,�,�,�"5(i(s(}(�(�(�(�(�(�)3*�*�*A+n+{+c,LBMOM&N3NDRQRESRS�T�T�\H]�]$^}h=j�j�k�o*pvp�p�r�}f��˒Ϝ|�������߻��N�Կi�����$� �9���!����x���/�����&���t�#���j�.���<� �������*�r���7#D#Q1^1�;�GH�q�s�s	vvRx_x8yHy{�{�{|}�}�~�����C�[�z���l�y�3�����˘������8��/�0�071�1�2O3�3�;�;H5�56a6�675;�8�9�0�061�1�2N3�3G5�;<�5�5`6�67�8�;�94;QL�trH�ZH|��0/1�1G3�3@5�5�5O6�67�9-;�031�1K3�3D5�5�5S6�67�91;ZL'MNQ�U�Y�Zh[�[$\q\�\5]�]^Ed�e@gh�hCi�i�i2kl]l�lmrjs�s�tw{�}7�����y�?�M���X������������������.���O����*���b�����������x�%�!�����T���q�!���~�,���������d�0�������O�������m�8
!8��]��R	
-�M�~
y}�9�!h��%��5�#61�;~?jC�G�H�KVLMMZ_M_�_<`�`a�aYbdyd�d�e�h�hKijhjCk�kHl�l�lHm�m�nHo�o	rnr�ru�uTv�v�w�xXzR|�|�}y~
~�o����/���V��A������X�=�
�e�#���D�����h�&�8�P�Y�$���4�*��
W?HR^{��w�[���ڟY�b��gqtJ�K�K�K8NWN�N�RT�X[�[�b%h�i�j?kNo�o0p{p'r������	���-���>���������������3�8�����a�����/��������������� ���������O!8O��������e	-
k
�
X��
�ND�01xH�H�KaLPZ�Z[)^�^�^O`�`a�a�axb�c�e�gan�o�o(q�r�t u�u�w�xbz�zO{�{�{�~���������l���U�N������n�9�Ó֓U������ �q�7���J�5�b���ؚ�o�5���)S'j�o�K���
�N*HpZG^�bfks�z��׏l�s�֕U�����k�Sj}o�?��|
�BHdZ;^�b�e_s�z�ˏ`�g�ʕI���t�_�&)04;FJQXck����������������	
!%)-159=AEIMQrv�������������!/=AHOSZapw����������	")07>ELSZamt{�����������������			!	%	,	0	7	>	B	J	R	Z	b	j	r	�	�	�	�	�	�	�	�	�	�	�	�	�	�	�	�	�	


.
6
?
G
c
k
s
{
�
�
�
�
�
�
�
�
�
�

!)-5<@HPT\dhpx|���������������	-=EIQYlt������������������



#
'
/
=
A
I
[
_
g
o
s
{
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
 (0?GOW_gow{�������������������.38=BGL]kpuz���������������%49>CHMRWiuz��������������!&+;CKYiz����������������',AIN[h{��������������
*16;@EJOTY^chmrw|���������������������$4@ELQV^ckpu�����������+3>Qev~��������������&6;@EUgov������������������(4<AHM[`how����������������)16>CKPX`s{������������������$,19>FKS[p|������������	
!%)-159=AEKPUZ_diq���������������$,9AFKSX_dlqy~���������������
+3:BJOW^fw���������������#BGOU[agmsy������������������#*18?FMT[bipw~������������������
&-4;BIPW^elsz������������������� 
   " ) 0 7 > E L S Z a h o v } � � � � � � � � � � � � � � � � � � !	!!!!%!,!3!:!A!H!O!V!]!d!k!r!y!�!�!�!�!�!�!�!�!�!�!�!�!�!�!�!�!�!�!�!""""!"("/"6"="D"K"R"Y"`"g"n"u"|"�"�"�"�"�"�"�"�"�"�",S*j�o!�N���
�P,HrZI^�bfns�z��ڏn�u�ؕW�����n�LLLqT<Y=Y[[�[�[�b�b�b�b�b�bLhPhThXh\h`h�jfkjknkrkvkzk�ptrurvrwrxryrzr{r|r}r~rr�r�r�r�r�rɻμӽ8���S���z��	�
������������������b�n����������^�
�����"��l�m�n�o�p�q�r�s�t����
�\s����s	�
�
�
f�\,-.������DEFG�������H�LoL�^�^�^�^]`�`-a
b�c�c�c�c�chhhh h!h"h#h$h%h&h'h(hsnxn}n�q�q�q�t.u�u�u�u<xyy�{�{�{|�~/�0�1�2�3�4�5�������+�|�G������.��������}�"������#�$(�� ��j��^�`LvT>Y[�[�bdh�j~kpip�p�rλӼؽ=�ÿX�������������g�s���������c�������'��u�������ax������x	9
�
k�a/�H��HLtL�Z�^�^b`�`2a�ab�c)h�n�q�t/u�uAx!y�{�{|�~���6�������‘0���L�ϓ����3������������'�$;'*-%<B(D+:&=)E,�����	<�$��jcore_intrinsics�����\q��]��s���ݝ}����fmt_helpers_for_derive��_�_��\q��]�T�׾=�.$crate::thread::local_impl::thread_local_inner�D�Q�uQb��athread_local_internals����
�f�f��\q��]l#��>g"���$���Z����\q��]��m���t�}�J���derive_clone_copy�����\q��]NS�%N�O��S�I�����_�_��\q��]�!1.#�o ��������\q��]pu2��H���e�f\��	derive_eq�������\q��]������z����������_�_��\q��]h&C�[y�3���V����\q��]|w��������������\q��]M�r�z}6$crate::thread::local_impl::thread_local_process_attrs�C�P�e�b��/$b������\q��]i%���d��̃
����\q��]7\��>�e~$�
u�����������\q��],�4�0{��;�V�����_�_��\q��]�%�k����&�������_�_��\q��]������4�'�������_�_��\q��]Ào5��<�
:������\q��]�B(0�*V�ܽY����\q��]@��	#�������\q��]�X��W���	)�������_�_��\q��]�����B�@�������_�_��\q��]ˠ�8J�����5
����\q��]ݻ�6��k�<�
\������\q��]y�_	�M�{�\���O\�������\q��]-�Ͼ&�Y%��������\q��]\�������G�d�������\q��]h�,��eC���O��Gb6������\q��]s����n�����߃b������\q��]^q8hԐ�Bm<a<U<q<�<]<}<�<e<�<�<i<�<Y<u<�<y<,C�B�<�<�<`A0?�A�?�=�>�B3A]?0C�A&@
>#B�@�>�BA�>�<�A_@R>UB�@	=�B�?W=�<yAM?B@�=�>�BPAz?WC�AO@B>EB�@�>�B#A ?�<�A�@x>|B�@G=C�?�=��ODHT ���i���p~�~���H{�ʶo
Xx�WܵcAN��#�0�up�
>
�g��"Ą��B�Lm?	�0R�^��a+@����٫^�����%,�.S�(?V��ޅ��+��#R��<s���K�9~�]��/��{�(��� �?���1�h���ڛ#�&>Z�PU$�.�H�D�&��Ca�ҳ'�B�*r)8�m���.�kb
��'�..s}2�4�X��)��6@�=�4"\{9�"�,*��;�R���>��9b<8��Cx�j��S D �j(�
�H�;��
�K���=yoB�O��d�3z�P�\:za�6 Q�"<��P��:DhؑS�w|�`��X`	��\�|�Zp�����\`�B1Ť[�\`�t}�b�^�*cxi`�:\�� KaP�e��9߲e�\��ՋR3lX����	wn��vtTK�q���fw�grp!)i�~v�tuh��{��x�-�7_]S�y@��d ;{�����׉��@1�ݿ挃�UC)j�ƅ�CJ�Qv\<�p����%j��ȁV�Zݩ����ZW
]�>6����?Q�������+�q�%���*_n����Q���-x��?z���6��e�b�����Fz��5	Y�O�����qÁj���O27^�9�p�^J��ªh݉�`��@	��%��ʹ0�������u���
Jt����k��w��H�bW�k���8ѩ�&�D��I_�P���бbA}kedи��L��6����%/���2�!U�՘���>��8&l�<���h���ǩ�(A�d�O+���=�cD����ءpxj́����a�D�
��@�����$T�PG�I�Om��h����U��
F�͔:�X	:ln��f�`㤶��%���@�~��Pj��	�������A���f�����P��*~ݯ�X���՛��0O���\Z��0��!�����w]�qc�$�u��x2�_�����6�`10�Y`���P�M���*۰7�ƿ����2�c_�`g�LZ�P4�C�8�P����k�� 2���{�A��a�k����X2��1��P�A��]�m��m�	�r�##��hl;[N���Q�R�[��>��D����{�t� ��A���t	x�|��ʄ �|�����!�+����#���r��Y$q��W���'����<�l)Q���;2,�)�:K/��,��`����^0)G���8aS2���-Ύ[3�"��SU�!4�Qv��S3�DʡՏݤ6q��Mh!Y�8yo�����9��^	��A�:A��!wCv?i�b'��@q���1K)@A��Sv�CY�����VD����x�-�F�}�kU�G�������H��+��~I�\��Q�EF��:��"��L�z6jV�*�Ni\����:$P!G����;�P��a���S�����Bj�T!CM�6��OWa{1�w�Y�=6���h,\��HlS�P_i5#7
7^`��Q,Qx0b��&͚^�cqV4%f�
i�g�-���i�=_-�&�k1��E��nik)`͓����l�DD�Y�:Mpj���\q��]Oԝmq���kx��[�/y���ii���yAT�\�t[�~���IԖ�~����3� {�1�ϰK1���u����p�q�H�������I�Q�%�q���r���ʳ�%�XŇiG_9+x���������s^�]/�$��C��	��!+�Y�P=������A�����2�;��_u�c�ى�e�*ɗ9f:�`�}����~VU���)ŋ$*����Y�%��=����9�,:�ƟRm�	��G_��9����:�!�73_��!��P��nť�y����;���X;�+�l����Ѡ�q�����f��7�,���PHB���l&5�L����������1����y�g��y$N�q���%��!���v�uO$�9�L�>b�y�{$��^�q~��1����x�\Oi�@���+@�o%ʡ�0��j_�it��{@+�ӑ�&R���Y��.�7��ա�w���"ݱ��.`��m��;�?qO�p�R�==���Q����^��9�!H(
��q"/m���3͎�~gN�I��:�x'�svt쉇�J;E�����I�FP����Y9<�oo[��-������;���d������
��Y��)�L0�9�`�41��Y��q+ܗ���=�������\��a���"�����=q:�<f��:�g
!�^����	`��~�
"�$2���j�9Q�I�.�JD���#Z����@�ʅ����]*��kD� rnK�4JU�.b�"��3��t�[�|1yS!�Z�2���"J������%:�p���(jt)��#5)�ښ"5*�|:`���*��a�x�W,��p�6a)R������/��[�&`�42�C��[?�8��%48N:�W�M�^R;���1�n�;��$e<Ef<=Z�XKZ��E������F"�bJ�7��G"s�ӱ�-N"�C4�~n2S��[x��V�W���&5!$�\
�&[O�]�ѵ���_`�{`�X�g1aZ�,0ѷCb��?�|Ba�r��\zdR6�����gJ��†�kl�&H^�zH(mjip��dlꇉ����pz���씲�qz�in�s
_ɪ�	��z�� �`�}��
��,��5x'众��wF�"��>�Y|���b���z�-���m�i	x������e���Tz�������\V���s��f�2��z��
�ٶ��ZrR~�/K��Ɂt`����͘�sJ���J�:�:���������*N���s��v������J�Qs�{���/F0��j��t^����0]�`P���>o�.`ٵ����<���"�
����H=I��?���S��ғ^�� #m��*�5YN}-�R��ݐ�E�p�
�yƲg��h7Qɚ���P����:if=I�z���{���"��4���j�B��^���ܒ�Xmm���ک���W	��~@�ө���"G�ջ�n�
(����n��)�1��:�<�R�
�G`B�N�C�Za��
���4_�����R�N�A]�~�j'��N��g������3��S���������.������������gz1�7�JI�h�T���Rgu�Zh������m���(����F���JW�L5��������A����n{%�J�瞿����2�
c+�-O���k�����3�#'o����?s�A��Iz��-�<l�3��*
z���f����J��
�a� [ivj<�"�1�����$�2{I伣�$Sŀ�����(C��}�Y%�)��.�d|Z�+;)��3�-�������2����[7�#3��,��6+���a�Z9�g�/�>��9;6�|%;�;��1rʂ��<�3�|��$5:���=��?�lC_�څ�@�v�2VWF{�m��?w�F�5�h��eH�&=&n}�F1�FH��L�K%��DNˈ����O�H�Sл�VP�rA����2Pc��*�-Q���/�BPßD��ll�V��Fl�'��WKE��q��Z�0Hy��]�߳]��s�`��
7�	ae3-��mD�gӻt(�i�h;Rk��ίui��D!	Ƚ�j; d�Z�οj'l;729�l��w�[�Yl��BN��In�����`�~q�L�����r;�.�,��u;�'�F��vE%�T�Vw�����)�y�9�J(��Ez�v�O�A6q};�j���aj~3����Ѓ�}S�3�
��̀�=.�Z�~�������x��c��~#�x1�b8��.�
�y5e�c;��ls�%��б��`;��~g��O�{V?E��������>e�3<=��ק�{ �����U�K�	��Y��C9�pl����}�9p(Z��E>�=��霋��v��Z�3�ea̠��p�����G��`Eo<}��KoO4���CV����y��ѻ9��]�[J��
N��
�5Qߓ�;��v�����`���/P�㶧��>��3�)#sΤ���@��w˓���i;�&��[߅{��-��=��c���O��]�������bnҫ0�*!��Zg�-?�3�|TDQ;U�>�&�����
�"p�L��*'+۰��#��+�L���������C8L�;aP�õv�>���P��JJ�s����*�d.��S���3��#�P�����3��������Ӭ$������p��sߔ6,r�D��B���f��#G�iT�R�c����Tp���u;i�Ѐ�Cq>y�ZDJ��V�ܧ�x�n���ߗ��6q��:�����S	L��K�d�+
�3!A�d�����f����
��6�x]q��4�Q�y?2]# ���'���ғ����gL:����Ή�j����R�|��]�`Q5���9s�wq!<3Ǻ��~"$�peo�)<˽�
��+��1"L�Ѐ2�n�p�!IF2�r ��>�{4�r�
�^9Ԥ��M�)C�T�XJ	6�F�2�AK��G�{H�+.|�H���)M+gItδ��:�L���zN~��Nl�y9@���O�r��#[P���<���~U,C?@.1KW춸MVGc]X��;��b�-X��7����X|2(B���[$-<.//?�\�F^U����]�U6@��_�����d��`tD�51<�a�F��}�#�gdp/<Τ�Nh۝h>�GglĪ0���xm����pt
o��
p��L�?Gbo�?�UV	s�>^�#���tlo�dr;�u$�fI ���v�
R
��+v썒5r`;z\m������{\;=�4ƪzl�6fc�^~��/:H�G�l�)��t�|>�|�Ն�3/�6/� �Ԟ���]�'����;�e�İ�Y����L��q
W�l9TFq���l��ޞ9������9�����>�N���ϕ�j���4$��*;��L�x%�cޥDH?V�d�����ͿĘ��P�������'N�A;
��Bm-운��?y����°%k[�O��Y'hHF8E��:�
xRS�4޽R�N4�$��4��u�ξ��"R+��I��(�k�l��)��\�J.�y���8�X��EȬ�:�iI���̭p���T�B�cΛk����o�c?��Ddn�W�h�����y}�mҔ“K�Wo"��}�����P�s5���6)��B��x��zڌ�s�Y���=�c�<Y�,R��TX1�4~"O�����g���޴m{��*�����r�Ի��ׅ�,�|���&9Α���p^N����C�5_��4䨮"NrS���τn����@�ݽ��D":y3�u��]���h������6VM��k�~M�G�쮆�QA�����C7�R&}خ���«�uTg�w�=�oY3�KU����6*�eI��'G�	M���L��
�D�R�$HB	�}��b'��	͢g���
_)/2�Q�
�GD31�~"���������q�e������O���\�c�yݭ���N,�#�X���-i�-=Y�&5�Gd�m��>��0�v ��]
�E�0 �N|�� �5*�#uЊ }/M�%}dz<�r=&�Ţ!h�4�)�"?n�u$|*-VY�N�ހ+}�O��_Jr+e>8SRw�O2]�����>�@F�m%}*C�@�jO�<D�yVH�G�Dů�ᶽ�D�R�Ș.K��bC�.�M]'}?��8T=c��w.?VE�<#���Y=[���K�P[m��%���%[-�o���"�c}�4�L��e��4��f�A�$F�g%��1�\N
h]�b����h��jt7��emZ��CLhe�A�-c��oML?��R�p�g�e
�sr-�"s�t}&��\6#�v]�ց��Ʌ|�hc�B��~]W�ne�'��n`��ʅ��&���o�}��*��W�����w�O�e���g����C�����2���ۏmg�C�ae�
8�3������>*ғͤܩ�R�0�Ւ*��`2��\?h��emyX�����	C7�-���K���E���QЈ�N	��K8�8Q\�E�5�����E���s���t������,�w4d��x'��Rb������*��#��d������5����abы�M$x+�aS�=C5
�h�s�U��[sX��Ū��ȋIa�
����f��uog��)�Ͳ��f��a�]�q3>�_��M�b�Y���*s�D��%�e�69�z��-��V�-<�%���4�7����x�ϻ�U��8n�i3��!ql	��׹��y���Q��_W��h&+�%\�N��w�V�^�R�W����#���"��Ϫ���^W}D|�E\
��"68D�n*-M諸v���\�ӌ�f�5�
V-N��##D4�,5����Fn��[�@n}�X3� �_V�”A$NC���`&�t�y�Z&�G�{Ӥ(>��rM�/&V����`�0&?�(���3Fͧ�tn4&>C�w��W6�FcG��p7��W��XK57��ZHN���>�k.b���B~�)#Ȥ��D��´���G6K͗"�p�J.)19?XQ7Ln	��d���M^BWC���O����kPf�p`
�uR6��u4�U��ݿ�ZV�JZz�A&U�ݝh
j��\�`�
8�]>�y`��ݑ`6��$&�a��S�$���b�5���'�b��6�לfc���yi�
�Td��i�2�^g�"k���~g�YIrf�y��3EEs�$c��g2"t>B�9ݞ�s&�#�ހ��x�1�d�Rx�)��ǩzކ��z6̋��:;�|��Z�=2�}6Ԟ�t�����MJ�Z]�6hufG�D���s�n�4?�n4� =bP՘��	^�5™GG'F�$Q����	^"�J��<*�fwȜ��'���u�6���h�������[�ϣ&s�t��2��L�D7��64}F�\	���P@�7m|��������h��A�(m������Tɰ]���_s�=�@s��|���:���Re��ӎ�f(zuSLZ4�6n���{)Ď���ɮX4Ć�C�il�hî�6��5�ζQ�i�i�Ѷ�ʭ�C�5�>@���|�F�h0^����ni�:�ئ���Oj���-,�`h?�����b�4�VD�e�X��V���s��f�͑�\b��F���U��f"���VG'��Z�����K�~���vȳ�v�:��RI�^*f �z�n�&lJU�Z�+�vn��ނK�6$�1zJ@/d�Q!�`��U��'_U�@8�B7��CV�{�YD�1��~��X>�XWݪ�C�-�w�E��^%smpn��sX�`� '�(��&!���N<@ߑ#?�:
���$����
�
%ﶞ��ɯ%�v���^��$�?�����+r�����,��c�-����	~h/W�Fj!V3�0Ϝ��C��2�^V�o�*�4������;U57#���RF6�9B���d8�gg坼�9׫:�����=���a����?��Z�x-�!BG�����XJB�Q��V�D���g�/U5G��~R GO��]��Jg�,=; �<Q�+80�`�$Q��u���R����y�S�?�eU���UW�Qog���V���-˟U/�mm"�Y�����%�]���rB?`�С�2���d��醢�d@}' �eg0S�7C�eh�$�+{H�i?��]��`jo;
�jpUh,�jS,P�l׋ѱx&��j-��N�MVqG)��{r/�u��YDu�8w'S����S^z7��S��.�|�zG/�ޱ|OYEsBj���G��6 �V�o/������H�ψن����	j݈Oo�V5L���q����"��3[��:��)�K���R��[��7��:RȠ��@Y��孒w�ͺ��cC�r�#Ks�(��6��@�WlwcC6���O��M�3�����%��&���"��ڦO���`�R��W(��m��
�$���W�#s�\<��tW�s�L�7����9���ϕ#u'b﩮���A_��?�g��s���DK>�����f�gU�!�&�?�&Xjh����%��]W�ǫ^�^����#�$����܉k��i��O2p4Q����GqV�/C^�V�U��}��M!���Ư�bYDQ����&���ɟ�R������D���5_K�O�y���7�׫����L�?�|�e�?�_R��������͢U�0�'��n�]c���
�|d��
������\���Q�Oh�|Z�'gKkih�7C/��!���8�j^�����P���߯�8F���◴
u��hh㯋��Rrp��_^6��Gb��_�Ai�L�L�/�3�����*���Wq�R�)���"�J�i����E�!mP�s�7=��RpY�G~�b����)m��)��?�IT $s���m=B&�����V\��,&q�﩯�'�/��P��M�\��7���I>����������$��`�':[������`[y+��?=|sy�!�6����1����a����A������55���D��y���2>����I�p�!:�.2���C������@�;��k�4���lz�j�������!%�@W���������(��Y������=���2_���I'^D��|���V����J�����g1�T�
��1��������Z��OmYl�w@�80{X�z����R�O�Kopw`{[�q��(m��\mju�0v�O94a��d������������u� O�P�y|���z��o0��M�{jeb�@/J����?n�mk�p`C��^�Z�u&�����$��(�f�����w/Xf"��C.
�����WbC���rcg�:$lNY#O����/_m���T{E�����cfT�h3����`������6��V�x�3E�
��IlNC�������\��G;�������vj�����l��w�fn�#�D{0����k.�`����/�0�����(��h��N�p9�a{i��F����m0As�-��^������[u�������c19������!����-���^����Z��0_A������$8D�kM�d������
���<B����`�O��6��M*dp)������@����L
���������Wk�u���]����$�b/��ab��u}��x���������b���H�q�,b�� 
Sb00/���'���Vu���)kh|:��J��b�+D�Sx�W������o����7 �i3A�����	�|�=@��Q�B�s����L��e��GuOG�!u�����6w���Ui `s"��#O��$��Y�������:5"26@zz��&��kd�y`��5z^<�\g��X���?���tG��p�>
2�M��"7���������^]���Z���j���������S��to���m���?����d>mYV��&N��p�H@�u������������uJ!fS:��w|��K\��Bl�D�����r��	w���>9c8������^�������Z9����p���������a��U$iZ��^�<di�����\K/�uAb�����N���s�&~�/p3)F��H�������pl����W�������d��c��Ph~g��t�x�(��6�X����^�_����$��y�%����!��[7d�I����M`9t)U=ck/�Tg��r����[Y���eCm�����������W*7M�r	PW3"������|r_xW@@�#�.>E�2Q��,'�����q�����������#����<U)����1�>������{�@��]�I7�������F1b
 ���m��P�k�����4�r�����7me���b�!\SS]�n�����.����<ch������%�����������bP<x@����	�<�����i�_7���R����8�������1���������9����������R�wyu\��I)g��>����������k���t��P�w�/���!�:������^c��S!�1+-���������a��f���`+�8�[��
N����
<��X)j����aqh������<1d��q{EO��������:�9�����������Z��r#r����x]k�&��(���F�����������P��*9H��2=yx!�������n��eC4���4d�������w����������f��I�F����3%�xP��j����a�������������t,�aU,��A�ROo@���[d�#w�+�Q!����E�-��RR��?N�������:IZ(MR�G�����P��� )�Jah{������J�Z��A�="����{z�N�nD�u)��,f��T�;����yP������
i:�e
3�"~r/JD�������8��+t	�)x�<N>���N�QIjwG�3!�?L��c �����?�h��V\E?�6�$@hpV������$��`�':[c/home/palash/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/crossbeam-epoch-0.9.18/src/lib.rs� ����}+�q@^�YA�o�3�$]ca>^b
badb#caDc_b
cY]b_Sl`8bJ

*?	#+!$/ ZJ;QU?:
('"$F`cbTJ @@O Q 
 1I
")&::::::::
:D:O)!
k2�j`�L��
J��Cf/home/palash/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/crossbeam-epoch-0.9.18/src/atomic.rs� ����>�o��+������
'$"=,_/
;&%<+;H=LM <T?/-%5\]B_]+_G"8#5b#*$$*6$$a
0)5
7?TJ
J8E
I60c`?]de^H K"#24/(QI]10QI_9:QI_ /0/2:!,.)))b*N:#&C)6/.B6
220N:.P!1.7AcbHQP+"GGW%#9'(W%+9.&L)*"
+%' ''"
+!'"
2_61##'9K;TNQLOPO'6##'9D@F_61#_)+9@0]_>1##79bMecLd`JV`_WSUGE1##*TV<$ ?
$K9(':-ecLdd_YJV`_WSUG7E1##(-MM'#
.Y 0
<) ?
$P9(':-Yccc>ORKQ@KPMP'''%61##SD 9 .
:5,Y1<
ecLd`Z$*]%%%%%%$ E1##*KM</;& =
"QecLcd_YZ$5/g%%%%%%$ E1##(-MD'#
.P 0
</@+ =
"V,c=_>1A#<4\X+b=_>1A#;4[V,c=_>1A#<4\W(^[(@\&' 
&!c4T
12:^[(\>' 
&!cbG< 
=+-*
7?53!  9?51F2,`6!4;:.79'%!# D8/<*#'8%9%'5+;"EdI/$+c+*"6#
E20B"
7ab1e4$K6 "1$"(&60V$"&'V$*-365"#&9)B93$/!6_+$"  4&A06
6?8   $:16!4(6%$5C$K!458)44%6@c+4.66;#0"
A=1"#!#'%9'60$%'%"
/=1 #2+39$6"SZ`6MPbb+61##'*
9*6"[d*^O61/#+##.1
'9
966-dZ`6MPbb+61##'1
936 
(@\&61#/+"
1S%:\A61#/+2
=/
3=1C#' 9!6_+61##(!!!.9:F+11%I9% ")M) 4NC+43#;?8!  =?E8' *+6=1#�輕��kY�h���yi/home/palash/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/crossbeam-epoch-0.9.18/src/collector.rs� 8),1���f�[l���.�_�#$&'H&!&$""-
!2,A)
 ?"<,/%$!'0&-=,-1
"?$' 4!#"*+&
(),-)
&*+':(HF#
*+#:(D
"* &"7$3U9TB"&<*+' =0*>
9*'-
<!"<*+' =0*>
5
;9'-
="&9.!7
*+' C(
6'-
:"&<*+' =0*>
9'-
="9.!7
*+&/$

7(
6.
:"&<*+'3 "$9,:<
9'-
=""&9.!7
* ""7(3!O4+@'-
D����Z>zq!���ү�h/home/palash/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/crossbeam-epoch-0.9.18/src/deferred.rs� QG�A8����8�%s��$0cd9!QS4J!%()"
73(*T>><;%*->C<a>E%*
#>' '(!'(!%?AE.H~�x���m���r��h/home/palash/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/crossbeam-epoch-0.9.18/src/internal.rs� �����$:5��U;Fc����<VXe
bc/e_dceeWca\a^:(6%"$0((<1+=&!(b"",,=cL[$1
,/(7
(:)@#
T?>"R"L8cK3-/80#$:"!!J
XB1)81]M_[#242 )O6
.c*L??)``b/-a_3)Ka.[-
*L1]bb+28(49(N4-%>&,O&%:8iB2?

c1:C`+)R2+,3N)B'
K-!N31=-#1LO240
0=0
&(+2CL3]`Bb%[g#b`]_cB17&&Wa^,:@1*.5]?/
!2/D.!
*!2B<U`'^RCdb[
%*4*1%*24*13
956d*"`=%B
1"ac#S=.ed.
!*ND
3N@7P'48/
$5682
"!"K&9
C""5?��O03%d�VM����sai/home/palash/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/crossbeam-epoch-0.9.18/src/sync/list.rs� Vs��̓b�˪`Dۼ!�}�%c=?1c?+:ac'S#
4R
;T
a][*Z  7"G'$Jc#+Ic#.41%0":1/;8?+&9`Z
!"

]\e68/&*"""
3#";:I\GJ<,9B0a-W `0
.b_VXTd?K2"
/';08M+2
?*/<9!K-d=5]&UTd3!HC L"a%+E:O"&!:
+
'#!&/
8
;T
:/*+"*CCC"""
'$%L$%L$%L(111
I**+"*CCC"""1
'$%L$%L(11
'(b**'"75;(R#!1!!@+"'(_**'"75;(R#!13(8!!@+"'(�̿ ypl��Ƌ`�j/home/palash/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/crossbeam-epoch-0.9.18/src/sync/queue.rs� "���c'��!����Ly�n�#7_HdW?"8bb;((=addUT**#&44))"'8--
b<#"&)00HHBP8K
X5$'"2\7[6
bE3)0) KCc*)&X38%
d\W
3)0)KKCc*)&X38%(
,=?9
WdQ
H
'34;)
'! *,
* '
0 =-2
4 &
('&)
"%* +*+ +!*
 .
* !*!!*
 $
"* "*60#%"+&2) /
* 2)"
) ":,":-")).,=>$..))))* "*/%*  (��q�y�w��؍ǨP�g/home/palash/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/crossbeam-epoch-0.9.18/src/default.rs� ���&���ʽP	�'��]#c_E0$&' ?A.F3C@
F9
'4
-*3
$!8'!!M
-
 7"Q˫Ha8�{�h��9ϻn/home/palash/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/crossbeam-epoch-0.9.18/src/sync/once_lock.rs� .=��\�K�]�,��X*} 'J#4-"(;
LHLKHL64
&<4
8("
%!;&+1'&<?
F�6�zV�$���Y+te/home/palash/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/crossbeam-epoch-0.9.18/src/guard.rs� ���*����TG���M���!2P"c]MX2-'K#4/,5`c"!!"$
^b]_-_`\\$
%
^b]_-_`\\a\&# P,)
c$da^:WbdA[cea==1$R$##RMAWT0IaY*
95
3A
b9b_^;bbb$^b&d+da^:@c\A[cea==1$R$##RMAW(
9@8dcaIa&#E>
8_cc9b61"&
,;

,;
9>
``ecc/61!"&
,;
H
,;
93
E)#!B.,
>L($
-<P7Y&##;4F>
?X`Z^&a
[D2.
8/6*9R5__Vdc2 . %N4)KY35!

0Rc )<"�wY�rG�����|�6Ee/home/palash/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/crossbeam-epoch-0.9.18/src/epoch.rs� �\+y��G<;eq��V`�$�acPbZ=7cA6Y
6'?dF;ed3<9,6*!
8,"
%Z--
+ b $.1-8'
.>*\aZJV`_WSUG$ H
,.
��$�Ŷe�|��oB�h/home/palash/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/crossbeam-epoch-0.9.18/src/sync/mod.rs� Y��(Ԃ�"�4vO;y�� �a�})��IWF3�7�~�ɶ@�x�w��������4�[�x86_64-unknown-linux-gnu�"����"�@�a
K��V�crossbeam_epoch�-898edee4616dca8c���\q��]��
��=������S�;S�������������������������������������������������������������������������������������	����S�F�F����rust-end-file