📄 libcrossbeam_epoch-3f303a1308604a37.rmeta
/home/palash/git/iron_learn/target/debug/deps/libcrossbeam_epoch-3f303a1308604a37.rmeta
Language: rmeta • Lines: 5270
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���^��g�`����s\-8775055eb4b1a9f1�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���\En�m��_55�
9�
:�
Qa2U��
8��
?����������������G����F�����,^����?�G�GP�GP
����MaybeUninit���uninit�������B1}-�hn�G��uu�w�x�ִ'
ǯ���G��I�_�I�_�I��I��I��I�������KE	�$?ę�G��I���Box�������lf���]v�G�B�B�B�)����I����I�G�uu�w�x�ִ'
ǯ���G�������^s���o*}�
�G��I�G��J�G��J�_�J��J��J��J��J�G��J�J��J�G��J�G��J�G��J�G��������^s���o*}8�G��N��N�G��N�G��L�L��N��L�L��N�_�N�_�N��N�������O�
wC��O��O��O�_�O��O�O��O������	�xS]�Bj�_�P�_��� ����������so�������6������o�2"���Q��Q�_�Q��Q���Q��Q�Q����7�����{CH�]��_�R�����%�����tn̴'�����#��	R~�W�k�.�_�S�����%�����(��!Q�����'��'���	�|K�1{�Jg��T��T�_�T����7��"���7�t�`�fr��_�T��T����*��*������*��*���*���*���"�:y8�T�0�U�_���8�����?m�4a��_���8��.����͐�y�7��Gj������8!H�؎tֻ��W�W�_�W��V��V�J���-��#���.���.���.�����"0k��|��
�Gj����0��0�����A�K��ˡ�G���Y��Y�_���9��.���9� ��{�XW�G��Y���Y��Y��;5�u����������������������������B��E
Yk	yu��������{u�����������u���u���������u���������������u�u�u�u�u���������������������������������������������������������������������_�?tP���!�_(�
�"�7�3��8��������������J(�
�� �-�-�5�-��*��]����GAM�_��
�_���������������������������q�aXÅÅą��:����@�FK�^�^��^��[�^buf��[����e�S���`��`��`��c������c�`��a���%#$�%
#�%
�-�G3E�%��$/
��G�%�%��$��Fl�$�G$�$�`��G��I�&
&4�&�`d�&�&
�-�G/,�&)�L|�&
#�
��
�L�FO�&
�&��%p+;0	�
�&�b,�%�g�%�gI�g��L�G�c9�C�G��fT�f#�g��	L�4�
��<�
��<�
������/�GD��G�<�ord�G��
�`��&d�
�_�7��$0L�
�`l�
�������^s���o*}�GL	
�`��S,�
�\��	���,�
�`L�
�G
�`��x,��l�SD�����4�
�\LD��>��
��a\�55�
9�
:�
Qa2U��
�G�G,�
�b�
�\�\��\��[�\�
�[�\
has_fields��[��_��q|�n��nL�nT�`r�`'�`�k&�`��`��G����+�k��o�`t�l�p�`��l��m�,��C��3�GD��G,�/,���!��
/'�D��O�GD��q,��Gd3�qp4��G�F��4�GD��H,�/4��G�G��4�GD��s,�,̩t�
��D�Q�G���� @	��tD#�t��$��t%	'�tK�t�H��Z�t,��t��t��t�6$Q�G�t�tM|�l�
H�G	��1�Z9�ZJ�G�t��Z
A�Z�wI�Z�wI�Z
Q�Z��Z	
	���!Z
����
J�G�`�t��Z�V�Z
�^�tX4��<Z
������	Arguments���pieces��[����[����[k�ĉ������}Z�� Z
�S�t�t!�ZQ�ZY�Z�
EJ��w���Z���Z�b��t��w�w�w;�tT�t|�wC�w�w��t
�t�����������Ne�����Match�/kK3b��!�Z5����������������;t����y��y8�xl@left_val�	right_val��	���v��y��z��
�`��`��J��x�x!)�
�tJE�w8�tNG|�l��v����|�l��v����3
�L����t,��t$��t��t��t��t��ts�t��8�<g�v��v�|�l��v����|�l��v����1
� N����t�tt��t$��t��t��t��to�t��/U�v��v���3
	��3
��G$��3*[�t,�3$_�t�4D�4
��G$�4%�4l�4
��GF#��4&�t�4]��4`�t,�4�G$�4�hi�J��;��������5�L��5�b	�t �G+7�tIXd�tx	�	φ�
		�t�
��t���
�	
	��5^��4O�GD�5�t�4�LHφA�tI�tQ�tY�tahφq�ty����j�|�6�h��5φ	�t�G*6�tHWc�tw	�	φ�
		�t�
��t���
�	
	��6`��5Y�Gd�5�t�5�hHφA�tI�tQ�tY�tahφq�ty����j�l�6�h��6l�6
��G-#��6"$�6
��JD#�6b��6N�b�6�t�6�bX�J��h��!B׍�����<
�tg+�t6=0���<��<
�}cc�e�	f���{��K�GPT��<$��<
�}�H�=&��<-4�=
�W������}���}/i݄���
������LayoutError���x�n�z��D�=��<X4�<
�}>���<5��<n4�=
�W���t��SD�=��<}����<�d�=
�}/t�=�=j��<�	��4�<�t�<��tÒ���������������������q�aXÒ��7͓f��o�����������������������q�aX����q�	���ː���s��������yܱ>
	̱>
��%��>1m�t,�>$_���?��?
j�G�?$��?��?
�4�?!��?.$�?
��G��?l�@<�@
���@L�@-��@(��@ 
�4�@"yڣ��t��@(,�A
��t3�AT�Ad�A�t�Ao��>���?���?�	�t,�?�t�>��4�?��?p ��b��t��	I�L�K�������������J���A���Aφ		�t
�+
7�tI	X
d�tx	

	L�B�t��BE��B
�n�H��B#9-�B�φ�	�t��t#.=		Kt�B�H�t!�H��B4�B
�o�HPD�Bp��A���A{��D�A�t�A�,�A��
�Hr�������t�φ$�t,�t4�t<�tDKφT�t\cjq�����������C�ĴC	φ
		�t�+7�tI

X
d�tx	
��C!�HL�D�t��CG��C
�n�HD6*�D�φ�	�t�t'4?N		\t�C������C4�C��<D�Cr��B���C{�Hd�C�t�C��,�C��q��t�������t~φ%�t-�t5�t=�tELφU�t]dkr������������D���Dφ	�t	�+
	7�tI
Xd�tx		t�E����E-��E
�+4�E'�E�
φ�	
�t����t(�t;KZ		h�t��E��E��E t��D���D���Db�b�D�t�D�t�D����4�E�bX��tφ�t�t�t �t(/φ8�t@�tHOV]d���	���������NT�N
��G$�N%�N��NA�IL�N�G$�N�-ʫq��Q\�Q
��G$�Q%��QT�Q
��I�JI&�Q���QU�IL�Q�GR$�Q�J��:Ȭ�����S��S
��$�S"��R\
u�G���PhantomData�Rҹ��^=x�h�S���R��I$�R�t$�R����b��v��XU�t~�-���Ac�����U��U���V�t.��UY
u�G���V���U��IL�U��� �����
������t��\�V
��h�
u�G�V����I���:��o�L�\����\$�]
��.�]L�]��\'��\
��������^s���o*}�G�G�`�]���\���l�\�I,�\�G�\�S�\�t���3�i7f�����L�e��Ğed�e
���1t�e��e,��e��B�e���d���l�d��,�d���d�t�ɴ�$H������L�k����kT�k
��
�G�kd�k��k&,�k
��aP�k�k�k���jq�b�j��,�j���j�G�j�byɴ��t�4�
7�i;p������L�q����qT�q���qd�q��q%$�q
��VE�qܒq��p9��p��L�q���p���l�p��,�p���p�G�p���p�t�ɴ��t�>�
A�iE|��ʹ�������T������d��L��
���ׁT߁
����G<ׁd߁���T�Ɓ
��
fT�<�<��	�Ɓ=���&

��G���t���w
������
�W�t�t����G������	�����+�҂�
��G����55�
9�
:�
Qa2U��
�G��������<ʂ
�W���t����G��������ʂ������~�������������������������q�aX�������5��,���<�����G<��G<������t����������������������q�aX���t<��������������������q�aX�t�tɴq�tb���w���n�wv,�
0�
4�9�>�
8���(���ʼ�ӽA������w��������8 ����������t���t��w�
�w5���	_ref__new�ܩ������<��#��w�߃l߃
����GA)����
5�G�����r��ۂ����t<ӂ�������t��w��
,�
=�w�����������T������d��L��
���ԚTܚ��<Ԛdܚ���Y���
��
]K�<�<��	���B���&

��G������
������
�W�t�t����G������	�w���+�ϛ�
��G����������<Ǜ
�W���t����G�������y�Ǜ����������������5��,����<�������G<ј�G<������t����a���ɴ2�t#����w���C�wK��
��
������
������������������w��������8 ������������t���t��w��
`�w������ܦ������<��#��w�ܜlܜ��8 ���
5�G�����0��؛��H�t<Л�������t��wq�
,�
��w��������
䘮$��
��G$��T��,��
���$ծ$ڮ
Tծ	

5
����O	6
?C	TȮ$ͮ���$�����D���
��G��$��9$��L��T��,��

���?Z	
��J|L��
�55�
9�
:�
Qa2U��
�G�������Ď�����4ί
���T�
������ְ	$̰LȰ
������@	װZ��������������˯���*��������������������q�aX�������$��,���GL���GTĬ��,���D����D������������������;t�����c�����x����j:��0��������������������q�aX����b��{�jT˯����������P	O	set_order�\
fail_order�j�#mfunc�tprev�{�9shared�$	next_prev�����3�����Y��'��.��5	$������l��<��
@�/L����
l��<��
A��
-	L�����H���
��G�G�<����	w,�����C����������Qa�3��������������������q�aX��55�
9�
:�
Qa2U��
�G�G�̿3��,���<��G��������,���GI�G ��=�G���uk�
m�
p�ir�#ty�����_��:�������G�	$������l��<����(L����
l��<����
(	L�����M���
��G�G�<����	r,�����H����������Qa�3�����3��,����<���G��������,���G��G�����Gh����g�
i�
l�in�#p�����������<��C�G`L����|��l���v	���	���
���0L��
��r4�����&���D�����S!�������
��l����,���t���G�������t�ɴ�t��t��tQ�T�iW��vL�����L����|��l���v������.D��
��c4�����$���B�����S!�������	��l����,���t���G�������t�ɴ�t��t�I�L�iO��v5�����L����|��l���v������/L��
��c4�����%���C�����S!�������	��l����,���t���G�������t�ɴ�t��t�I�L�iO��v5�����L�������T��
��/d�����)���
��J�GL)������d�JD���I$���t����>������L�������T����,d��ĥ����
N�G$��&ԥ��t���$Ӂ
���J���z��������$��#���
���JQ���������������������������;t����J�܀�I$Ӏ�t$������t1��d�J�7�:���������+L�������
����� $����D4���������$��"ރ�t��tD��
�`č�d���k��
5���-,���`$���`���8,���l�RB
���,ل�`$���`���X,ӄ�l
}RB	�ӄ���n4��m	ID������������ك��a\����,��b��t$��ɴL�G?�t��t����n��nQ�n��n��`��`��`��w��`Y�`L�wT�����@r�l�������kd�w�`�l�w�`��l��m~L�������
����� $����D4����Ɇ�Ɇ��$܆"���tl��D��
T�G��)-
̈�	
���'	��=��
�_�L/��-����…��������t�a\���,Ʌ�bЅ�t$��ɴ��Gs�t��?�L��L���&�L��*g�j�m@l���������y��'Lĉ���Ӊ
���ĉ!$Ή��D4�Ή����
��G$��(������v���T�I$����,���t$��ɴ��G�%�(^���ǁ�t�d�
��G ����Ɋ3�I$ي��ZT���t���\��
��J,��'������ǁ$ю#܎��ڍ����W�I$���J,��t$���b�owned�#�&\���ǁ�t��\��
��J�Jŏ+Ԯ�T���I Ώ����E�I$���J���J�b�8څ��d��L��
�G��'������2�I$���G��t�1��yD���tԈ����
��G1%����ڒN�K$���k��ts�7��}d���t����ǁ+ ����ƕM�I$���LΕ�tm@6ǁwLٝ�t��\���$��"������j�ΝC�t,���J$���bf�$ҝN���L�����G�x��"]�Y�"]�y8#��@]��]
�SE#���E
��GP/���ȭRҹ��^=x�J��������J$��t$ҟ��y��x��!E�y�׌�)
�`6�`AP���xk�xs{d���t�ѧ�ѧ
J�G�&��������#����������]�JD���h���t���b�@@U�������ͪL��t;�ͪ��(Xê�t$�����\����9 l���h䘫l��׍+!���������6���~	�J4���J$���t���`�tA�b��J	�h�@@>������$׍��J��˭T˭Ȭ$֭#�����@�JD���G$���
0Ȭtl°<°
S�G$ʰ&��������E!ذ����a�JD����$���t��8͕�������T��
��J�G$��d�����%�����L!մ��ٳ|��l���J$������t�B������L��t�ض�ض��,Ѷ�t������d�ɶ?�t,���J,����y�t��sV����úTȺ��$údȺ������
L�G$����.��-����M!����������d�JD���J$���t���t$���t�'�*�-m��Ú����L���t쀼�����,���td��<��
X�Gļ&ټ��Ի���h�b��JLܻ�t�����t��b�)@�d������L���t������,߽�t��t<��	�`���d���k��5
���-	
,���`$ž
�`���7,���l	�R
B���,޾�`$��`���W,ؾ�l}RB�ؾ���m4���mID����������ڽ��a\Ľ��,���b���t��t�����t�n��n3�n��n��`��`��`|�w��`;�`.�w6���@I�C�����k3�w�`��l��w�`��ly�mM	�ԿD߿
��J,�$�߿,�
��GF<�nTԿ
��GG��T����
��G$��,���Կ1D�
��Gf���������Y.>�2�J$ſ��,���J��G\���t�3����ۤ����ť<���J�L���t�������,���tl��D������#������t���T�����,���t}����t�"@�[������L���t��������,���t���d��
V�G��)����������X��4��؝L���t�����t�"@�\�����l��T������#������3�J$���G���1��u���l������#��� t��
��GG&������V�J$���J���h�܅8���ǭ�d��,����$��<��������3�����,��1��w���L��
��J$��\��������C��4��؝L��1ۯ|d��,����$��<��������3�����,��1��w���L��ۯ$��\��������?��4��؝L��1ۯw,��������-�k$���o,��/L���t������6�t,���k$��/���F
��GC���ȭRҹ��^=x�b�N��������k$���t$���
1L���t�����
N�G0#���t|���N������v���K�ND���o,���tc����t�"@�Y�����I
��G���t�D��������x�kl��L���t������,���tD�����t������l���D$���o,���tu����t�"@�X��L���t�������,���tl��D��
T�G��)������w���I�G,���o,���t�����t�"@�\����L���t������,���t���d��
V�G��)����������M�GL���kL���t�����t�"@�`����L���t������,���tD��$��
�������Yl��D�����#���
����R���������������������������;t�����l���o,���t ��L�ti���-@O����$�t�<�
��G/L�/���)��G�x� �"]�[�"]�y;#��@]��]׌C!L…�t䰅���
��������KE	�$?ę�G�Gk_҅�������Dʄ�k$��Y�or��y�x:�t�8]����yE׌#���~
�`�
'�`�����x��x��$��t��<����(L��($̋
�������nL���t������, ��"
����b����������������������;t���������k$��5�oN����t�*���j��L���t줐����,���tԐ����d���?�t,���o,����v�t��pS��L���t��� ���
L�G1–,���2���
��k�GS)ϖ��Ε��kl���o,ޕ�t��t��t�$�'U������d���t�ך�ך
J�G�&����������#����������h�k$���N���t���b�@@U������L���tT���t���������J$���o,���o,���tw�tk$�'SL���t\���t���"\��
��t�tJ;Ě�����ɝo����������������;t������Less��������Greater��ji�/޾���o,؝�o,ߝ�wB�w6&�)���KL���t\���tԫ���
��tF7���˟����W��l���o,���o,���w��w�$�'U���L���t�����,֠�t۠�tD���`Ċ�d���k��5
���-	
,���`$��
�`���8,���l	�R
B���,֡�`$ݡ�`���X,С�l}RB�С���n4��mID���������Ѡ��a\���o,���b���t��t�����t�n��n2�n��n��`��`��`{�w��`:�`-�w5���@H�B����k2�w�`��l��w�`��lx�mLd��,��
��G$��<��0���&���<���
�_�N/��-ȣ��â��a\��o,ʢ�bѢ�N��N���%�N����:�=k�����t��d��
��G"������3�k$����\l�
�Uφ#	�t1�U<H�tZi	u�t�		�
�
φ�	
�t���t�
��
		��
�

�:,�
���
I�S,�
�P,�
�Uw��φ��t��t��t��t��φ��t����t����l���φ"	�t0�U;G�tYh	t�t�		��
φ�	
�t���t�
��
		��L�
�9\����T$���,���q��φ��t��t��t��t��φ��t����r����l���φ"	�t0�U;G�tYh	t�t�		��
φ�	
�t���t�
��
		��L�
�9\����Z�OT���,���u��φ��t��t��t��t��φ��t����r����d���φ"	�t0�U;G�tY	h
	t�t�	
��φ�	�t�
��t�
��		��#��
�:!���f�b��PL��bP��z��φ��t��t��t��t��φ��t����y�����
�t����t,�$3�T�
��t�&�t18<��t
DATA_WORDS�T�
����b/���b���
��
��t�t9\�
��b��y
��	�����P$����������G���H������B1}-�hn�����ȭRҹ��^=x����_�$�

&.��
��

��!��
��

�������
��� ��
����
��� �� ������$���T�
���,d��$�
�����L
	\��

��,T�
���
l
B	
*L�

�����$���
�
��V����
�	�
\�D�
���=%�
������
$���T���&d���"$�
�������I������lf���]v���K����
��1T�
����B*L�

�����$����
��V���
����	�
6F��T��
�
��
�
����������P$�
���	�t��t,�
E�tq
�t9��D��bX�������������^��H�������D��b������������/�������Y��������܅���������������a�� �����������c�����������l��������q��"|�
$�

����
\�
/��Ԙ
L�

���]#�
�

����b�V�b)1�
������
Q�b�������
�������b�@,�/c��������	��$�
������/����L�
���^$$�	��Unique��������^���A����������_��M��������φ�
	�t������t�
���t�	
�
����V1����K	Z_��	�V
u�φ�	�t������t���t�		"4�8��E�V�b )���^�b�������Ձ���by�������b�����b���Qφ��t��t��t�tφ�t �t(/6=D@�܅��������L��t��{("�"��"'�Q3�Q=FPX#�
��t8#�
�#��*�Q5�t\C��m($��`X$�
�`�t&2�`Y^
�_otdi�$����a�Ӊ��b��`��`��`��w��w�����Ō�`�ً%��%��bӉ%/X&��t�t#&��H&�
ӉӉ�ti�tp4�AK|�l�
��Q����@�Q$���TL��tl�
��t��2
�����f�Q,��Q$��tk�t�:�'�
���8'�
�'��*�R5��^D��o((��`�(�
�`��'3�`Z_ًlqaf�(����a��R��b��`��`��`�ɴ�ɴ�����ѓ�`�ًL�����$���+�L���8
�����z�Q,���,��G��t}ɴ�#�i'R���L���T��t�� ,���=.�������i�b���,��Q,��G��buɴ��t�3�"7�i;o�����#��d�#�tD�#	�t��#^��#ʼN?	3<�#<�#��#:=
	��#d
^$�$
��tt�$
�
��$
���Q�Q�$$�$��tt�$
���$
���Q�Q�$�$���!���$��$ ��������������������q�aX�Q�Q��"��,�"�Q<�"�Q�"�G<�"�G<�"���ɴ
�t��t��jD�$�t:�Q+�t��Q�z�
~�
���������
Kʼv��	|�	
����g$�	�	��	�	����	�b�	��,�	���	�bs�L���
��9	


T�9	��;4�9	
��U/	D�9	d	\�9	
,�9	�����:	

	
����g�b�b����9 	l�9	
�����g����	s	:��93	,�9	
�,�9	_$�:		��9-	�:	

�:	(��4�V�b	'L�:	$�:	
��gG
	#�:	��8�	�:	
.�r�N��9L	�b�9	��,�8	���8	����������������;t��������z�j8��/�b��P���0�b2�gg�������	�D��"��M���������f�:	���:	��'�V�b&L�:	$�:	��A�:	�*�b�:	��@�g}�������h���������U	
��G�b�J����U.	|�U	
���G�����J$�U	`��U)	�V	���Uy	�b�U	��,�U	���U	�b����$�'S����U	����U	T�V	
��G0d�V	�V	�9�J�U	��O��o����o�}�
��t�	T�t	����t	4�t	��*
D�t	��t		\�t	,�t	�����u	t�u	
�,�u	
��u	l�v	,�v	
�,�v	
<�v	T�v	
����v		
�
�v	
�v	(��4�V�b'�v		
�v		
��p�	8H	,��C��t�	��v7	
�g�q	�SL�p	���p	�������j�����b��bv�R4�v	��`��@�i�l�	�_guard�O	
��h���������R\�Rb��iT�|	����|	4�|	��*D�|	��|		\�|	,�|	���l�}	,�}	��,�}	<�}	�}	��|}	���|&	�b�|	߭L�|	�������j�����b�1�	�u��
���\��	�St��	�S��	�����	��t��	��_#�
@�t���t,�$64�\�
��t�&�t18<��tMAX_OBJECTS�\�
��t�&�t18<��tMAX_OBJECTS�`)�%��H)�%
��T8)�$
�)�%�-�T8�Q|�TfM�����}(*�%	�``*�%�`�Q&�`H*�%�`
�T&	
2	�`��
�_����ns�*�%���a��T��b��`�`��`�Ӊ�`��`��T�ָ�D�R]Ӊ�`UԸ�`(ķz�,
�t��,��t,�,%8��V
��t��V,��t,�V%128���^L�^��$�^\�^��^�5�5I�5��4�5phantom��4�5��4榦��������)��)���)���"��#+#��K��
������^���^O�<�^��,�^����0 F��N��0t�`����5���\En�m����ManuallyDrop������2ҏ���Z�O��`($�`
����������b��V���`̠`�`���_e��T�_��,�_ӽ:Ӿ��`φ	�t��+7�tIX	d�tx		�`�
φ�	
�t���t�
��
�		�`
���*"�����`����`��lφu�t}�t��t��t��φ��t�����nH�����a�+�+p�+��*�@��n�*{�t��a�a
�+�t[,�a��a�a�t�a���aQ$�a��,�a�t|���>���$�g��g
���h����h�h��+,�h��h����h\�h
��\�h�h�t	t�h��h#4�h
�P�t	\D�h��h9�h
�+�t�L��h(��il�i4�i
�$�i
D�i��i
��CachePadded����g�˰؎��R��i+
���h#��i
��=$�i
��0
��i��i4�j
�
d�i	D�j��t|�t
�
T�t����t�	��+��u
����v
��L��t
�w<�uL�uRC��t��v\�v,�v
�W�Q�Q-
<�v.��v)��x�2�"]�g�"]�y5$�1�@]�1�]׌D"��y
����x(��x
�Z.!t�z�+�+p�+��*�@��n�*{������������:�"���t��z�{
�+���,�{t�{ ��\�{"
���t�{�t��{
�����,�{"Q!-��{'�{
�+�� �!Tį{<�|$�t��|(%��|��t�t.	%$?#
$?��t��|-#l�}4�}��$�}'D�}4�}(�}<�}
�'M(,&|�},�}�}�}��g�b���g���h���i���i���t���t���z�)�S,�g��,�g�S,�g����t\�h����b���u�t&����������������;t����t��Qd�i�������)�G��QL�i�Q<�t�t����8�G�G���2�yd�x��b�G,��,�z���b���{��C��y�t��t���bU����w��#��*�global_epoch�E
	new_epoch�+�
.res�3������t���t�����n��4�������c��j��	�����������,�y�׌��������y.
�
�Z��z��������������SlU
�`b'�`m|�K�x��x����~����~�~��+,�~��~��|�~��t$	'�tJ�t��~%�~���v��~��
T�
����6��
*	��|�����
��T,���	}J3��+����������,
,����
	
|��D��
�$��
T��܀���~���~��b�~��,�~�t\�~��<�b����t�v�bl��u����Qd�GP�t���b���*�������'�����������\��*������������.,�����Ί�t&�5�TZ	
�S�V#�`�V'�ڊ�����	���t&		(�tL	�t�ڊ'����z������Ή�����
�b���,��td�����T%�b���
�t��vL�*O������t���
������������.,����������ƌ��.,ƌ����t&�9�TZ	���V#�`�V%���	��������t&	(�tL
�t���'����	�
z������	�ȍ	|�D���$�	T���������������
�b���,ދ�t\���!�td��������b���y�tl�vt�b�g�*j�*b������P�����g��(A��`�A��`uu�w�x�ִ'
ǯ���VYe�`��ً�����A����a��V��b��`��`��`��������*5���`-ًI(B��`�B��`��'�`�B��`
���ȭRҹ��^=x�G�WP	
\	�`��ķ�������B���a�V�b#�`+�`�`&��/�`�`���� v������`����`Yķ�HC�C��(2�W<��DM�Zd(D��`
�_-2:D��Q�a\��d�bk�`r{������
l�:\�:
�L�:��<�;
����:$�;
��VD5,�;��;$�;l�;4�;
��V,D�;*	<�;�;	���4�;	��<�;
����;$�;��?0,�;
��;$�<
T�<�<
��V,,�<1E�
Z9E�
Z��G�W�w�E�
Z

AE�
Z
�wIE�Z
�wIE�ZQE�Z�E�Z$�=d�=,�=
��V,	<�=�E�!Z
���E�Z
���y�E�]Z�E� Z�z!E�ZQE�ZYE�ZP<��= \�=
��W�G�,�=
.\�=
��;��=��:����:���:���;���;��E�
�Z�E��Z�b�:�VL�:��,�:�������^s���o*}�VD�:����G�����������������;t����������j������$�;����G}�{��w�t@��Y�w�w��w���t��t��|!E�ZH�|k�b������q�#u�.?�]	succ��
�|��|��	�;��w��6�����v��>��_�z	����<
�t@O���wk�tOz��?�L�?����?4�?��+D�?�?	<�?�?���4�?��<�?
��T�?$����? $�?��SD$5��?$�@
T�@�@��
%	,�@|�@	$�@��@D�A
��V,�A�t\�AL�B��|�B�B��+
,�B��B

	�H�TZ	���V&�`�V%��C%��L�D��<�D
��<�D
��T�D&����Cs��D
��V��%�t$�Dm^&O��D?I	��Cy
j�I�55�
9�
:�
Qa2U��
�V��L�I���JL�G����G,�G��+<�GT�G'����G*\�G
��Y�GW'9,$�H$�KT�K�K��%,�K|�KL�K����K��L�L(��<�L
��T�L)����L#$�L��(RD)5̞L��L/����L
�����W�V�W��L
����������������������q�aX���W�V$�M ��M�� �V<�N!����N��!��N����Ol�O
��Y�G�O#(��O"
�����W#��O%
����"�V$�O
�����P���>���?���?���@�
��C�
��I�*����������������;t�������>���-��#���.���.���.�����"0k��|��G�YL�>��	��K�j����$�?����G��t������$�@��z�t��;���$�C��������������������q�aX�������'�G�G�j,�E�b�����1����t������{��"�GS�����`��?����������������������������������n�|���4	�����l��.��������*��BЄ�����2���\�

L�

�6'��&
��

��

��G+8
?|�

�-�HO`�
��j

��G�
�
����
�Y$�
�5�5Once��5inner��5=d0ݞh.��-�-�5�-��*��]����H)�H(�L�
ےij
d�

�6-t�
'T�
����
�

�-�H0,�
��
φ		�t
�H*
6�tH	W
c�tw	

	�
�φ�	�t���t����		��&
��

��G,��
����
�b�
�YL�
�ے��bi�H������φ��t��t��t��t��φ��t���������Ҕ<��
(N��`�N�"�`�������g�˰؎�uu�w�x�ִ'
ǯ�����2��������lw"+�G��`�N�"�`
̙(	
4	�`-3ķAG8>rwfN��~�a��Y��b��`��`��`�̙��`��`�͜�͜����͜�`���`4ķ"
L�"̙��"
�̙/!<�"
��;$�"
���j4,�"��"$�"d�",�"
���-<�"4�#
��<�#
��܍#$�#��
?0,�#	��#$�#
	l�#4�#
���
-D�#ĸ#	��#"$�)
���GD�)
������������������;t����G�b�)�#���L�$̙��$T�*	<�$
��<�$
��J��$
����������^s���o*}���$�$	$�$��,�$
��$5��$�	
��GТ�����Т��ӡ��$��$
�WТ55�
9�
:�
Qa2U��
�����G��������$���$�<�)
�W����b��G���b�b��Vʥ4�)|�)�)���!���"���"���#���#���������������������q�aX��b��"��,�!��,�!Т$�"���͜�G�ӡ�"���Т$�#ŧ��Gw����������������;t���ӡD����j<�#ӡ���������������������q�aX������������������������q�aXТ��9ŧB͜a�G3�G'����������3��#��.�h����	n���	���������:���Ƣ	�����^	L�%��̙��%�9<�%
��,�%��G$�%���@1��%$�&��$�&d�&
�ТТ?2*0��&*��̙��&�	�<
$�'��<�'

��<�'
��,�'��{��'Ƣ
�$�'y
`QB	��'5,�(��$�(��̠(l�(
���M@��(4�(ӡ�H��(��(
��G?��(��(
���G�)���%���&���$��1Т�$Т$�%ŧ�͜�G�W��pөŧ
͜=Т��G��G��bMТv�G�H;����������������������ӡ$�!���#>���.F�������k	ӡ�9:����٭��3Ƣ:��W��
_ref__self�_ref__guard�
_ref__head�
_ref__next�_ref__n��)���b�)ʥ����)	��6tķ6d�6
��G$�6,�6��61	D�6$�6���7��5����6,�L�5��,�5��,�5̦��j�$�#'�.�w���
l�;\�;��$�<��<<�<
��G+,�<t�</�<<�<
�P�GWL�<+�<L�<	̙��<�	)<�=

��5$�=��^
.,�=��=��=T�=
���D�=	d�=ܣ=$�=
��������KE	�$?��
Z�=1��;����;���<a
�b�;�YL�;��,�;�����7ТD�<ŧ�͜��G�b��Ko�#rsentinel�V�
���ٸ���h�4�;���������^�R��a

�R�a
��P�R��a�����������������;t�������������������;t����P�P����Q�t�b�������3#;Z:��`�P�Q�tbX���_�\�	L�	
���	D�	
�7T�	R�a��R�Da�P\�	��s!�����j�R�a
�R�a
��P/5�R��a
�����b1�	R�a�R��a�R�!�a
����b$�	R�!aO	R�$a�R��a�� ����b�����b�V_��R�a��R�ZaYR� a
�f�P�b
�9�R� a�R� a���R� BaR� a����R�a�������������������;t������R�a�f�fStorage��f��f�f��fm�՟���P�b3__rust_std_internal_init�t{��Z��
"\�

���P�S�b�S�V����
N�
���	@�S,�
���d�
�

�4�
,�
�
���S�
�����4�
handle������(\�
�����b�V��ܦD����
K$���z��L�
�4�\����������4���
���y4�

����g��D�

����g���g����
"D�

��P����g�����g�~��
��

����g�E�E�EAccessError�N����Av�g����
Zt�

�W�g������g��������
.�
�
�����g���,���������������������q�aX�g���������
���������Z�������[������������2������������
��$�

(
�����@3;�
�=�g�
��S���
��z��n����������_ref__f��
��\�
L�
����
D�
��3T�
��
��

y���'0�
�
����g�
�����
�������P������E�V��_��,������P��P�����
��G�)�F4�`;BP
��Gi�v�F��`����q	
��%�R0��8?M
�c�p�R{�������	
��&�S1�S8?M
�c�p�S{�S�����������,�+���/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� 2��%@$�%���F�g�g�
	�

	
�%���g�%���g��%��g�g��&�g�g��g�&
�G�g�g$�%��3UWRT��&BD�'���F��g�
�

�'���'����Ė'����h��'������g�'
�G�g��$�'��']_Y[��'$�(I�*�5��(4�(�t�(�Z�,�)�Z\L�)�Yb\�)���D�)����(lacRTDF68&(��)���*��+�T�+4�+/15?HJLNPcu����I��4(�g4C�hLK��a��p�[ ȭ\��!ȭ�!mem�$��#�G\���$�,��&DerefMut�D��'���(�,��a)�#,��*b\���,�D���-
AtomicConsume�l��.�q�e�4!Z]ORL[FLj:�y-��
�������L��\�Ĝ����7������&~��8ԙ�G�G�q�i�4t���%��;8 The error returned on failed compare-and-set operation.�"Use `CompareExchangeError` instead���:����
2�3�
4423���G����G�55�
9�
:�
Qa2U��
�
�G�G�TVQS��I��<9 The error returned on failed compare-and-swap operation.����
6�7�
8867���G����P�GL���G�GT��G�
���Qa2U��
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��^�^��^��[�^�a�[����e�S���a;�
;
>8�G�G$�
��6����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��t�II���G�P�GL��v��4t��t�b�KK�����L���@==��G\��t�t�t�MM�����L�� @�)@��Fl��t���OO�����L����2A��'�� /, 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�tL�(��( The type for initializers.�$�(PP��)*��(-* Initializes a with the given initializer.��)�d�)	 # Safety��)���)/, The result should be a multiple of `ALIGN`.�$�)���tPP
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.�,�,�t���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�/�t���P�WWP
V�����/�/܁3��052 Drops the object pointed to by the given pointer.��0�d�0���0���0L����1D���2Z���2ŭ$�3�t�bPP
X����3��3�ZZ���3�G[\]^`bQRSTVX^]b`13��3,�3YY�tL�3$�3YY�G��4)$�4���tYY
]�G�sB��4+,�4�t��GY�__Y
^�G���C�4��53L�5�t��GY�aaY
`�G���E�5Ԝ6$�6�t�bYY
b�G��F|�;,�;�dd���;���{��KefT�;�;cc�t��;D�;cc��G�t��<�ii���<�j
��<4�<�t��hh��	GI��=&�ll���=�HmnoprtQRSTVXtpro13��>,�>kk�tL�>$�>kk�t��>($�>�HR�tkk
o�G�	YL��A+,�A�t��Hk�qqk
p�G���N�A��B3L�B�t��Hk�ssk
r�G���Q�BԩD$�D�t�bkk
t�G�^T��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ִ'
ǯ��wx$&��J$�Juu���J<�Juu����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}}����U��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��ʫ�=V��R"T�R�t�I��ǁ�W��U ��S&# Returns a new null atomic pointer.��T�t�T���T�<�T����T ���T���T" let a = Atomic::<i32>::null();�<�U��$�U�I������\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�������^s���o*}��G��\���$�\�i�Y�Y "��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�������^s���o*}��G��d�
��G$�d�Z ��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�b��
���j������j����GT�j
��G��$�j�
�[�i�[8:��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�������^s���o*}��G��
���p����p��T�p
��G��$�p�
�\�i�\�\@B79��~���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�������^s���o*}��G���G�G��S��������������������q�aX�������^s���o*}��G55�
9�
:�
Qa2U��
��G����
���������T�
��G��$��
�_�
�_�`�
``OQFH���<closure_kind>��<closure_signature>��<upvars>�����L҂��������������������`�����^����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�������^s���o*}��G���G�G��S��������������������q�aX�������^s���o*}��G55�
9�
:�
Qa2U��
��G����
�����������T�
��G��$���
�e�
�e��e��e�eRTHJ����������������Lϛ���������������������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�������^s���o*}�
�G���
�������������������̭-���������������������;t������
��G�
��$�����k���k�#�k��$�����������ݰ`���±^�����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�������^s���o*}��G�G����S��������������������q�aX�������^s���o*}��G55�
9�
:�
Qa2U��
��G�G����
���Ͼ�����Ӿ��־?�������G�GT��
��G���G$��
p�
#p�i.p�#9p{}hjln�������`�����^�����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�������^s���o*}��G�G����S��������������������q�aX�������^s���o*}��G55�
9�
:�
Qa2U��
��G�G����
������ۣ�������������T��
��G���G$���
�r�
�r�i�r�#�racWY[]���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�t�G��S�������^s���o*}��G����
��G$���Tt�i^tit.0���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�t�G��S�������^s���o*}��G����
��G$����u�i�u�u.0���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�t�G��S�������^s���o*}��G����
��G$���&w�i0w;w.0���*���#  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��
��GDx���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����
��G�y���4���������L���I��_���8������I��^�^��^��[�^�a�[����e�S���a���
��G$���|���6���������L���I��_��…8Ņ�����I��^�^��^��[�^�a�[����e�S���a�Ʌ�
��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��
��G������"�������I���ԉ�$���J�I��
��G܅ʂ�ҏ�����׏�I������$���G�I��
��G�]����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�����t��
����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���t����
����G�$�����'���#  An owned heap-allocated object.�����š*' This type is very similar to `Box<T>`.�����b���ԛ*' least significant bits of the address.�,�����������L���JKE	�$?ę���+-\��$�����t侜<�������ߜ3��������L��J������')䧝T���J�t��
��G+����)���@��ܞ�d���������-* Panics if the data is zero in debug mode.�Tǟ�t�J��
��G�b������������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���h�J��ǭ@��������,) 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��������$��������L���J�������&���Q����t������<�������ݣ������%" let o = Owned::<i32>::init(1234);�<���$�����J��Ȭ����ٳ;�ް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�������^s���o*}��G���
��G{��� Ԥ��۴.+ Returns the tag stored within the pointer.����t�������<�������ݣ����*' assert_eq!(Owned::new(1234).tag(), 0);�<���������J�t����ť$�����-���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�t�J����C��M����-���������L���J����Ի$׻���J�b�ܻ�
��G$��ݼ3��������L��J��_����8�������J��^�^��^��[�^�a�[����e�S���a����
��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���
�����ˇ����0��L���L^s���o*}����68�\��$�����t���(<�������ȭRҹ��^=x�
�b�N���38�����ˇ���L���N������,�����N�N����
�8�G$�����28�����ˇ���L���N���88�����ˇ���L���N������')��T���N�t��
�8�Gx����)T���t�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����
��
�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����
��
�G��������.ςٌ�t�����<�������8���ō,��������>; let a = Atomic::<u64>::from(Owned::new(0u64).with_tag(2));��������"��܋� assert_eq!(p.tag(), 2);����4��<��������L�t����
��
�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�t�L�ޕ�
��
�G$ߕ�e��Ӗ(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@N����J�
�����ˇ���L���L�����#%���"������L��L����
��
�G$�����œ08�����ˇǜ�LӜ�N���K�
�����ˇ���L���L�����#%�ɝ<\̝����L��L���؝�
��
�G$ٝ�����18�����ˇ���L͞�N������,������N��N������
�8�G$���Y��ϟ88�����ˇԟ�L���N��_����8�������N��^�^��^��[�^�a�[����e�S���a����
�8�G$��������:8�����ˇ���L���N��_��â8Ƣ�����N��^�^��^��[�^�a�[����e�S���a�ʢ�
�8�G$ˢ�8��̣58�����ˇѣ�Lݣ�N������<���N��
�8�Gl�,L�,�����[���#,�����)4�����*,����I��5��L�l��]�� OQ>@��2����%" An epoch-based garbage collector.�L��OO�
wC���4��������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��^�^��^��[�^�a�[����e�S���a��	�
�$�	��	�
�O�����
%��
74 Checks if both handles point to the same collector.��
����O��O��
�
�$�
rhs��
���O����$! A handle to a garbage collector.�\��P�xS]�Bj����,��������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�b���
�$����P��_���8������P��^�^��^��[�^�a�[����e�S���a���
�$���d�,D�,����I����!�[��ȭ\8���ȭ�����$U����G\[�����s�����L��*r�ILO=?Lm/��T���tL�$���t�M��tԕD��P�so������Ķ$��������$���������G���H������B1}-�hn����<��������P��_���C������P��^�^��^��[�^�a�[����e�S���a���
�$���l��P�����,����P��T�����b��_raw�$���	,�	���P����������	����bD�	���b��b
����!�:<��)$�����b��������D�����@����)$�����b��������D�����@
���$��P�b��
�$�L�-,�-��b\������D�������746!T��Q�������� D��Q������
4d�
�Q�Q�j��
�$�
���
��%L��Q��
�$���#4��Q�Q��������%D��Q�Q��
�$���&L��Q�Q��
�$����R������'��Q�R��
��",���1$����R�G�Q�����$��i(���7,����R�Q�G�b�����$��"���i���!���!���R�Q�Q�G�G��"���$�"�
7��
@��I��R�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�,�	�SR~�W�k�.���	,�	����T�	�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���b����
����	����	���	��l�	���b��g�	����$�	��<�	
����g$�	���_adf��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���b����
����8	����8	���8	��l�9	���9	��$�8	��-/24<�:	����������������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�������^s���o*}��G�b�����U	����U	
��G$�U	���<�U	����������������\	��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�b��\	�
�$�\	��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�b��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���g����
����p	����p	���p	��l�q	���q	
����g$�p	�o�68;=�T�r	��R��tn̴'������R��:����R��
�d�r	�����Ĩr	�R�����r	$�r	���R�b��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��{	�
�$�{	<�{	������������������b��|	�S�����|	$�|	���S�b��|	�
�$�|	̪}	�S��_���}8	�}	�����S��^�^��^��[�^�a�[����e�S���a��}	�
�$�}	��}	���-	��~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��7d��	��S��(��!Q���S�Sp7��S�S��
�,��	����S���!	�S�— 	\ɗ	��S�d�.D�.������5T�����$����D�����p$��+����$������d������D�������������[���������\�����,�����4�����L�����\����� D�����7\�����6,�����%\�����#,�����8,�����-L�����8L�����8$�����9,������"��0
4������������������������x{il��*_bPS��E��"8;),��""��6	������̍�ą\���t����T|K�1{�Jg�����"L�����P�A��tT������tĕ�TD��T��������T��
���%D����T���
�$���TD����T�P��������������������q�aX�b�P���
�$�� D���($���T�Q�T��
�$��",����T�����<��T��
������t���T����� $� ���T�b�� �
�$� ��"�T��_���#8�#�����T��^�^��^��[�^�a�[����e�S���a��#�
�$�#��#��&�Tt�&�T���'1T�'����T�Q��'�
�$�'��d�'��)4�)���#+#������*4�*������8��.����͐�y�7��U�U��+,�+������9��.���9� ��{�XW�T��+*,�+����\�+������Ԣ,l�,����t܏-�-���
���/;D�/�������T��S�b��/�
�$�/�*�/�#,�/��4+<�4������S�b��4���$�4�#,�5ĭ7����������������TӉ��;8\�;������S�Q��;�
�$�;�#,�;��K,�K�U:y8�T�0�������d�L,�L����V��M.L�M���ӽ��N�N������5���\En�m�TĊO\�O�������Od�O�������P L�P�������Q,�Q�����T�U�U���������������V%īV����t��W<D�W���O�P��W�
��L�W��^&4�^���U����^���$�^��_,L�_���U��O��_���$�_�`���������������a&L�a���U��a���$�a��cH,�c����U�P��S�b��c��$�c� D�c�#,�c�c��������������T�T�b��e),�e����U��S�b��e�
�$�e�#,�e�e���������������	�b��g!�g���U�S��g���$�gԎ~,�~���U�b��~���$�~Ԛ�,�����U�b����
�$���Ή#t܉���U�b�����$����#tϋ���U�b�ދ���$ߋ�ӎD֎����U�b�ߎ���$�������������������	�bΖ���������������b���U������������#D�����U��V����
��	,�����,T�����V��U����
��*,����0D�����V��S�b����
��*,���#,��D�/$�/����!$0�����ȭ\����ȭ���G<�����G�����<�����������<�����������%\������4�u����#,������4���������9��������+}hjTV?A��L�����������Ѕ����"��(���������<>�D����G��V���
����G���&T����V��G���
����G���)D�����V��S�b���
����G����.$��
���j����Ѕ����Y���Y�Gd����� �X�"0k��|�������UWRT��,�����
�S��$�����
����$�����������^s���o*}�
�V��$������	�<�������ȭRҹ��^=x���Y�� �V����� <�!�V��
�T�!�V���$14�$����V��S�b��$�
�$�$�#,�%��%#��j������%���W�%��W�Gd�%�V���24/1ܞ&�&�V��
��G�W��*U4�*���V�������^s���o*}��G��S�b��*�
��G�W$�*	container�L�*�#,�*46��7D$�7���V��S���-��#���.���.���.�����"0k��|���G�W��7�
��G�W$�7�#,�7#%��9,��j������9��	�9Ͽ	d�9�V���"$')��:$�:���V�b��:�
��G�W$�:��=<�
���j����Ѕ�=Ժ	�=���=�	d�=�X���J�J��=79�?AL�>$�>����������������������q�aX���W��>($�>���X����������������;t����X�J��>�
��
�G�Y$�>�jLy��5T�
�-���G\�
�����$�
�5����
B��
3|�
"��
D�
������
�Y�A�K��ˡ���!#T�
$�
���ے��!
,�
�������0
������
��$�
��$�
�Y��)
������
��$�
�Y��
������
�Y������!
-\�
�
�Y��
��G��S
\�
���Y���G�����
�����	�
���	�bl�
��	�b��G�

��G��	$�
��
GI��A
T�
����Y��	�b�����
���	�
��	l�
��	�

��G��	$�
��
/1�
��������������G��	����	���$
l�
����Y��G��
�
��G$�
��
������
�Y�����
$�
���Y�b��
�
��G$�
��,����G\�����G<�����G�����<�����������<������������\�����%\������4�u����#,������,������4�������+��9!��������2����uw`bKMt�$������������lw"+��!��$�����H��$��������&��������$��Y��
&������
��$�
�Y��
������
�Y���������
�
�Y��
��G���l��������Y�������^s���o*}����������^s���o*}�����S���
��G$�onto�$��
��#,���.$�����Y�G��S�b���
��G$����#,���!>d�!�����Y��Ș��!���`�#5�$���������������)������������ʥ��+�|�+�����Y��	��Ș�����+���	�+��$�,����	��Gt�,���	��	�$�,
��G��	$�+	condition�L�+�#,�+vx�/��������������G��	�����4��������������G��	֥�b��58<�5����Y��S���5�ٸ$�5�#K��8�T�8����Y��	��S������9���	�9��$�9����	��Gt�9���	��	�$�9
��G��	$�9��	L�9�#,�9np̆;������;�Y�����;$�;���Y�b��;�
��G$�;��/:�,�,�,�,��0�----(-(-:-:-K-K-]-]-8o-o-�-�-J�-�-�-�-\�2<�2�������L�����\�����#,�����d�����0D������*oq^`��Q��B�� 0��$L���O����%L�����0��0�����A�K��ˡ�OC��������	��	 Pins the current thread.��
�S
�D�
����������������
��
30 Returns `true` if the current thread is pinned.�L�
�D�����������������0��)& Returns the default global collector.�����	
���J\�����g���
���������������P�������	��g�

����g�N)_adf�
���������������
����������������23�-�-�-�-�-�-�*T� ������ �F�\En�m���`�F�*N�`�F��
��Gceܕ ���`�/�/�������_�G�/�F��_����/�/�����F��^�^��^��[�^�a�[����e�S���a���
��G,���/��,��Q���o�2"��\�$�����t !�$�Q��%�Q��������Q�Q�"��
�,�����&�Q��������Q��
�����'�Q��_����������Q��^�^��^��[�^�a�[����e�S���a�$��
�,����#�#�(�Q���#��#�#�#�#�8�#�#�#����Q�b�%��
������)�Q����)�Q�����������Q��Q�&��
�L�����\��R��{CH�]����$������)�)�*�R���)�)��R��
�����+�R��_����������R��^�^��^��[�^�a�[����e�S���a�(��
�,���Ȅ�%	L�%��Tt�`�fr���d�%,�%����QL�%$�%����TB�B�,�T���B�B��T��
�����-�T��_����������T��^�^��^��[�^�a�[����e�S���a�*�%�
�,�%��ڼ�,��V��?m�4a����$��������:�V��_��������V��^�^��^��[�^�a�[����e�S���a�A��
�,�����.$���j��������	��Ͽ	d��V͐�y�7����136��G��$�������<������X�X�;��j��������	���	X��_�WX�Ͽ	��V��_�����X�X������V��^�^��^��[�^�a�[����e�S���a�B��
��G�W,��X���L��W!H�؎tֻ���<� ���W���W��<�W��<�W���������W��W�C��
�L�������=�W��_����������W��^�^��^��[�^�a�[����e�S���a�D��
�,����ԑ,��������Y ��{�XW���!#��"$����̙��"$����̙B��������	�Y��_��������Y��^�^��^��[�^�a�[����e�S���a�N��
��G,���Q�t.b4�	����R�&a�R�a��P���!�������R�a���������������R�Oa�R�a �����������R�!a���������������R�"Na�R�"a ��f�f���f��f�f��fm�՟���P�������K=�V,>�V�
�VA�V�
�V��V�<�V�;�Vp;�V*;�V�:�V|:�V�\�V�d�V0�V�p�V��V��V���V���V���V��V���V���V���V���V���V���V���V��V���V��VӅ�V��V���VM��V���V���V���V���V_��V���V��V)��V���Vػ�V0��V���V��V���V���Vw��V+��Ve��V���Vå�Vm��Vq��V���VЛ�V���V��V���V��V��V��V���V���V��V���V���V���V��VԢ�V��V���V��Vj��V���V�	�V�	�V���V��V��Vw��V��V}��V���V��V��VI��V��V��V���VK��V��V{�V�l�V}b�V�U	�V�^�V�Z�V�V�V^U�V�R�VR�VSQ�V�}	�V�}	�VI?�V�>�V�=�V�<�V�#�V�#�Ve<�V�:�V�/�V�/�V�7�V+:�V�5�VZ9�V�;�V�7�V57�V�6�VJ6�V�5�V�c�V!5�V�e�Vz4�V14�V�3�V�3�VH3�V�2�V�1�V^1�V�0�V���V�.�VV.�V�-�V��Vv+�V�%�Vd(�V�&�V[$�V�#�V�"�V!"�V0�V��V��V��V��V��VY�V�!�V�,�VQ�V�+�V��V�5�V�9�VP�V�9�VY�V��V��V��V�/�V��V��V��V���Vb�V��V��V|�V��V���V

�V
�V���V
�V�V��V5
�V;
�VX��V5	�V;	�Vv�V|�V���V��V�V�Vh}��������������������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
UnsafeCell
CompareExchangeErrorcurrentnewunaligned pointerAtomicrawtagconverting zero into `Owned`Owned'converting a null `Shared` into `Owned`'SharedEpochdataAtomicEpoch�	SealedBag	epoch_bag'participant was expected to be unpinned'#assertion failed: handle_count >= 1#EntrynextListhead_markerStalled&assertion failed: self.curr.tag() == 0&Queuetail�
�
��
��
��
��
ʢ
Ԣ
ޢ
��
��
��
ȣ
ԣ
ߣ
�
��
��
��
��
ʤ
��
��
��
��
��
��
��
�
��
խ��ǣH��gLIJ�ͧ'��
�A�\>��@/��	�xCܙ!K*H�\Ř/u��a3Nϖ8pJ
���o�>�QC�x��t
�����$H�\NT�d��I��w�y�D��o��_���Cǐ�7�"���
��-�Y���wb+r�H�}�g�����1j��Ͱ�Q���Qq���E��ϳ���5�]b���څ���@a)a���.i���(}Xk��&:���ֲ%C���
�[h�/��	i ��/U+���I�3��b�@�&+�������o��Х����o��6���u���u4~��9��bF�X� �����?��@���vR<rjkrE䑊���}�ʐ�'X�A�����4��
��e�
���B�b��81x:2z���-��'e�Dɖ�H��-��r�b�G�����z%w�����ڣ��Gm��>1��ǧG∢ďQ�H;O��2�c!�n��*��Oi��������%�˴�V��j��G��%��X��&6�tVI�}�?�N��m��-5��Z"��A�����3��~�R�ű���Q�ڻwH�t��h���K��1w�ui�r@=�y܍��
4˜����[�%��&1�1���NYĀ00
�k(�\@�b��i�G?�`
Sjj �8�i��*�݂o�Y:�4�-���O��*������om99|ֹ��a,<���\}F����[�LPP_�q�&�x�����t@������js����#	��"�A�7���>��F��:�ƺ���~�Z���U��_Ԛ�*6$����i>���D�!p
N��� ����L��cU��[u�����a~`'B�æ�.>Q�͕N��#繕hwf:�6��7>_Z_d�8�5t�ךɟ,:(��;�R��#��׳�b]T>Чb8�T��p>q����~�W�`�o��lT�(�ri���\k�h3#�7g�bfILV��a�@��2���O�ab�CY��M��'��oW%!Qܲ���1$�nZ�a�ş�%�v��ÿ���Vo/7�^�_i2^>�H��!�o�dn��)xt+��e�Q�8M�[#��d�i;L�vj���t4�`+4������H5��r(#�{->�V��E���+������J����I�����"�\(j?t�z��rC{>^��y<�]� �ƼIgh1���h�(Z�,�%5&=��{�{�mwP�̯�o�#p�M}k�FT��_sT�I���a�v����s�<lپq�fH��g��K��ރ�:����p��A��L��*w��`ܱ_��E��]�ʼnXݖ��v�U6�;��i�{՝bq�����]�
G�)��H�Y�4ff&d����/m�C�������;�Q�Q��J��lR'=�7�:������w
{��m�
��խ\/{���$�[H\��]�)�}��I`�4�'_C�v�����>~��
����
]�yA>�-g
Nzb��h�#,iT�8,d���P�ݺ��. bD��DK�S.�(���D�gML�4����SZ���&SO�ܙЙ��D�<y�",��ʎf�n����~�|EO�-��@�]~��JSK˩ �¬�-�к>�'��X�gsLf�&:��*�`Fڙ�;BB�S�	�џ�g�AJ׿�1T�/��:)�x�BՙD��sN��N,`��م>ص�<9�S]#e�
DB��U'(Sj
��'�Gb��Z�1��5tO�}ts�q��/��c}��]z��쨋*c�������Nu�΃B��QD���F�fÎ��O�ڨp[�%���"��U��g;q�����
xYd����"�5�K��v��^����E�����[1Xj�%~�$6���6l��>�ezw�l#�b
�X}�io�Z���2u�\a��E[T����d�}��~^���s�Wbp�c�E�h��_z!>����J�n�j���Y���7�4QO{�v,����iJø�l�-�I_~9��9Ӵ�Kp'-\�P+6o�2E+�5@=#������>���&�^Z��.ݾƆ�v��i/%I�P���0��i"���x�o;�o�%O���myI��)׿��܎l�Ń�w���h�����W\"Aw
A�*�rP��~���¼�-̔�)�?\��c�%V(��Pk��9�U,��mR�ҟ�Y�(�*�Yee��!�"y��*)v���#҉7��p�veA�/qwZA@V�*܇_.zw�FFE<J��&9�kG��i�(�ج�y�8��?��?-S6G�|�A}/!~�qi�/�47���q�BV�A�)^k���`��XNQЋ���
=l�U-3fB�����-�Sp�)��4b^u�fr6ꯊA�H�R�)�RN�ˇV��y�
��噏<�E��ITh��u/$5���t��܊7�b�N���ź��•����Ⱥc_@�O���~,��A�Q�ʲ�IX�����50�����@F����zi�R��r Q_�̈́\N��9_$a{	刽����4<��3l����[�$O)$k��
sJ�п��%��W�ȡ��iry�x�I�лىeG(į������ �Ֆ0���+m��=����~+��/�4�)Ӑ����Sl"��D�lL�O�%�ց��i�co�6'�Ȁ(�סšc!9�l���'�k��ȒVo�蕲hڎJ$:�-�Ut$��iŷ�"�Dy�cg��s�?��O��4a"�H�N+u}�$ h[l�۩�3\j��)W��S����s���2Ȝ7|��IC,:>���%(����<����x�>���׳�o���1[$D����Rl��->!��=��V�搙�I߂s����}j��h*%�Fhle��MG�!��k��`o��:��!Q[�<���ȿ�M�D(�i���=�y!!f��
���[ʞD��X�I�T>�<$uS�oOe>�E��Ajh��<�@ǯ�,y�Xza�]�=K�Eˢ�t�6� e�x�uɓå�o���g���h?����Ns����Z#?��Q�W��y!1���L��N[x�G�?�tKpm~�3e��/�itcr�)r�8GV7����Vi)����J������KI���ϋ�UnX�4����W��_
R�[���p��c����WF�k�u
=~��+�t���Ϟ��a^$�l�q�3��' �>S��i�g�Ҿ��G˔2o�!����y?F��w�ĉ� 4������X�I�c\iWf?u�s�n&�H���~BJPc��Z�-)d~���Ldf�ɯ�댍�3p��1����t�M58"��f�[-��zd�����}�!L�yL�rYΘ���;���;�j]�C��0�T!�:�h��������%��+������Xq-G�/IZn-!�`-|a� G��{��³�,��??������1c�D� ~��B��9�5�n��h�X�@;���C~껲u&Os���`vm����\����T���.)4���Of:��3��YP��H;�p�ܬ�v��ڂxOf��|2�)w ?7/P[
hF��>28��,�Q�)��e.9
䫞�S��@K|��[kW�9t�YϜ�5�a�d�$�7˷_���:���j%��/��s�{� ��-]�l��m<�l��s����D]4��0_9��i焫�H}��Mi�!�'d;�
C��8�9��[����u".��K�_��=���/�A�#�p���ˋm`g{iW|���j������/�t����K.���˵��Ԏ��9�o�1���C�~�G,���ٍ�~����9�W'�rϤ�����m����.@����
t�I�};D	�9���z����Y�~��BNU}p��*�S
J�1V�I�����?IGG�^ŠJx�Ȁn\����$^vn����F䶸��tS޸{G��a*��V�7^L�����ES�	�G_�x��E��o�oq��9��#�ge|���ۯ0��A'i�����>&D���h} �����GT\�]��Jt��]-��i7y�\�����e��ۗY��b�NZ���?H0���S�Y
�����Ӕ�\$�H�1il�lB�t|���xm�@{����Mt�7౐Q�#|{o���l������+����Z��M֒ Qpw����W�።�S�����M���NU��tF]4v8���]��+=l�@�t+�N-��ߴ�u2���ar_A�{�s"�s9tl��'�U����m2��sw�S$��<�&��aJWY���N�;+�*�+�9d�����
޵@��{&
RD[xM{���"s� �p�yB��#������C5U�
#��
o��qi�����6w�������+	|�:��ς�v��6cyٜ����Sx�)9Wʃ��q�q�1��83�O\b���]�1��:�����}�G��V�� \���bq��s��<>X_G6���2�i�_��,R��.�y���u>œ	+)1c!���q�T���Rq�XSd�9��h������\��3©�02c��k��5����WS�=v��l�٦�;;�o1<�*wr��h/�x�i4Ɍ�#��`�I�F��2��]��T�IE��z���b8��K
�$��a�^��;��]�|T/~x�K!3��*y���vC%Q�l�����C�_]���4�B����-뇬�K�kkL��˒����hR�rM-���e%q5|E>�	2��Iym0�v�Qq_���b�m-���~�<|�+h-��O�I�����ߋ��1������R���V�;O��Oo)� �7A����N7�Q��n�WF�kP0���tU�<�� @>kF�-1x�*Iw�M��ߋ�����yM�C����tJ���7Q�L!WR��!��u��Lr��J6+^��!\�%��P�^Aً|�B7��,��Z�n�G���
,9����]��7a���J��7����#†K�S��I��ȧ��� ܹ����C�;*.g��;�Hju��?B�,�T�Io:k~5:�+��.3箟�a�2�AEM��筃��L{���fOa*�&�䦶��407	�����X� �A�Y��Z�K[��+�:�6�A��ms�ce�?��w��DJٵ9v��<�}���,a���w�ND���~7�\̫9�T��[����%屒����'5�p���h�����
7��1f�I�8��)P"~���o�w��!��Y7z=Fˬn�z�9��$�λUÊ��-���
oXm��b���}��Oò;��3Iw�7Ɍ���h�;�\��ɊK��9��H�߆I��Ҡ��v�o���}��q2ze��opB�~VL���L�`�"D���Ze'�����Mp�xy�`�l'.ʤ��Z樫�Al�MJG�35S~��2��>��[�R�c��޲XJmxC���ųI��5�a�R��JTU�2�'��?GHk3��
dd�=rS��f9'��)����i
&�)��.RHK��KikcI�'�S�}'�d���:`�ma�@�(>\6q�� ��N=E�G�eM:c7�[1��p�d����Uߴ���M���>#��5Ҥ;69�C��<������W��iWb?��v�z�TX�R\:��+Z�+�\�}+���j�G�{�S��5�'C�`q�x�6I�d�g��-�9'8?Yƞ�ͮ�yG�N��S-]�����;p-p�6Gtd!Q�U�!�����գ��M@��H0X����Y|�ф��Mf�p�s�!�mբ>�c7��+�y&���w<�sֱ��G#��
`��쥐���S4c��F$�Y�����ض����+(�\%��������_T�
	���7����T�b��ɩz�Q�	�KU�����[qU�Z�x��h�Ra�ۿ(������n�'@�GL���S��j�]඿���s6��q�6�͹�wg?��\�4��z��`Ᶎ����K{,A�/5�^U�-���S+
@W�yi&MkR��0��y����K5&�]�\����TxT�LE+A��|�?���Feʚި��sjٵ<U
G�\��0��Y�~��6c����#� �uau�z����ϩv��k9�e��a��A��I
���F*q
ɮxʔ:+�.x֊����	�������*�C@XtTw}!<�mU�Wkȧ���F���2�����E��'��ߙ���01��$�G ��8�i��Y'����!1�9��>U@f���h�d��P�#v���; R�
M���A���b��R��P����Άo*e?���lj<G�,� ��GS�[����c�'t����!s���Q����ӻc��;J�N#s���eZ��؄�F����M�b�O��O�az��B�7JWp��9L�Ygƛ���ʕ����t�������~����_M;��3�d7��4�t�+Nr�qJ;�~^�+g�I�o5���>)�yʠ5�^0Y���Y�U]�
!�[?FS�,A�MnZ��%i�3a��8�ѷ�P\:��s����kN��߽���b�?�"p�%�̢�~�쀖�p�p���7�M�	���^�c��<7Q�N4���ު=⬈�8"�|�o���E���0�K��MUGLЌµ��aՋ5��o�Jk�"R�����`e�>��������j	��[w�a��Dg�Z�o��!4�j�K�.�f�Np
vs"��V'H���k=��=V8�ާئ �Z9g�6�V�˓$;}��$;�I������b�����dm��>��n��0���j(0pv-��R����qt��i5(���8���,+�L�@ɵ�?�Rd��	h�Q`=�S�O|,�^M�'z���L��^�*���E�k���>=x��[l0wc�ܬHC��bp'Ķw������u�L)��iB�B�_&;�t��F	*2�O�i���ëH�n���t4D�yR]4�@��6<��X8�Y��]98��ܻ]��i��t}�;�/V7�w��j4_�tE�m�L,$[F�F�(ʦE�7�BL��	$���Rc���,���>SG�h�6�˥����*~��d�/JJ3�>�l2����g�%���k'&���	7����`t��
7[heO�~�(q/*�U��*��H��y�zntxrc%�g�Ď�-N\4��Bo����{�Ր�a��>׺m#��AS���-�'������]v	z�,�Y|Np7�$Mn�r@q���`�I�k.9X?���B8�lK���Y�lg��B���/<����ή��OJ
ߜ_���6_�ֶs���D���c7 7��!܄	A�� �o�#5�&�h�b&�T�Q�G�3`1Cɰ�N��٧Ѫ���$���٫"D�����1� �0�e�<�EuL�C�y��������b�K�C^� �/o��b��{����ﻼ�ѐ�K2 �_[\,�-����'���М��b�MLS̩�C%�r�w�����u��7BrO�%�*�/��Hg$X����4�9�,�y�cu��ʐ��R�R�C�\)I�R��[/I�R��[��������������������������������������;I<�>�>�?F�]��x4F�Y�c�
hFr�2-?<a<q<�<�<�=�>�>j?iA�A�B�C6D�DE�EFI�IK#KpK�K�K,LzL�LAM�MN�R!S]S7T�U7W
XgX~X�X�X4Y�Y�YZ7Z^Z�Z�Z/[F[^[�[\^\�	\3_L_f_�_`B
`�a$
b�b;	cd�f�j#m�oix�x/6y���(�A(��?�������>"�I!���������������F����
��[�����&��	���
�A�
����#�?�]���������%�l	�l��	���D	�]
�"�m�������r�����B�����2�w��
��W����i����b������i����l����`�����
�D�� ��%�� �t�Y�f�����'��������5����~�����������:���,�G�X�i�������)�����^�{�(�E����[�v�����}��4�����O��'�P�������-������L���O�����E�i�����%�a�������<��l<�	�	�	�Y��E�&='�*�.3�3�3�34�6�67i7�75V8UE�E�E�E"FIIKIzI�I�I�I�IJJ�J@K\K�K�KL-L�L�LM\M�M�M8NSNtN�N�NKO�O)P�P�P�PQNQjQ�Q�Q�Q�QRhR�RSkS�S,T�T�TZU�U�UOV�V�VJW�WX4X�X�XeYvY�ZQ[�[\�\B]d]�]�]�]?^[^�^�^_�_�_�`ha�a,b�b(c�c1d�d�d�deDe�e�e�f*g�g�g5h�h�iQjlj�j�jkOk�k�lm�m�m nouo�oCp-qmq2r�r
s�s�s't�t�tAuvZv�v]wtw�wtx�x�x�x�x>y^y�y�y[z{z�z{!{�{�{�{�{ |@|�|}5}O}o}�}�}m~�~�~�~��"�=���o��������z���F�������"�����H�����#�	;G<i<�>�>r?5I�R��B�W���t*FmY}Y$[�c�h:r���<�C�D7IK�K�R+XZ�Z�Z _�_�_-`�a������(���=���`�����
�������O�������o����9�����D�����X������	�	��������������&�S�d�u�����j�4���R���$���u����Q����	�	<3�3	7u7E�E?I�I�ILK�KL�L�L�M`N�P�
QX*[]K^�^b_�a�bod�d2egeh<j�j�j'kPqw�w�x�x�xOy�ylz�z{�{�{1|}`}�}�~�~�������������




%%

%(
;E<g<�<
=�=�>�>p?~ABC#DzD%E�H�I�J8K�K�KAL�L�LVM�MkRSKS
T�U�V�WkX�X�X�XIY�Y�Y#Z;Z�Z3[J[s[�[\s\�^7_P_�a�bc�c
f	j�l�n�v�{�ݏ��L�����f�������\��q��������`�ѵɶ(�D�ɷv���?�C�e��������(�/�������H���m����x���� �����-�^����u�1���$�2�����~�'�K�������@��0���	�t�#�����4�_���D���I���U��+�V�������B���#�a���d�����~�����:�v���Q�
r�	�	�
>&X*D.m23b3�3�36.7�7;E\E�E�EF(F	I IOI~I�IJ_JKqK�KBLMbM�M�M<NxN�N�N`O>P�P�P�PQRQnQ�Q�Q�Q*R}R�R�S�S�ToU�UVeV�VWJX�XYkY{Y�Zf[�[0\�\F]h]�]�]�]p^�^�_�_�`�a�b=c�c7d�d�d�e�e�f�gJh�hjUjpjdk�k�l,m5n�oXp�q8r�rs�sxt&uVu�v(w_w�wzx�xyry�y�z5{�{�{|T|�|}9}�}�}s~�~�~�
�&�πu���ʁ(���L�����7�ۄ���:��-2<8<;<]<m<�<�<�<�=�=�=�>�>�>�>9?>?B?F?J?N?R?X?_?f?�@�@AA
AAAA"A&A-A2A6A:A>ADAJAPAUAYA]AdA�A�A�B�B�B�B�C�C�C�C2D�D�D�DE�EBI�I�JKlK�K�K(LuL�L�L/M<M�M�M�M
N�RSXS2T�U�U-W3WXVXcXzX�X�X)Y/Y�Y�Y�YZZ3ZLZZZ�Z�Z�Z[+[B[Y[�[�[�[T\Z\�\"_/_H_a_�_�_�_`0`=`�abb�b6cd�f�f�j�jmm�o�o�oSxWxdx�x(yi�m�z�Ɂ�&�-�:�ˑϑܑ�ИԘ�����ÞǞ4�8�C���ͩک��Ϊ۪��ϫܫ��4�A�{���ǭ�I�V���ϯܯ �l�s���ȱ���;���������:�W��������Ѹ޸�f�f�������;�?�W��[�h����������l�������<�{����� �-�q������E�R������c������P�]����������c������Y�f������[�������������?�����|�n�S�a������"���������������"�/������x�����������������6���������������(�C�T�e�������$�����Z�v�$�@�����W�r�����x��0�����K�����������	��#�>�L�{������(�����
�G�����=�J�������4�9�=�A�d����� �\�������7��h����	�	�	x�������&�&9'�*{.�233K3�3�3�3
4�6�67e7�7/8QE�E�E�E�EFIHQHVH]HcHjHoHvH|H�H�H�H�H�H�H�H�H�H�H�H�H�H�H�H�H�H�H�H�H�H�H�HIIFIhIvI�I�I�I�IEJ�J<KXK�K�K�KL(L�L�L�LXM�M�M3NONpN�N�NFO�O$P�P�P�P�PJQfQ�Q�Q�Q�QRcR�RSfS�S(T�T�TUU�U�UIV�V�VEW�W�W.X�X�XaYsY�Z�Z�Z�Z�Z�Z�Z�Z�Z�Z�Z@[M[�[\�\]$]1]>]`]�]�]�];^W^�^�^
_l_y_�_�_�`�`_aca�a�a�a'b�b�b�b�b#c�cd!d'd-dvd�d�d�d�de3e@ete�e�e~f�fg&g�g�g$h1h�h�i�i�i�i�i�i�i�i�i�i�i�i�i@jMjhj�j�j�j�jk=kJk�k�lm~m�mnooqo�o=pq)q\qiq�q�q�q�q�q�q�q�q�q�qr
rrrrr&r.r�r�r�r�r�r�r�rs�s�s#t�t�t<u�u�uvVv�v�v�v�v�vwLwYwqw�w�wpx�x�x�x�x;y[y�y�yXzxz�z�z{�{�{�{�{|=|�|}1}L}l}�}�}i~�~�~�~{����:�������k�����܁��w���B�������҃��Є��B���̅���������������†ɆІ׆ކ����������%�-�5�=�E�M�U�]�c�k�s�y���������������������ÇɇχՇۇ������������#�+�1�9�A�G�O�W�]�e�m�s�{�������������������ˆɈψֈ܈�����������"�(�.�4�:�A�G�M�S�Y�_�e�k�r�y����������������������Ɖ͉Ӊډ��������������$�*�0�6�<�B�J�P�V�\�c�i�p�v�|���������������������ŠɊЊ֊݊������������#�)�/�5�;�A�G�M�S�Y�_�e�k�q�w�}���������������������5<A<c<�<�<�<�=�=�=�>�>�>�>@?D?H?L?P?V?\?c?l?�@�@A
AAAA)A/A8A<ABAHANAWA[AbAiAB�B�B�BC�C�C�CDvD�DEE�H�I�J#KpK�K,LzL�L�L1MAM�M�M�MgR
SGS�S�U�U�V1W�WXXgX~X�X�X-Y4Y�Y�Y�YZZ7Z�Z�Z [/[F[^[�[�[\X\^\�^$_3_L_�_�_2`xab�b�b�c�e�f�i�jvlm�n�o�o�vUxYx�k�o�e�+�/�Ǐ͑ёޑ�Ҙ֘�6����Şx�6��P�ϩ�Ъ�ѫ��6�F���ԮK�[�ѯ�q�u����������J���Ķ�#�?�����`�Ӹ�)�-���O���=�	���]�m���	��������}���"�2�����G�W��������R�b��������������[����������H������_������p�p��h������� �$�5����������������<������������,�����_��{���0�[���/���4���Q�����������'�R������-����L�����?�O�������;�?�i�����%�a�����<��n���	�	�	�
z����)&�&C*/.X2�233O3�3�3�57�7%EWE�E�E�E$FNHYH`HgHrHyH�H�H�H�H�H�H�H�H�H�H�H�H�H�H�H�H�H�HIIKIzI�I�IJJ�J\K�K-LM^M�M�M8NtN�N�NKO)P�P�P�PQNQjQ�Q�Q�QRhR�RkS�S�TZU�U�UOV�V�V4X�X�XgYxY�Z�Z�Z�Z�Z�Z�Z�Z�ZB[Q[�[\�\"]&]3]B]d]�]�]�][^�^n_{_�_�_�`�`aa�a�a�a�b�b�b�b(c�cd%d+d3dxd�d�d�d5eve�e�e�f�fg�g&h5h�h�i�i�i�i�i�i�i�i�i�i�iBjQjlj�j�j?kOk�k�lm no�oCpq^qmq�q�q�q�q�q�q�qrrr"r*r4r�r�r�r�r�r�r
s�sctuAu�u�u�v�v�v�vwNw]w�w�wvx�x�x^y�y�z!{�{�{�{@|�|}5}o}�}o~�~�~����"�������q��������H��������"�ׄ����#���������������Ɔ͆Ԇۆ������������"�*�2�:�B�J�R�Z�`�h�p�v�~���������������������Ƈ̇҇؇������������� �(�.�6�>�D�L�T�Z�b�j�p�x���������������������ƈ̈ӈو߈������������%�+�1�7�>�D�J�P�V�\�b�h�o�v�|���������������������ÉʉЉ׉݉��������	����!�'�-�3�9�?�G�M�S�Y�`�f�m�s�y����������������������Ɗ͊ӊڊ������������ �&�,�2�8�>�D�J�P�V�\�b�h�n�t�z�����������������������B�H�I�Jޏ���<�<�<O=�=�=0>�>�>�AMB�B�BHC�C�C,D�D�D�DE�EI�I�J
K]K�K�KLfL�L�LM9MwM�M�MN~RSTST�UW�WX`XtX�X�XYoY�Y�YZ-ZEZUZsZ�Z�Z�Z([<[S[�[�[<\�\�^,_A_Z_{_�_�_`!`:`�a�ab�b'cd�f�j�lm�o�oxax�x y�w����`�7�U�ّ�t�ޘ�ɛ���0�{���שs���تt���٫��>�n���ĭ��0�S�����ٯ�J�}�����(����v����3�O�t���ݷ����۸�S�W�����z�"�G��9�e�����	������W�������'�Y������*�\�������#�O�������N�������.�Z��������+�������B�c�������B����������,�����a�S�:�H�������������`�������,�������W�����j�����}�����$��;�O�`�q����������I�f��0�����;�j�~���i�� �o���2��4�G�^������������6������G�������M������N�������%z�=�	�	�	��Q����&�&1'~*j.�2�23"3x3�3�3�3�6�67T7q78LEeE�E�E�EFI(I[IqI�I�I�I�I4J�J#KHK�K�K�K�KL�L�L�L>MjM�M�MGN[N�N�N%O�O�OwP�P�P�PQ^QzQ�Q�Q�Q	RQR�R	S^S�S	TnT�TAU�U�U7V�V�V5W�W�WX|X�XEY�ZJ[�[�[j\�\.];]R]t]�]�]	^G^�^�^�^4_v_�_�_T`@a�a�a�ab^b�b�b�b�cOd�d�d�d�d�de=e[e~e�e%f�f�f#glg�gh.hqhjJjaj|j�j�j�j�jkGkwkhl�lgm�mn�noUo�o&p�p&qDqfq�qs(s�st�t�t5u�u�uvNv�v�v=wVwjw�w�wUx�x�x�x�x*yKy�y�y@zhz�z�z{l{�{�{�{|-|�|�|*}E}\}�}�}Q~{~�~�~c����2�g�����M�}���Ձ��_���*�d�����ʃ������8������C�s<�<�<)=�=�=
>�>�>�A"B�B�BC�C�C$D{D�D�DE�E�H�I�JKQK�K�K
LZL�L�LM3MdM�M�MNlRSLST�UW�WXZXlX�X�X�X\Y�Y�YZ%Z=ZOZ`Z�Z�Z�Z"[4[K[�[�[)\~\�^&_9_R_h_�_�_�_`4`�a�ab�bcdwftj�lmgo�o�w[xzx�x��q���߁6�1�)�ӑ��H�ؘ�������'�r���ѩe���Ҫf���ӫҬ��8�e��������M�|���ӯ�(�w���б������m�޵˶�*�F�_���Է����ո�J�N�n���q��9���$�_�����������I�t������D������$�S�y������I�������@�k������T��������"�k�����!�]�n�����9�b���y���	�#�����S�E�1�?�������������R�������&�x�����I�����\�����o������	�2�I�Z�k����������<�`���*�����5�a�x���\����b���%��.�A�X��������������0�n����A�r�����G������E�������m�0�	�	�	�
|�&����&�&'q*].�2�233o3�3�3�3v6�6�6G7k7	8FE_E�E�E�EFI"IRIkI�I�I�I�I'J�JKBKyK�K�K�KL�L�L�L1MdM�M�M>NUN{N�NO�O�OjP�P�P�P
QUQqQ�Q�Q�QRDR�R�R-S�S�S=T�TU�U�U)VV�V'W[W�WXnX�X7Y�ZD[�[�[]\�\(]5]I]k]�]�]^A^x^�^�^_p_}_�_G`3aja�a�ab.b�b�b�b�c:dzd�d�d�d�d	e7eFexe�e	f�f�fg;g�g�g(hdhjDjXjsj�j�j�j�jkAknk[l�lZm�m�mgno$o�op�p q/q`q�q�r"s�s�st�t/ueu�u�uvkv�v4wPwaw{w�wGx|x�x�x�xyEyzy�y2zbz�z�z{^{�{�{�{
|'|�|�|!}<}V}�}�}C~u~�~�~U���
�)�D�����?�w���́���Q����O�������ރ���ބ� �Y����=��<�<�=x>�AoB�C0D�D�D�E�I�JKaK�K�KLjL�L&M�M�MS"T�UW�W)XxX�X�XYsY�Y�Y1ZIZWZ}Z�Z�Z@[W[�[�[@\�\
_E_^_�_�_+`�a�a�b,cd�f�j�l�ox�x%y3�Ɓ������Λ���5�����x���y����&�s����;������^����-�{����8�T������Ÿ�X�\����'�L��M���������\�����,�m����a�����7�����S����B������0����V�����G�������1�����f�X�?�M����������e���
�����\���o�������)��@�Q�b�s����������N�h��2�����=�o�����n��"�t���7�!�6�I�`�����	�������8���4�����O������S�������*�B�	�	�	^v��&6'�*o.�2$33�3�3�3�6�67Y7s78NEgE�E�E�EFI*I`IsI�I�I�I�I9J�J(KJK�K�K�KLL�L�L�LCMlM�M�MLN]N�N�N*O�O�O|P�P�P�PQcQQ�Q�Q�QRVR�RScS�STsT�TFU�U�U<V�V�V:W�W�W
X�X�XJY�[\o\�\W]y]�]�]^I^�^�^�^`_�_Y`Ea�ab�b�b�cYd�d�d�d0eee�ecf�fqg�ghvh%jfj�j�j�j%k|kml�llm�mn�nZo�o+p�pNq�qs*s�s t�t�t7u�uSv�v�vDwow�wZx�x�x�x�x/yMy�y�yEzjz�z�z{q{�{�{�{|/|�|�|/}J}^}�}�}V~}~�~�~h���7���R����ځ��d���/�n���σ�����=������E��<=�=�AC&E�I�J9K�K�KBL�L�LXM�MT�U�V�W�X�XJY�Y�Y�Zt[�[\t\�^�a�bc�cf
j�l�n�v�|����M�����g�������]���r������a�������w���@�D�f��� �����)�0�����I���n����y�������.�_����v�2���%�3������(�L������	���
�u�$�����5���E���J���X�C�&�c���g���������<�x���S��	�
	?&Y*E.n23e3�36/7�7<E_E�E"I�IJaJKrK�KCLMdM�N�NbO@P�P,RR�R�S�S�TqU�UVgV�VWLX�XYh[�[2\�\q^�^�_�_�`�a>c9d�e�e�f�gKhjfk�k�l/m8n�oZp�q�r�syt'uYu�v*w�w|xysy�y�z6{�{|U|�|�}�}u~�~���w���)���N�8�
��<=�=�A)E�I�J9K�K�KBL�L�LYM�MT�U�V�W�X�XLY�Y�Zu[�[\u\�a�bc�cfj�l�n�v����N�����h�������^��s������c�Ե˷x���A�E�g���!�����*�1�����J���o����z�����0�a����x�4���'�5�������*�N��������
�u�$�������E���J���C�&�d���h���������<�x���S��
@&Y*E.p2>3e3�36/7�7<E�E�E�IJaJKrK�KCLM�N�NbO@P,RR�R�S�S�TqU�UVgV�VWLX�XYj[�[4\q^�^�_�_�`�aAc�e�e�f�gLhgk�k�l0m:n�o\p�q�r�syt'u[uw+w�wysy�y�z6{|U|�}�}�~Ҁ)���9�
��<�<�=mAE�I�J'KtK�K0L~L�LEM�M�S�U�V�W�X�X8Y�Y�Zb[�[\b\|a�bc�c�e�izl�n�vix�x��΁j�̏�;��}��U�����K�ٮ`�����O�����e��.�2�T������r�������7���\����g������M����d� ����!�u�u�m��:�����������c�������3���8���1��P���S���m�����)�e���@���
��-&�&G*3.\2Q3�3�5�67�7*E�E�E�I�INJ�J`K�K1LM�N�NOO�O-PRlR�RSoS�S,T�T�T^U�U�UTV�V�VJW�W9X�X�XU[�[\_^�^�_�_�`�a,c�e�e�f*g�g9hSk�k�lm�m�m$nouo�oGpqq�rs�s�sgt�tuEuvZvw�w�xay�y�z${�{C|r}�}�~�������&���H���҅)�#S#�#�#�#5$s$}$�$�$�$�$�$[%h%�%�%&&&&)&3&@&M&Z&g&t&�&�&�&�&�&�&'''%'/'9'm'w'�'�'�'�'�'�'�'�()R)\)�)�)�)�)=*G*�+�+�+,N,Y,�,�,�,�"5(i(s(}(�(�(�(�(�(�)3*�*�*A+n+{+c,�<�=�=�>�>�B�B�C�C�D
E�L;M�M	NbXZ�Z*[._�_`<`bm�ocxy�9�ۑ����٩ڪ۫@�ƭU�ۯ�
�����ݸ��g�������,���Q�����\�����e������!�
���.�����������I��������&33L[0]=]x_�_�a�a�b�b�de?e�e�f%g0hLj�j�jIko(qhq�uvXw�w���������O24�4�7=8�8)9�9�:y?�@�A�BrD4FUG�J�L�OzR7U�UsVuW�XZ�Z�[A]�aVb�c�fSgh�m�pcs�tDv�w�xmz�}��S�E����$���i�����9�������������������ÖG�ЗT�ؘ8���A�!���������:�e��������E�ƨ��p���������I�޾���_���l�Y���������f��+?�s�,��A�{�h�X�E�C�<�(�@�a	?�C��x#
$�$%�%�(|)�*�/�y����_��������V���� "z1�AGyJX��K����+e,��?���.����3+�� �3�4�7;8�8'9�9�:�>�@�A�BpD2FGwJ�L�OxR5U�UqVsWX	Z�Z�[?]�aHb�c�fMgyh�m�pas�tBv�w�xkz�}��Q�C����"���g������7����������������������E�ΗR�֘6���?����������8���������C�Ĩ��n����������ܾ��]��j�W���������a�=��+q���d,?�y�f�V���A�:����������$�$%�%/(p)�*2+x1w����]���~�����,�T���&�=� v#N2�3�4�7<8�8(9�9�:�>�@�A�A�BqD3FGTGxJ�J�L�OyR6U�UrVtW�X
Z�Z�[@]�aUb�c�fRg~h�m�pbs�tCv�w�xlz�}��R�D����#���h������8�������������������–F�ϗS�ט7���@� ���������9���������D�Ũ��o�����������J���H�ݾ��^��k�X����
�����e�>�,r����,>��������@�z�g�W���B�;�����`	�B���	$�$%�%0({)�*+y1x���
�^��������-�U�
���'�> � "w#�<d}3�E�eBw�AMG�JC���A�6�����}��� �!�AQG�JG���E�:��������� �!�<�=�>�A�E�I�JeK�K!LnL�L)M�M�M*T�U%W�W�X"Y�Y�Y�Z�[�[M\�\�a�b/cd�f�j�l�o*x?������������=���������{�������5����������`�_���/�O������d�4���i�����[�	�����T���?�����t�f�M�[�������s���i�|���6���$���S������q�
�y�<���;���7����������V�����/��Ejy�&�*t.�24�6^7 8QE�I>J�J-K�KL�LHM�N/O�O�P[R�RS�ST�T�U�UAV�V�V=W�X�XOY�[\{\�^�^�_d`Pa b�c�eof
g�g~h�kul�lom�n.pq�qs�s�t<u�ubx4y�yJz�zv{|�|�}[~m]�i�4�����T��	H3CIsd���Fes����I�Rɳ[;?<a<q<�>�>j?C�D�HK�KeR
X�Y^Z�Z�^f_�_`�a�������������&�α�¶]���l�"�����r�B���w����i����i��l�`�������������~�����:��G�X�i�����^�(���.�v����O�P������E���l�	�	3�3�6i7UE�E"FI�I�I@K�KL�L�L\MSN�P�QXeYvY�Z�\?^�^_ha,b�c1d�deDe�g�h�i�j�jk-q2r�vywtx�x�xCy�y`z�z{�{�{%|�|T}�}m~�~�B�o�������F�܃�CZ_����K�n��	23uE8I{M�P]gd4j�v�x�{}�~���|��C�Y_�����?�b��	&3iE,IoM�P][d(j�v�x�{�|~���p�&)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"|"�"�"�"�"�"�"�"�"�"�"�CZ_���!�M�p��	43wE:I}M�P]jd7j�v�x�{
}�~�����<�<�<�D9I:IKK�K�K�R�R�R�R�R�R1X5X9X=XAXEX�Z�Z�Z[[	[
[.`bbbbbbbbb	b
bbb
bbbbéĪū*���?�ůb����������͸θϸ��������Q���������q����;�����F���������������������������������������w�������l�6�������&����������]�^�_�`�a�b����������	�	�	�	�	�	�3�	7w7�I�I�I�INK�KL�LjNkNlNmNnN�Q�Q�Q�Q�Q�Q�Q�Q�Q�Q�Q�Q�QXXX0[1[2[M^�^h_i_j_�a�b�boepeqereh5k6k7k8k9k:k;kRq�w�xQy�ynz{�{3|b}�}�~�������y���#�(�~ �YZK�uI�K�<�D;IK�K�RIX�Z[�_�_/`bȩɪʫ/���D�ʯg������и��V������v����@�����K���X���������������������S�d�|�����q�;�����+���#���c����	�37|7�E�I�ISK�K#L�L�LoN�Q!X3[R^�^k_�a�b�d2eseh�j�j<kWq�w�x�xVy�ysz�z{�{8|g}�}�~�������������������������������������U����2��������lw"+�T����U����U��V����V��U��V��U�U�f�P�g�P��T55�
9�
:�
Qa2U��
��������^s���o*}��b�b��T������������������;t����T��	����Ε���T��U�����b�������KE	�$?ę�����U�b�������KE	�$?ę�U�������^s���o*}�U���U����������������������������L�VN�VN�N�U��U������U��U��J�VJ�U��V������������������V����������V�������������������V����V�������V��Ϛ������V����V������V����V��U����V����U����V��U��V����U����VH�VH�H�U���������������Ę�֞����֞������b������uu�w�x�ִ'
ǯ�����R��
�P���P�`�P��Q�Q�\�P�g�g�-�h��g�h
end_or_len��g�h��gFPR<?���P��O�����I������lf���]v��K�����I������lf���]v�U�K��O����T�������S�����P��T��	��	�5�5Weak��5��4�5��4>(,A*�����K��	̡������I������lf���]v֞�K����I������lf���]v���K�֞����ä�����O�S�T�U��T�O�֞�������ä�S�����-�-�5�-��*��]����T�5�5ArcInner��5strong��4�5��4�5��4�-���
�������	��U�+�t�+���+�t�+���+���+�t�E�t�Y�t�Z�t�&�P��������B�JT���t�t@�&�P���t@�g�P�Pו�P�T�W�t�t�����������W�������T�Õ�W�t�t����V��Ϛ���W�t�t����V��Ϛ���W�Q�Q�W����W���t����V������W����b��T��b�W���t����������W���t����V�����b�Ub�]�]�U^�V^�^�U�5��6��K�6��K����U��U���H��H���-��#���.���.���.�����"0k��|��U�U�H�����������,M�[�}�t�6��K�7��K�֞�K���K����K��U�K�7����6��K����U����T��U�U�E�t���P��Oۊ�P��R�ӟ;ZI1F?"33%B(fT+D:=0$'*UF-XH<#&75)E,�V�V�	<�$��jcore_intrinsics���խ��ǣH��*��E����}����fmt_helpers_for_derive��_�_խ��ǣH��3�j�����9��
Zpanic_internals�usխ��ǣH�OF7�S�-.$crate::thread::local_impl::thread_local_inner�D�Q�uQb��athread_local_internals����
�f�fխ��ǣH���'렸���V
fmt_internals�const_fmt_arguments_new�խ��ǣH�T^�,��K���$���Z��խ��ǣH���m���$crate::const_format_args���"]���Zϵߵ��խ��ǣH�$���-$crate::assert��7�TZ���Z�����generic_assert_internals���խ��ǣH��5G��$crate::panic::panic_2021�!��TZ��]����S�Rխ��ǣH�ر�W$��@t�}�J���derive_clone_copy���խ��ǣH��>��KV�<����dz�_�_խ��ǣH�Ngok3��������խ��ǣH�pu2��H��e�f\��	derive_eq�����խ��ǣH�RN��nr����Vϵߵխ��ǣH�B���WxH���<n��usխ��ǣH�v�����������dz�_�_խ��ǣH�����B��������խ��ǣH�|w������������խ��ǣH�M�r�z}6$crate::thread::local_impl::thread_local_process_attrs�C�P�e�b��/$b����խ��ǣH��uA�Q�	�$crate::format_args���Z��Zϵ��խ��ǣH��1�����¶0�1�"]�ϵߵ��խ��ǣH��9d���r�����TZ����S�Rխ��ǣH�)���\�n�̃G��խ��ǣH�7\��>�e~$�u��������խ��ǣH�X��6R�B�S���dz�_�_խ��ǣH����C�'�����D��dz�_�_խ��ǣH��ڔ���z���z��dz�_�_խ��ǣH�*�n��\�<������խ��ǣH���/�E����ܽ���խ��ǣH�@��	#���V�V�խ��ǣH��X��W���	��6��dz�_�_խ��ǣH��ZJ�`-l�ptr::addr_of_mut���@������խ��ǣH���sm^��������dz�_�_խ��ǣH��0ь������/�/�TZ~����S�Rխ��ǣH��X�ȍ
N���5���խ��ǣH�ݻ�6��k���3�TZV�����ķ��խ��ǣH�LX�g{������Vϵߵխ��ǣH��jR0�j�<�Vϵխ��ǣH�?�Y~o(a�¶"��"]6ϵߵ��խ��ǣH��X���iB�<�[	����խ��ǣH�k�)+�c�������O\�����խ��ǣH�Iph�T�����!��խ��ǣH�\���������d�����խ��ǣH��Iǿ�T����F�TZ������ķ��խ��ǣH��ZV�X�21!C-/ #����TZ`�����ķ��խ��ǣH��T: ��debug_assert���B#��SZ�ysխ��ǣH��VV��}���
�-�TZ������ķ��խ��ǣH���$D�՚����� t�ysխ��ǣH�&y�'�g�����O��Gb�����խ��ǣH��j�چ������Ռ ��ysխ��ǣH�4`��p[7����TZ�	�����ķ��խ��ǣH��d`_x�<
����8]�ysխ��ǣH��sl7�R�2�����߃b����խ��ǣH�^q8hԐ���݄I��ysխ��ǣH���e��S�����vE��ysխ��ǣH��_�L!s��cYY�X@YY�e�c�X(Y�e�c�X,YY�X0YY�X8YY�XDYY�e�c�X�X�c�X�c4Y�X�X$Y�X�X�c�X�X�e�c�X<Y�cY�c Y�c�X�c�XHY�`�]�Ya�ef�aV_[Cf�d'e�\0c�`k]Ad�]�e[a�^Xe_?[d�[�b�_M\�b�_�\]c^`�]lY�`d�a�^�a�[�_�\�b(`�c�Y�d+^=Zdb�Z7b>]\Y�`�]-ZKa�e3f�as_/[df�dHe�\Mc�`�]od^f�a�^�eF_�[1d=\�b�_�\�b`.]�c�`�]�Y
a�d�a_'b�[�_�\ cN`�c�Ye�^�Z}b�ZTb[]��ODHT ���i�(�ج�y�8�����h�������
x���j(0pvV��+	|!��S+
@W��݂o�Y:S�;;�o1;�9�,�y�#� ���s�!�m��Oa*�&��z�V'H��M�M�D(�i�j/��:)�x��@��H0X��F��>28�һ�u2�����H5��r����7�����+�:�6��*�C@Xt1f�I�8��K�kkL���L���M���WF�kP0��\E[T����ˇV��y)<��X8�Ym-�Y���ҟ�Y�(���
�[h�/�T��[����>��[�R�U
G�\��0�ʠ5�^0Y�. �_[\,���02c��k7[#��d�i;�*�Yee��ƼIgh1���	i ���Wkȧ���l�٦:��ˋm`g{�x��[l0wcb���
oXm��R��r Q_7���u�خ�o�w���"���x�o�"�Dy�cgR����~�Z�a�t���Ϟ�����`t�u�����a~h�6w����� �\$�H�1����h����`��!��ٍ�~���qt��i5X�fÎ��O�2^>�H�Ã�쀖�p�p9�-̔�)��M���>��n��0�U-|a� G��w����W��Ygƛ���%@=#��������R���VW]�C��0���ާئ �ZOު=⬈�8>���ۯ0���h-��O�T�@ɵ�?[Ӑ����G9�U,��mR�t�6� t�l�q�3��a�ۿ(��Ȝ7|��IZ*H�\Ř/u��Cǐ�7x�Ȁn\���m����Z�x��h�R���"�A�^F�F�(ʦt�����@F�5'�d���:`��ma�@�(�1� �0�e����h�(Z��8,d���P�_d�8�5nT�(�rivD	�9�����:���j�[1��p���s6��q���oq��9���•����0��������������hR�M�ɊK��9�Z�a�ş\%�������ɩz�Q�	��Q�Q�������1c֬���.)4����|�?���K��A��t
���	��v�U6��wb+rW��S��X�М��b����O�az"�oW%!Qܲ}�A�#�p����-�'�����+(��3��*y��F#,iT��/IZn-!�`��O��4a"�T��9�5�n�q�x�6I��)� �7A�Y3Iw�7Ɍ–�>�c7��+����>)�y-9'8?Yƞ��r@q蕎K{,A�/�x��E��o�D��DK�S.��}�!L�yL���a3Nϖ0�v�Qq_�QW��iWb?����Y|��/qwZA@V��[qU����]98�n�ar_A�{2�i�_��/u�\a����O�ab�CY{�'�Gb��Z�}��Mi�!���n�j���A'i�����sjٵ<�zntxrc%��u&Os��ϱ���t�M5�e�x�uɓ�u��[w�a�H��=�y!!kh��_z!>����{�{�m�_$a{	�9,y�Xza�r�)P"~�����0��y��.ݾƆ�v�E��z���A������~�'∢ďQ�H9�}�ʐ�'X,�]�\������%屒���	2��IymP���ѐ�K2�BV�A�)^k �rYΘ��ء�xCܙ!K�Ͱ�Q����X�I���>�����q�q�1&����9�W�������;�wP�̯�o����SZ���&�[H\��]���Rd��	h\o���}��+�����"�|2�)w ��ͮ�yG��I�����ߋU&���	7~�����ES�Ut$��iŷQ�m#��AS��k�"R����E�K.���˵��JSK˩ �ʕ����t�&'��
�A�\�����n��	$���Rcv��`�I�k�į�����B�I���a�v��܊7�b�.SO�ܙЙ����S�Y
���sֱ��G#�-N\4��Bo�=����~+E�
��噏<*aJWY���\����T�������+e��/�it�d��I��9|ֹ��a,W�ۗY��b��P������$���٫"�K�S��I�o	z�,�Y|N�'��)���ɯE�k���>=an����F�Y�lg��B���b��80�d�����q2ze��A�MnZ��1�{&
RD[-��r�b4�F��:��`���"���^����
`�6�͹�wg���+Z���΃B���>�'��X��
sJ��=���Z#y�N-��ߴ
��]z��
Sjj �8�Q��h} ����"s� �p��4�B�J��*6$���c��; R�
C^� �/��R�)�RN(�n��*��O;]��+=l���1j���y!1��{7 7��!�Tw}!<�mU�o*e?���E��Ajh�p�5�'C�`�#e�
DB��� ��GS��A��I
���g��K��ޝb8��K
�B���L�`�/*�U��*�bfILV��ay�)9Wʃ�%�J6+^��!f�z��`Ᶎ����b�K��b^u�fr6�&8"��f�[-�}j��h*%d���h?�w>\6q�� �^���s�Wb�C�v���!�"y��uau�z����b��R��E�7�BL�u �����?((��;�R��p�
���B/�i�g�Ҿ���xʔ:+�Vo�蕲h�O`o��:��ga���J��m�����js�\'t�����v�z��w�ui�r@=I�Q�ʲ�IX3�@�t+�1��:��)(�\@�b��Oo�Z���2���s���2YFˬn�z�9�O��*��U�ű���Q�F5S~��2�ݥ��T�b�����Feʚި�4v8���
܄	A�� ����iB�B�f��bq�,�"���
���-5��Z"Ci��*�R����Z�cu��ʐ���c��޲X�����"�\�+������J�47���q��N4���=�ųI�۩
����
]ҶT!�:�h�`vm�������zi�6��Z�K[�~�h�dBՙD���c��<7Q<���J���w
{��'d;�
C�����G��%�?�veA�i�����<l#�b������X�|4��
��e.~5:�+��u�~�(q��쨋*c����^�*���`?��?-S6G,R��.�y�0;O��2�c!:��83�O'v��6cy�#��Of:��3��Oò;�ӕ��h�;�\��� @>kF�^�ܬHC��bc!�[?FS�,0��iJø��"�5�K��v�yi&MkR����Ns�x���_M;��('-\�P+6o�o�>�QC�xBJPc�����JTU�2��|��[kW�;�~^�+g+���aՋC��3\j��)W(��Pk�����/m�C���I�o5,�ڨp[�%���/�t����Np
vs"�LJmxC�֨���myI�����{�Ր���u4~��&�7�:���߭C����tbL�vj���t������504y�x�I�@��#�kG�!��k��f�i焫�H�rM-���eNrE䑊��+Nzb��h��XNQЋ���"��YP��H������j	G�{�S����쥐����5�]b������zd����/7�^�_i�V�搙�I�bKI���ϋ���E���iW|����cI�'�S�}��<9�S]��E���0@��1����V��筃��x?u�s�ɯ�댍�|{o���l�ȡ��ir?�s����c�{��³�,�܎l�Ń�w��u>œ	+1խ��ǣH�'�k��ȒN*)v���#�;BB�S�	�*.g��;�Hr��p��c���WS�=v9�b���}���s"�s97����#†n�����C�;qQ����ӻc���ëHiz����Y����:����������;p�%��+�����RHK��Kik�
4˜����K`'B�æ�i���K5&�\/{���$���Q�G�3`1�\�����e��;69�C�ɽ%��/��s��\b���](�@��6l��P�#v��߽���b6��h����5�V��j>%�̢�~8���i�coJ�G�����z5�I�3�� �ȧ��� �pML�4���҉7��pm�
��խ����
,9�kp7�$Mn��2E+�5�!�o�dn���T��p>s��5����8�a��>׈��GT\�����Al�]��Jt���~��d�/z�Dg�Z�IV�� \�+o��!4�jJ4Ɍ�#��`>���>&D��[�$O)$k�<�)xt+��e���~,��A2�m�L,$[sh��u/$5�,���1$�n~J׿�1T��9�o�1����6���6l���!��Y7z=��~�<|�+S>!��=��a�`e�>���FȺc_@�O�1�FFE<J�-p�6Gtd!��'@�GL���i/%I�P���;J�N7BrO�%��TX�R\:�።�S����_T�
	�4D�yR]4k����W\"A	�~7�\̫9����]��7l3��
dd�=��>U@f��>SG�h�6�x�;��i�{��A��ms��W�`�o��lu�!s���:��s�4_�ֶs��QO{�v,�����d�}��~�C�y������_&;�t��g�g�Ď���\��3�6��]��T�I@B�����-�$$X����4��tU�<�]9�e��a���$H�\NT
'.ʤ��Z��s��<>X-?��\�4����A�H�'��~���¼�!���������t��-˥����*y��գ��M������_G6���.��M��'�|����$^v��gLIJ�ͧ���%�˴=�UnX�4���'z���L�_�.@�����NU��tF]	ߜ_���6�ڻwH�t��GI�T>�<$unlj<G�,��G˔2o��(���D�g�MUGLЌ�B�	�����ÿ���Vo��6c���������@a;�p�ܬ�v�d�g��-����u��Lr�e�����4<�:䶸��tS��<���\}FX��D�<y��g�%���k'}D�����������t@�[w�y�D����Ӕ�Wp��9L$���\k�w�I�F��2?�2�AEMw+�\�}+� ����Lf.x֊����Y���&�^Z����M�b�O!Ā00
�kN�¬�-���VI�}�?A��dm��T�{G��a*�o�#5�&����E����?�"p�7yB��#������%��W>�-��'e�D2���(}XkSp�)��4%�4�-���T�K�.�f�K>��@/��	4�`+4������/�4�)F�Q�8M輆��e.9
䫽l��m<�l��.9X?����M���A�����C5U��w�ND���p�c�E��9��bF�X�'��WF�k���<�EuL��TxT�LE+A�#p�M}k��̈́\N��98S�oOe>�o~��BNU}p�?��Q�Wz,�Q�)�N��S-]�
=l�U-3f#J�1V�I����Y�U]�
/��h�X�@;�?7/P[
h��ܻ]��o�xy�`�l����b���S�hwf:�l�gsLf�&:��
7[heO�~�qi�/����kN�5��b�m-��R��Xq-G���F*q
��}ts�q�(j?t�z��H�N+u}�$U����u�L)e��*w��`�|���xm�@��sw�S$����yM�ai��t}�;p����u".�yA>�-g
�����]v�Rĺ��[��C,:>���[>#��5Ҥ�;�o�%O�������qi����!9�l���MV7����G�^ŠJ�(�סšcL�J$:�-�P*�/��Hg�(���8Y��]ŦlL�O�%��I��@���vR)U����m2��A�����-E��ϳ�����9Ӵ�Kp�]�=K�Eˢs#s���eZ�{������k=��=V8N����E��
�N���ź�/{����Mt�{� ��-]��8�9��[���6���u�%��DJٵ9v��"D���Ze����
޵@�ܱ_��E�͡|EO�-��=���/�%(����<�\�1��5tO�.>Q�͕NjUߴ����y&���w<���/��c}���A����Dce�?��w��3l����;���>~�۵�Q`=�S�]���#	]՝bq��ե��0��i�����Nu��h�b&�T��M֒ Qp)1c!���2Q�U�!������$�λ�Xj�%~�$��X��&6�t@tl��'�Z�-)d~�/U+�����,+�LZ(#�{->�V����,���wĉ� 4��ߓ,�%5&=�6��7>_Zm��V�7^L���&:�����/<���� �A�Y}���C~껰�1[$D��_%q5|E>�O�؄�F��� ����I��
t�I�};�B8�lK����ф��Mf�p�7౐Q�#�vC%Q�G-��R��W����[�LPY�y<�]� ����@�]~���*܇_.zw��*�`Fڙ���a^$�;��]�|D?\��c�%V
���LdfȚ�+�9d��Y�4ff&d�����,a�����j4_�tEr���j�G�cr�)r�8G�����s�<l�t�+Nr�qJ*�%�v�����ϩv��k��h/�x�i=�rC{>^��Kpm~�3~u
=~��+�`��م>ص�7�Q��n�[1���NYM|�B7��,iS4c��F$��KU������Y�~���D���c�n����~��9g�6�V��PP_�q�&�xZ3�d7��4�)5�^U�-��Cɰ�N�����x�>��]�L��N[|��<�&��'�rϤ����$��a�^��C�6'�ȀKl2����|q����~�tMLS̩�C��opB�~VL�Sl"��D�Hq�T���R3�3��~�RE8�ѷ�P\3b�@�&!��F���2�	�E��IT+��Z�n�Gj�' �>S�rS��f9��ݺ��. b�%w�����6�Х����o$",��ʎf��JJ3�>�{;���;�j�ɖ�H��3��W��_
�sN��N,�n&�H���~�� �Ֆ0�C���ض�����U��_�b�����Sx$�01����H�߆Iؙj�]඿��l����Hپq�fH��[�%��&1�L�Ҡ��v��<��������N��m�B!Q[�h���NZO|,�^M�^
G�)��H�U��-�)a���.i�QD���F�f��
���l�n���tjT/~x�K!E^Aًh8pJ
����<�@ǯ�q
#��
o����??��L{���fy����
7�ً��o�#�3p��1�����[1�ڣ��Gm�75�a�R�y?F��w����S���ֲ%C��y܍��J�i�G?�`P)�}��I�J���7Q�ci
&�)��.�w
A�*�rP
�N�;+�*�<�*wr�<-1x�*I_]4��0_9�����407	{�@��2��z��'5�p��/V7�wqju��?B�s'��?GHk�p��A��L�il�lB�t���N=E�G�l�-�I_~9�,�T�Io:kth���K��1H�MJG�3��!p
N���eJ��lR'=���cU��[g]�ʼnXݖ�9t�YϜ��i��Y'���C�_]��I%i�3a��2o��b����eM:c7롷5�a�d�$��лىeG(A�Fhle��Meq�XSd�94c\iWf�<rjk*U'(Sj
���&9�kG����+m��D h[l��V]-��i7y��5��o�JD��Qq�����ڂxOf��1x:2z��1>�ezw��
�X}�i��|�A}/!D� ~��B��$;}��$QC�~�G,���#�ge|�[ʞD��X�mh3#�7g�x��Ԏ�������om9V��S��@K�'��ߙ����o���gv%�r�w�ح�ή��OJ
��џ�g�A��	���^�;��*�S
��٧Ѫ�������?IG�;�I���R7���>�_.3箟�av�FT��_sT���Rl��-`Vi)����J�p'Ķw��d�7˷_���F	*2�O�ih�s����D����7�M:xM{���t�ךɟ,:o"�|�o��?�׳�o��^b]T>Чb8rNZ���?H0���o��_�
`�4�'_�x�G�?�t}��H��y���)׿��L!WR��!d\�%��P�g�	�G_����U��g;q��:��ς�"�H�}�g�����}�G��*��<�}��i>���Dd�Y���7�4�<���ȿi$�G ��8�
�>1��ǧG8��!1�9�Yd�������K�_���j��������-뇬�K�;O��OoX-����'�����B�7J#��s�?�Sw�M��ߋ�`#��׳�q'�����Mp�[����c��a����w<;��>U����������y�o����j����SVoI������X�i^�9�r��
��������:�����O��e{��R���z�<�,^N`pr��5o��s�CS=1I��/��l�
73����WOR?`�����[
�'a�8��zQI�`�}qm��������+Y-������R�����n��	)`��b$����:�.�D)\S��p02����������@(������������4�k��������w��PpLsOFk~I���@P����������9��W�V=�Y�k���c�f�E0������G7
\a����<OJ���7�����&�K��T������L+F�R�=i,-�����GQ�����ga�^�}6DTQ�[�����Xm��{����$,Ss6�5�l?Ca�������+��������W�����M�4�����XxE)[�AhZ��.7�����15��f;wLm���7�v*��X����sg�|'d#Y�����wRO�����-����1c3����
,hZkJl^]
��''6�������������*��Y�J�0z��m�o�o�������0m�������C�V���uN��������1����n������z`����Ov���������\Umu�K�w��������������������,���nq����������[SnUT��JV�}��DaR�����,.%v�������������U���m�i���4���{����t

�(	�p��_�������Gi���Z�1_2o���������@q�#q���'��l���iz�F����1�����A;�)^[7<Z��`�����s��3��E��������i�R����O�q�kQ�H����o::C\o$2
BjUi�m�y��4�o��E��v����@>����.u~wF6����9w�������������;BI���$�������N;OC�1$^B���A5��aa�I�Q���d@�����.P1n57=]n\8����Vo7��|~k�j��NO��5�0����X�2 -�y�7N��A����{]�u����O�v����H��`� �����������S�Y=���\�6���NrA������?��N��]���sa$TBi�*s,q��������^t���&��O�	����|;���SZXR����������L�.����o:7����3aC�����7E��0;��_��rOo�#D����~J&����������g���&&^	g'����5�����h��{�����A��IF�+�"5���uj����~��^U��Q��K�~�t}lYC��� r8�3[��4�	��6�f���@'V�@�{���\d0 J��������������;C������IR'}y�����%1G3����b����k)U�c8Q�������`w��������������~{\U�-�����n;�2�p��f�����������''��>^�����;��Q�m���i����j�����4���:��������*8XW�]:�?�v&+o�����o�-�W�~����,�]zMM��WR�8���
�������(�F
;L+dMC"��������#6%�54��M�������Z����
S1[e�<W����S�����_FGc@oL!�����&���G�)).J�*#��w1}����7��
�5T���?m��Y��j<k�lS��}��z�]�E��_��S�'e��s��4#]������E�bqNs3l��
~E��A�P��ut0$G��������(yx$��b��8��������V5&:�����5�|�����-��KA]��^���s|Pt&�3?LlLmP%f������|�S�?	!��y����>��}�U[����%����H3l����� _�����
#	}0��*�%�wJ��4�����"����&��P��M��^:E�b�O��_8L{S>��"_O#Vtj?w{��|���8����G�a����w<;��>U��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)!
�t��C���.���꺾�f/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#���>�ħv�;KT_��i/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+@'-
DY�Y�����`
h1��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.H9���g�����wg:�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?��og�m~~���+�֒i/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!!@+"'(7��_��@������<�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)"
) ":,":-")).,=>$..))))* "*/%*  ((�#�m�xK����FMg/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 �6�S�S*Ib��2e/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
,.
T�rM (��H�@�.e/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 )<"T�'U
I\0���F��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'&<?
�I����>'��C��D��h/home/palash/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/crossbeam-epoch-0.9.18/src/sync/mod.rs� Y��(Ԃ�"�4vO;y�� ��\�\�Z�d��IqC}6��$�o�������'�(�O����x86_64-unknown-linux-gnu��Fh�o?���-]"�+crossbeam_epoch�-3f303a1308604a37�խ��ǣH���
��=���	Z���S�;S�������������������������������������������������������������������������������������������	�������h�<U�U����rust-end-file