📄 librayon_core-683451861a2493f2.rmeta
/home/palash/git/iron_learn/target/debug/deps/librayon_core-683451861a2493f2.rmeta
Language: rmeta • Lines: 5721
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_deque��8�r���G$7�ݠ-39548485313d4b56�crossbeam_epoch�"����"�@�a
K��V�-898edee4616dca8c�crossbeam_utils�ɟ��P�#�}
�Gr�-30ff13b172e89a74��$��$��$��$���$��$��THREADS_BITS�d����32�$�܄��$�0�$�0��$��$�$��$	�$�!�<�!
web_spin_lock�|�!̯!�private�
PrivateMarker�
private_decl�private_impl�	broadcast�	
�OP�R�spawn_broadcast� �BroadcastContext�"'a�"worker�"_marker�&�&with�(�(&impl FnOnce(BroadcastContext<'_>) -> R�&�&num_threads�-�-�broadcast_in�0�0�0	0	0	0	spawn_broadcast_in�7�7	9	7	job�<<<<<<<<<<	JobResult�F�F�H
F�J
J�FPanic�M
M�<Job�Pexecute�<JobRef�R�R
execute_fn�<<<W�
X�Wid�ZW�<StackJob�]L�]F�]�]latch�]func�]�
<d�d�d�d�
d
as_job_ref�d
run_inline�dinto_result�<l�l�l�l�<HeapJob�qBODY�q�<t�t�
tinto_job_ref�tinto_static_job_ref�<y�y�<ArcJob�|�|�<��
�as_static_job_ref�<����<	�����impl FnOnce(bool) -> T��	�into_return_value�<JobFifo��inner�<
��
�push�<��join������������A��B��RA��RB������impl FnOnce() -> R���	�join_context����������call_a����impl FnOnce(FnContext) -> R���	�call_b�������	�	�join_recover_from_panic������������	�
��Latch��set��AsCoreLatch��
as_core_latch��UNSET��SLEEPY��SLEEPING��SET����
�
get_sleepy��fall_asleep��wake_up����probe�����	SpinLatch��'r��
core_latch��registry��target_worker_index��cross������
�������������
�wait_and_reset��wait�������
�set_and_tickle_one�����CountLatchKind��Stealing������worker_index��Blocking����	���
��
�
with_count��	increment�������LatchRef���������	�����
�
�������������������������	�
���
������������������� �!�"�#�$�%�&�'�(�)�*�
ThreadBuilder���
�
stack_size����stealer����������
���run�����ThreadSpawn��spawn���� �	�����
����� �Registry��thread_infos��sleep��
injected_jobs��
broadcasts����
start_handler��exit_handler��terminate_count��THE_REGISTRY��THE_REGISTRY_SET��global_registry��	�init_global_registry��S��	�set_global_registry����	�	�default_global_registry��
Terminator��
������������
��#�	�	�current��current_num_threads��current_thread�����
���
impl FnOnce()��wait_until_primed��inject_or_push��inject��has_injected_job��pop_injected_job��inject_broadcast��%impl ExactSizeIterator<Item = JobRef>��	in_worker������in_worker_cold������	�	�in_worker_cross������	�increment_terminate_count��	terminate��notify_worker_latch_is_set��
ThreadInfo��primed��stopped���(�� ���
�WorkerThread����� �fifo����rng�������	���	�
��$�set_current��	�������	push_fifo��local_deque_is_empty��take_local_job���&�
wait_until����wait_until_cold��	�wait_until_out_of_work��	find_work��	�	�	yield_now��yield_local����steal��	�	�	main_loop��	�	��'�����XorShift64Star������
�COUNTER����
next_usize�scope�����������	�
���
�����������Scope��'scope��base��	ScopeFifo���.��/�fifos��	ScopeBase���.�����job_completed_latch���	��-��.�����	�	�
scope_fifo���.�����	�	�in_place_scope���.�����do_in_place_scope���.�����	�get_in_place_thread_registry��in_place_scope_fifo���.�����do_in_place_scope_fifo���.�����	���.��
�� ���	�	�����	�	�	���.��
�	�
spawn_fifo����	�	�����	�	�	���.��
�	�heap_job_ref��FUNC���&��4�	�complete���4���execute_job���4�execute_job_closure���4���job_panicked��maybe_propagate_panic����.�����.���ScopePtr��
����������������!��������counters�����AtomicCounters�����DUMMY��as_usize��	is_sleepy��	is_active���	�SLEEPING_SHIFT��INACTIVE_SHIFT��	JEC_SHIFT��THREADS_MAX��ONE_SLEEPING��ONE_INACTIVE��ONE_JEC����
��	�try_exchange��add_inactive_thread��increment_jobs_event_counter_if��!impl Fn(JobsEventCounter) -> bool��sub_inactive_thread��sub_sleeping_thread��try_add_sleeping_thread��
select_thread��
select_jec����
�increment_jobs_counter��jobs_counter��inactive_threads��awake_but_idle_threads��sleeping_threads�������	�
�Sleep��worker_sleep_states���7�	IdleState����rounds���;�ROUNDS_UNTIL_SLEEPY��ROUNDS_UNTIL_SLEEPING����
�	�
start_looking��
work_found��
no_work_found��impl FnOnce() -> bool��announce_sleepy���!��>��(�new_injected_jobs��new_internal_jobs��new_jobs��wake_any_threads��wake_specific_thread���
wake_fully��wake_partly�� ������� ���spawn_in����	spawn_job����	��3���
spawn_fifo_in���thread_pool�����������	�
���
�����������
ThreadPool������
�build���#�install������	��������%�current_thread_index�� current_thread_has_pending_tasks������������	��-��.�����	��0��.�����	��0��.������1��.������ ����3��������,��,��������C��C��,��,�������halt_unwinding������resume_unwinding��AbortIfPanic��
���compile_fail��quicksort_race1��quicksort_race2��quicksort_race3��	rc_return��left��right��rc_upvar��scope_join_bad�	

 !"#$%&'max_num_threads��%ThreadPoolBuilder���#��
�use_current_thread����get_thread_name�����"��"�
spawn_handler��
breadth_first�PanicHandler�StartHandler�ExitHandler��>��
��#��B�build_global��build_scoped��W������	�	�	��#��K���get_spawn_handler��get_num_threads��	�	�	�	��J�thread_name�����
��J�take_panic_handler����H��get_stack_size�����K�get_breadth_first��take_start_handler���"��N�take_exit_handler���"��N��
��B��M����
����N����K��"��N��"��N�into_builder���
�is_unsupported�GLOBAL_POOL_ALREADY_INITIALIZED�CURRENT_THREAD_ALREADY_IN_POOL��description��source���
initialize�	��#���ClosurePlaceholder��
����	�	�	�	
����
�migrated��	CoreLatch�������	LockLatch��m��v�����	OnceLatch�������
CountLatch��counter���	����__rayon_private__��DefaultSpawn��
����
�>��T�CustomSpawn��
�����������T�
LOCK_LATCH��__RUST_STD_INTERNAL_INIT���	�__RUST_STD_INTERNAL_VAL��	��U�
RegistryId��addr����������������������WORKER_THREAD_STATE���U��	��U�	��U�Counters��word������JobsEventCounter��
����������	�
������WorkerSleepState��
is_blocked��condvar���>���Executed��
�Idle��
��������������ThreadPoolBuildError���	
��	ErrorKind��GlobalPoolAlreadyInitialized��
�CurrentThreadAlreadyInPool��
�IOError��
����
Configuration��builder��>	FnContext���R����8 8(8+8,8/8/8/808087878Z8i8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8P����_""�$�%���L7M�����RR�S�<T�<�=�� �	��lP]]�a�b�<c�
<]:���������Pqq�s�<����`��P||�~�<ľ���B0��nP�����<�N�&a\&E�_���R����j�ֻ�`B��o����������������l��v)d�78��o�_���S��S���S�ȩ���C���p�_���S���E�E�[�U���q�_���S��S���	��M�8ù���_���������������������y���q���������	�6���P��8���r��r�_�����
��������� �������4^9o��_����T:3�K]�.��t��t�_����T������<����u�����$����ս1[�	�����V��V��g�q���v�_�v���v��v�v��v��v�v��v����)����� ���)������)�����W?�u�{�s��w�_���.��/��V��wWWQ�.�_���/��/���/��@.��T|��.������6���m>Sw
0�����y����W��W� 9��-�����y�����W���i
�}x����z�_�z���z��z�z��z�z�_�y����X��X���Y��Z����Q����B����Nqv����_�{�����Y���YF_I65����|�_�|���|��|�|��|�����G�5��@W���_���Z��	��aE���<�_����Z���Z���[��P$�q9GyW����[��[����fSk�����J	��
��J����J����"��"��K��K���+����t��}�_�}�_���J	��
��J����J����"��"��K��K���+����#�_����Q������_�~�_���[��R���h^U�/�}-"������������������������������������������UR��VR����l]yq�|�����������������������������������������������������������������������������������_�����P�����������������_�

��
�,�
$0��

Ħ
�,�
$1��

Ԕ
�,�
$2��

��
�,�
$3���?

T�?

�;,�?
8t�?

d�?

�;'��?V

��?
�?
���>�
�pL�?
�;�;��;��;�;poison��;�;data��;J��+΃���;�;Condvar��;��:�x\�^���K��a

�K�a
��p�K��a�����������������;t�������������������;t����p�p�����J�q�b�������3#;Z:��`�p�J�qbW�����_����

t��
�#�K�+a��pL��(_��K�a
�K�a
��p/5�K��a
���̍1��	K�a�K��a�K��a
���$��	K�aO	K�a�K��a��� ��������V_��k��a

�k�a
��+�+p�+��*�@��n�*{�w�k��a�����������������;t�������������������;t���ƒƒ����j�q�b�������3#;Z:��`ƒ�j�qbX�����_�\��	
L��
��w,���

L��
�+�U-���k�+a�ƒ����1_��k�a
�k�a
�ƒ06�k��a
�����1��	k�a�k��a�k��a
�Ǘ$��	k�aO	k�a�k��a��� �Ǘ��Ǘ�V_���
�T�	����H��z��%:��_��
���,�%16����d��/	20�^��/�,��/����_����d��/	20�^��/�,����-����_����d��/	20�^��*�,����-����_���d��@3	�A�a,k����$	'JK��>�,����<�$�0�_��
��,�$1���t��@-	�A�[,k���0�,��+������_�t�L��@-	�A�[,k���&�,��+������_��
 ��$��%32�������+	.�,V��;���/����_����64���i���$��(6"The global thread pool has already been initialized."����<:�����n���$��(<"The current thread is already part of another thread pool."��

F�yK&FHI�JK�L�MN�O���˞��y��y��,�

F�yN&��2���Box�������lf���]v�"���B�B�BGlobal�����I����̀
��u�(�u3�u:A��=
��'����$����ս1[�	b�5�5I�5��4�5phantom��4�5��4榦��������!��!���!���!���"������"���"���"�����nI��9A���
��y�)�y4�y=D��"
��&�z18?<�.
��%�}0�����
�"�f+�cah<�����������������������H��"������,�����*io���PhantomData�\��γ�FromStr�<��t	�4��
�L���|� ����"��$����d����l����0t����-,����.,����1�����0T����/L���� ,����3T����C�� ���C�����BT� ���,\� ���,L� ���,� ���$�!�0��T\�!���Td�"���T��� \�"������41 Rayon-core houses the core stable APIs of Rayon.�5��9c` These APIs have been mirrored in the Rayon crate and it is recommended to use these from there.�����QN [`join()`] is used to take two closures and potentially run them in parallel.���OL   - It will run in parallel if task B gets stolen before task A can finish.���gd   - It will run sequentially if task A finishes before task B is stolen and can continue on task B.�����RO [`scope()`] creates a scope in which you can run any number of parallel tasks.����� These tasks can spawn nested tasks and scopes, but given the nature of work stealing, the order of execution can not be guaranteed.���VS The scope will exist until all tasks spawned within the scope have been completed.�����ur [`spawn()`] add a task into the 'static' or 'global' scope, or a local scope created by the [`scope()`] function.�����|y [`ThreadPool`] can be used to create your own thread pools (using [`ThreadPoolBuilder`]) or to customize the global one.���vs Tasks spawned within the pool (using [`install()`][tpinstall], [`join()`][tpjoin], etc.) will be added to a deque,���]Z where it becomes available for work stealing from other threads in the local thread pool.��	���	&# [tpinstall]: ThreadPool::install()���	  [tpjoin]: ThreadPool::join()��	���
30 # Global fallback when threading is unsupported��
���
^[ Rayon uses `std` APIs for threading, but some targets have incomplete implementations that���b_ always return `Unsupported` errors. The WebAssembly `wasm32-unknown-unknown` and `wasm32-wasi`���]Z targets are notable examples of this. Rather than panicking on the unsupported error when���WT creating the implicit global thread pool, Rayon configures a fallback mode instead.��
���
b_ This fallback mode mostly functions as if it were using a single-threaded "pool", like setting���`] `RAYON_NUM_THREADS=1`. For example, `join` will execute its two closures sequentially, since���b_ there is no other thread to share the work. However, since the pool is not running independent���_\ of the main thread, non-blocking calls like `spawn` may not execute at all, unless a lower-���c` priority call like `broadcast` gives them an opening. The fallback mode does not try to emulate���_\ anything like thread preemption or `async` task switching, but `yield_now` or `yield_local`���&# can also volunteer execution time.�����XU Explicit `ThreadPoolBuilder` methods always report their error without any fallback.�����#  # Restricting multiple versions�����OL In order to ensure proper coordination between thread pools, and especially���NK to make sure there's only one global thread pool, `rayon-core` is actively���NK restricted from building multiple versions of itself into a single target.���52 You may see a build error like this in violation:���\� ```text���A> error: native library `rayon-core` is being linked to by more���>; than one package, and can only be linked to by one package�<� ```�����FC While we strive to keep `rayon-core` semver-compatible, it's still���HE possible to arrive at this situation if different crates have overly���GD restrictive tilde or inequality requirements for `rayon-core`.  The���KH conflicting requirements will need to be resolved before the build will�d�	 succeed.�<�����������������������+H,�"�+��=��+��*�*��(�γ�γ0����t	��
��� ��"�����������0���-���.
���1���0���/
��� 	���3���C���C���B���,���,�������0��T����T����T��� ������l��D����yD�m<�_��H��!\�\�<�
Ĩl�
��0��E(�0��E(
IE����d�����*���<5 This trait is private; this method exists to make it���8<+ impossible to implement outside the crate.���.+���8����8�4�8�8�T�����8$�(�8,�'�8�
<�'�8�l�%�%���d�����*���
8�8�T�����8$�(�8,�'�8�
<�'�8�l���8,�'�8�
<�'�8�l�%�l�L� "07�4|�D]�ST7��DC��!Dd��)dn����*γ\��γ�I��5������($�����R)��{}D�qďct�C��j��LI Executes `op` within every thread in the current thread pool. If this is���NK called from a non-Rayon thread, it will execute in the global thread pool.���PM Any attempts to use `join`, `scope`, or parallel iterators will then operate���PM within that thread pool. When the call has completed on each thread, returns���30 a vector containing all of their return values.�����EB For more information, see the [`ThreadPool::broadcast()`] method.�����?< [`ThreadPool::broadcast()`]: crate::ThreadPool::broadcast()�L���?�?��?buf��:�?�	�:$x��Lk��������������������""�$�%���L7M����������������$�����$�
����op��������
b��NK Spawns an asynchronous task on every thread in this thread pool. This task���OL will run in the implicit, global scope, which means that it may outlast the���OL current stack frame -- therefore, it cannot capture any references onto the���	2/ stack (you will likely need a `move` closure).��	���	KH For more information, see the [`ThreadPool::spawn_broadcast()`] method.��
���
KH [`ThreadPool::spawn_broadcast()`]: crate::ThreadPool::spawn_broadcast()�|�
���!!�������""�$�%���L7M���ĝ����������$���$���<�
 ���������
��85 Provides context to a closure called by `broadcast`.���
�##����&�l��L7M��$%�
Ī
4�
""��wB<�""���γRҹ��^=x������''�l(+,���E$��
��&�)�
**)&���������&����""�$�%���L7M�����!���������
(���������������RO Our index amongst the broadcast threads (ranges from `0..self.num_threads()`).�,����l&�&
+�$���"��EB The number of threads receiving the broadcast in the thread pool.����� # Future compatibility note�����LI Future versions of Rayon might vary the number of threads over time, but���KH this method will always return the number of threads which are actually���/, receiving your particular `broadcast` call.�\����l&�&
,�$���,�..�l/�_/���:������l��^�^��^��[�^���[����e�S����������������������q�aXÅÅą��:����-�-
/�$������d����������1�221�����������""�$�%���L7M����������������$���$�
0��������D�������0<closure_kind>�3<closure_signature>�3<upvars>�3303���������0��4��4��4404����]]�a�b�<c�
<]:��������������	�6���P���q�������q,�0��5��5��5505�������l,�!0��6��6��6606����������$���$�������88�$���$����""�$�%���L7M�����$��������$�%��$�%��<�%
7�����$�D�$��<�%7��9��9��9979�������&7��:��:��::7:������'7��;��;��;;7;�����l���5�5I�5��4�5���4�5��4榦�����||�~�<ľ���B0�օ��<��FPR]q|��,
�<=�4$
�<>Injector�DB
�<@Steal�,L
�<AHb
�"<B
UnsafeCell�Tv
�-<Cmem��
�<DI�
�5<E�
�l
��0"
��vxlX
l�k
UD�
Ft�
:�
L�
�GG���y�
����˞�HIJKMNIKL�y��NO����������lf���]v�"��������$�
FF��FF���0�0FF
K�y�0�0�y��FF���
FF�yk0p0FF
N�y�0�0����FF����
FF����
�
PP�����
P����QQQ��#
<�
PP
Q��this�$�
Ĕ	
4�	
�l�=�� �	ST��	
<�	
<RR���	 
T�	
<RR���	
�l܏

�l\�

�lXZ\��O
�
���lW�YYW���
P�y�

X�y��$�
"$��"
�
���l[W�
W
Z$�
8��
ZZ����ؑ'�ؑ�
��=��Z��"
<�
�lWW
\$�
��#
D�
�^�_�`_`^	���m�
���m�
���m�
��m,�
��m$�
��m����
�m����m�
���m$�
���m$�
�m]:������abc��������
,�
]]�m��
$�
<]]�-�-���-��*��]�������������������;t����m�� 
4�
<]]�-�-���-��*��]���FHI�JK�L�MN�O���˞��m��h
�e�f�ggef	���
Г�
���
�,�
��$�
����
���
��$�
Ɣ$�
�mhijk!TVY[��9
�
�m�m�mdd
h�m�m�m�$�
�,�
��0
T�
���m�ld�
d
i�m�m�m$�
��8
T�
�m�mdd
j�m�m�m$�
stolen�4�
��+
\�
�m�mdd
k�m�m�m$�
��p
�m�n�oomn	���
Г�
���
�,�
��$�
����
���
��$�
Ɣ$�
�mpQp!TVY[��"
<�
�ll
p�m�m�m��$�
��
<�
�rr���n$�
��nD�
�n����n$�
�n����`�sOQL�
�
<qq�n��9
�uu��D�
���$�
��$�
�nvwx��)
�
�n����������lf���]v�n��tt
v�n��
��!<
d�!
ܟ�ltt
w�n$�!
��"]
��"
ܟ�ltt�n<�#

x�n$�"
��#A
�zz��D�$
���$�#
��$�$
�n{Q{��$"
<�$
�yy
{�n��$�$
��&
4�&
�}}�$�&
��n$�&
����$�&
��n$�&
�nľ���B0�~JLL�&
�&
<||�n��';
�����$�'
���$�'
��$�'
��$�'
�n��� "��')
�'
�n�5�5I�5��4�5���4�5��4榦������n��
��n��'
��);
T�)
����l�)

��n��$�)
��+\
��+
����l�+
��<�+

��n��$�+
��,C
�����$�,
���$�,
��$�,
��$�,
�n�Q�!#��,"
<�,
���
��n��$�,
��-
������-
������--
$�-
<��������������.
�������.
������y�.

��y���$�.
BD�.
��������������y���y����1*
��1
���y��
��y$�1
̜3
<�3
�n�N�&a\&E���3
,�3
<������head��tail���!�GƧ��ld�3
�n����3
�3
�n��
���4;
$�4
���n�l�l��4
�
�$�4
job_ref�<�4
��7
�n�Q���8"
<�8
���
���$�8
D�$�����D]���L,����$M����)dS����4m���H��"���[L�������~�;%pDBaclfTlyF��7�����B? Takes two closures and *potentially* runs them in parallel. It���63 returns a pair of the results from those closures.�����FC Conceptually, calling `join()` is similar to spawning two threads,���85 one executing each of the two closures. However, the���96 implementation is quite different and incurs very low���EB overhead. The underlying technique is called "work stealing": the���EB Rayon runtime uses a fixed pool of worker threads and attempts to���DA only execute code in parallel when there are idle CPUs to handle�<� it.�����C@ When `join` is called from outside the thread pool, the calling���C@ thread will block while the closures execute in the pool.  When���GD `join` is called within the pool, the calling thread still actively���GD participates in the thread pool. It will begin by executing closure���HE A (on the current thread). While it is doing that, it will advertise���MJ closure B as being available for other threads to execute. Once closure A���DA has completed, the current thread will try to execute closure B;���	JG if however closure B has been stolen, then it will look for other work���
HE while waiting for the thief to fully execute closure B. (This is the���
$! typical work-stealing strategy).��
�t�
 # Examples�����FC This example uses join to perform a quick-sort (note this is not a���FC particularly optimized implementation: if you **actually** want to���DA sort for real, you should prefer [the `par_sort` method] offered�t� by Rayon).�����WT [the `par_sort` method]: ../rayon/slice/trait.ParallelSliceMut.html#method.par_sort��
�\�
 ```rust���
 # use rayon_core as rayon;���
)& let mut v = vec![5, 1, 8, 22, 0, 44];��� quick_sort(&mut v);���,) assert_eq!(v, vec![0, 1, 5, 8, 22, 44]);�����30 fn quick_sort<T:PartialOrd+Send>(v: &mut [T]) {���    if v.len() > 1 {���"        let mid = partition(v);���.+        let (lo, hi) = v.split_at_mut(mid);���)&        rayon::join(|| quick_sort(lo),���*'                    || quick_sort(hi));�D�    }�,� }�����74 // Partition rearranges all items `<=` to the pivot���A> // item (arbitrary selected to be the last item in the slice)���:7 // to the first half of the slice. It then returns the���2/ // "dividing point" where the pivot is placed.���;8 fn partition<T:PartialOrd+Send>(v: &mut [T]) -> usize {���      let pivot = v.len() - 1;���     let mut i = 0;���     for j in 0..pivot {���!         if v[j] <= v[pivot] {��             v.swap(i, j);���             i += 1;�l�
         }�L�     }���     v.swap(i, pivot);�L�     i�,���<�������  # Warning about blocking I/O�����=: The assumption is that the closures given to `join()` are���=: CPU-bound tasks that do not perform I/O or other blocking���@= operations. If you do perform I/O, and that I/O should block���FC (e.g., waiting for a network request), the overall performance may���FC be poor.  Moreover, if you cause one closure to be blocked waiting���C@ on another (for example, using a channel), that could lead to a�l�
 deadlock.���d�	 # Panics�����FC No matter what happens, both closures will always be executed.  If���>; a single closure panics, whether it be the first or second���B? closure, that panic will be propagated and hence `join()` will���EB panic with the same panic value. If both closures panic, `join()`���;8 will panic with the panic value from the first closure.�$����������������������������������������t�����������$����t�����������$�����$�����$�
���������oper_a�4�oper_b�4����������@$���������������������������l�������
�������SUOQ����������́��������H�����������������y��%���D�����������������!���B? Identical to `join`, except that the closures have a parameter���B? that provides context for the way the closure has been called,���B? especially indicating whether they're executing on a different���DA thread than where `join_context` was called.  This will occur if��� 96 the second job is stolen by a different thread, or if��� C@ `join_context` was called from outside the thread pool to begin�L�! with.�d�!���������������������!���!���!���!�������!��������!��$�!�������"��������"��$�"��$�"��$�"
�����������4�!��4�!����������"R4�"����������������"������"�������"��������"
�������"injected�D�"egac���#���������������F���l�#������#��u��$���<�#����������������#F4�#�����������������#����#����$���$
�������#1368���$�����������������F�������$��������$��w��%���|�$��������������̈%����������������������w��������4���4������w����������������l��v)d�7����4
�
worker_thread�l�4job_b_latch�\�4err��5L�,��������������γ\
������,,
���b\K
�����DX
����Ir
�5���!D�
����)d�
���Š<�
�;���,�
�;���
�|"
��7*
����tg
�|)
qs`b�
RTAC��
,�
�������
����� �����!
�
����
�����$�
�
\�
������K
����������&
l�
������o��
�
���$�
��
,�
���
4�
���
D�
���
�
�t�
�o��������
�
��o��
���'
T�
���o��
�
�$�
��(
\�
���o��
�
�$�
��
<�
���o��
�
�$�
��"(
�"
��o��
���$�"
��$"
,�$
���o��$
�
�$�$
��%
�o�����%%
l�%
���o����%
�
�$�%
��'
L�'
������������������l��v)d�7�l��v)d�7�����'
��'
T�'
����o��'
D�'
������Ԟ(
��(
���\�(
,�(
�����(
���������(
��*<
�+
��w����
���4�+
��.>
,�.
������
���4�.
��0"
,�0
������0
�
��$�0
��0"
8���o�����1%
l�1
���o��o��1
�
�8$�1
��1
8���o�����2 
�2
�o��
�8��$�2
t�>
�p�����>&
�>
�p������@#
t�@
���p��@
�
�$�@
��B
$�B
���p��B
�
�$�B
��C
�p�����D 
�D
̍��
���$�D
t�K
�q����K 
�K
�q��
���M�
��M
��q����N
�
���$�M
�D�N
���N
��O
�q�����P%
l�P
���q��o��P
�
�$�P
��T
t�T
��r����y�������D�U
����r��V
,�V
����o��Y
D�Y
�������Z
d�Z
���D�[
����r��[
,�[
����p��['
�r��_���[B
�[
�����r��^�^��^��[�^���[����e�S������[
�
�$�[
��[
|�^
�q������^7
�_
�����������������;t�����w�q��_
�
�owner�,�_
��_L
T�_
�����������������;t�����w�q��`
�
��,�_
��,�`
��d
L�d
���q��d
�
�$�d
��e7
$�e
����q����������������;t�����w��e
�
�$�e
��,�e
��i
�q�����j 
�j
�q��
���$�j
��p!
D�p
���������s�p
�s�ԉq
��������	�6���P����s6���P�����p
qs|�p
,�p
����s�4�q
������γRҹ��^=x��s��q
8��������q
�r�
��q/
�q
���s��������	�6���P����s��q
�
�8�s�,�q
��r-
8��������r
��s$�r
�r��s!
8��������s
�r�����\�s
4�s
���s��s
,�s
���r��s��s
�
�8�s$�s
��t(
8��������t
��s,�t
�r���!#��u 
�u
�r��
�8�s��$�u
d�D������������������������<����4R���D"]���\@����RLM����,X����D_����SLi����SLt����L����<,�����,��;���4�����ZL�����K\�����Kd�����Kd�����Z������J������,������D������,����Stealer�<�X��Worker�4�@��p$��+�����*��
DefaultHasher�l��G���4��`�����������������b\������D�����I��5��Once�$��5���4�����'����1X�������������������|l�n��vadRUCF47%(
��3��������|��D����"��~�<�rD�cD�U��*IL9<��.1\�Ĭ��UR Thread builder used for customization via [`ThreadPoolBuilder::spawn_handler()`].�l��s4^9o���������$��������������������;t����F�F��F��1"`��x9��T��������������������;t�����4����@@�B�Cbuffer�Dflavor�E�2y�������lĠ<����XXʎZ�[˖�}K#V/���l��D������d�,�������s��������GD Gets the index of this thread in the pool, within `0..num_threads`.�,����s���
�$���"��FC Gets the string that was specified by `ThreadPoolBuilder::name()`.�$����s����������������;t�������
�$���	)��	KH Gets the value that was specified by `ThreadPoolBuilder::stack_size()`.�T�	���s����
�
�$�
����
JG Executes the main loop for this thread. This will not return until the�ܔ thread pool is dropped.���s��
�$���!�s��_���8������s��^�^��^��[�^���[����e�S�������
�$�����\������������� ��������=,������s��������������������q�aXܲ���
���$��4���!�t��������<,����t�s١���
�$��4�����������������s��K����u���١t���u����&���u��u�
��#��u�u��
��u� ,���[���٤t����&����u��������<,����u�s١���
��u$��4�ԢD������nI����������d�����?�?��?���:�?�	�:$x��Lk����(��(���)���(��� ���:��f���d�,�������<��<���7��)Jfp�t+��l��������&T�����;�;��;��;�;���;�;���;J��+΃���?�?��?���:�?�	�:$x��Lk�������(l��������������������;t�������������lf���]v�������������(l��������������������;t�������������lf���]v�������������&d�������%|�%�������b���S�XU�t~�-���&.d�&�����������������;t��������&��&��5�5ߐ�5��5=d0ݞh.�B��(9|�(��
�,�)��������������}��������������������q�aX���}��-���-����������������������q�aX��}�#�������-���\�.
����[<�-%'�.�����������������������������������q�aX���}����0���0��u�������0��u��07�u����1+
��u�D�0=?�2��������������u���u��2��������������u������6K��6��
��VT�=�����u�ս1[�	������u��VO����u��
���>��>�������> ����u����>��>$�>���u��>�
��$�>l�>����������������������?��?�����#���г�?�\�@
����[<�?�B����������������������E�������������������W(<�X����
���[,��\��
���_<t�_�������������������;t�����w��_�
�$�_��a%�a����v��b�
�$�b��d)\�d�����d�
�$�d��d3d�d����%��%���d�����l�e���D�e���
���$�d��dBD��i&��i�����i�
�$�i��p4t�p����l��p�
�$�p��<�p��t14�t����l��t�
�$�tinjected_job�d�t��z"��z������z�
�$�z��z,��z��������������������;t����l��z�
�$�z��[������&��&����������%�I���� ���J�ll�
���$��!l�@B����L���������������������������������w�� ������������$����$��
�����$Š��Ȋ�������t����������������������������������w��� ��������ܐ��$����$�
�����$�����������������������������p�����T���������������������������|���������w����������������������������w�� ������������$����$��
�����$���%t����Ɨ����Tٚ������������������������.̐��������
�$���שL�������
�$��լK���������
�$��������T������:��f��������4������p�ʱ<ʱ����p���L������qĈ�<�������|��������.���������
�� <´�d���w�W?�u�{��������ڷ4ڷ�����IJ�<�������l��$������nd��,������ֹֹ������-�������͐���D���������)�w����ҽ&$ս�s�w��
��4ڽ����w������$�����w����
�$�����������������ƒ�w����w��������������������.<�����
����2\������
��4�����������������������/D�����w�������
�$�����#,�����w����
�$�����-$�����w�l����
�$��������2L�����w�l����
�$��������1������w����
�$�����5t�����w������
�$�����"�������w����
�$�����JT������w��m����������m����m\��
��m$���,��.0���3|�������w��o����
�$���,����������������������'�������w����
�$�����%L������w������
�$�������������������������������������������'L�����w�|����
�$�����)\�����w�|����
�$�����0<�����w�l����
�$��������!,������w������
�$��L�����������������t�������������������
�����*L����s
��4����������������������������lf���]v�����������ր�������������������oL��������������������������w�̄ �����������$���$��
���������{}��Չt܉�������͐����,�����+�+p�+��*�@��n�*{������������������
����<���ٮ���$�����������
�$�����'T�����������
�$��n���L�,����������������"���4�|���<�q���<�����4�R���ST�����,�����#|�����'L�����!D�����)d�����4����H��"�����*��γ\����γ���ManuallyDrop�d����������\L��Y���D�����I��5����"���.����������!��ux��Ekn\_MP>Al�3l�&D���	���D����(����t������PM Represents a fork-join scope which can be used to spawn any number of tasks.���)& See [`scope()`] for more information.�,��.���x�V��wWWQ�4���$�������/��������/���	�\Y��ju�.����P����NK Those spawned from the same thread are prioritized in relative FIFO order.���.+ See [`scope_fifo()`] for more information.�L��.���x�@.��T|���4���$��������,�����?�?��?���:�?�	�:$x��Lk��n����L���.����\Y��ju����4���	D�	�������
/,�
����Y�Y\�Yp��X=nۼk�p����������q��K4�������γRҹ��^=x����������lf���]v����x�������.����Sg��B? Creates a "fork-join" scope `s` and invokes the closure with a���DA reference to `s`. This closure can then spawn asynchronous tasks���DA into `s`. Those tasks may run asynchronously with respect to the���FC closure; they may themselves spawn additional tasks into `s`. When���EB the closure returns, it will block until all tasks that have been��� spawned into `s` complete.�����EB `scope()` is a more flexible building block compared to `join()`,���A> since a loop can be used to spawn any number of tasks without���FC recursing. However, that flexibility comes at a performance price:���B? tasks spawned using `scope()` must be allocated onto the heap,���B? whereas `join()` can make exclusive use of the stack. **Prefer���DA `join()` (or, even better, parallel iterators) where possible.**���l�
 # Example�����HE The Rayon `join()` function launches two closures and waits for them���IF to stop. One could implement `join()` using a scope like so, although���<9 it would be less efficient than the real implementation:���\�����ҽ��<9 pub fn join<A,B,RA,RB>(oper_a: A, oper_b: B) -> (RA, RB)���'$     where A: FnOnce() -> RA + Send,���'$           B: FnOnce() -> RB + Send,���           RA: Send,���           RB: Send,�,� {���,)     let mut result_a: Option<RA> = None;���,)     let mut result_b: Option<RB> = None;���     rayon::scope(|s| {���30         s.spawn(|_| result_a = Some(oper_a()));���30         s.spawn(|_| result_b = Some(oper_b()));�\�     });���.+     (result_a.unwrap(), result_b.unwrap())�,���<�����̢ # A note on threading�����EB The closure given to `scope()` executes in the Rayon thread pool,���DA as do those given to `spawn()`. This means that you can't access���<9 thread-local variables (well, you can, but they may have��� unexpected values).����� # Task execution�����EB Task execution potentially starts as soon as `spawn()` is called.���FC The task will end sometime before `scope()` returns. Note that the���@= *closure* given to scope may return much earlier. In general���PM the lifetime of a scope created like `scope(body)` goes something like this:�����/, - Scope begins when `scope(body)` is called��� $! - Scope body `body()` is invoked��� $!     - Scope tasks may be spawned���  - Scope body returns��� 74 - Scope tasks execute, possibly spawning more tasks���!?< - Once all tasks are done, scope ends and `scope()` returns��!���!@= To see how and when tasks are joined, consider this example:��"�\�"����"ҽ��" // point start���" rayon::scope(|s| {���#!     s.spawn(|s| { // task s.1���#'$         s.spawn(|s| { // task s.1.1���#"             rayon::scope(|t| {���#0-                 t.spawn(|_| ()); // task t.1���$0-                 t.spawn(|_| ()); // task t.2���$             });�|�$         });�\�$׍��%!     s.spawn(|s| { // task s.2�\�%׍��%     // point mid�<�% });���%
 // point end�<�%���%���%@= The various tasks that are run will execute roughly like so:��&�t�& ```notrust�l�&
 | (start)�,�& |���& | (scope `s` created)���&@= +-----------------------------------------------+ (task s.2)���'52 +-------+ (task s.1)                            |���'52 |       |                                       |���(52 |       +---+ (task s.1.1)                      |���(52 |       |   |                                   |���)52 |       |   | (scope `t` created)               |���)52 |       |   +----------------+ (task t.2)       |���)52 |       |   +---+ (task t.1) |                  |���*52 | (mid) |   |   |            |                  |���*52 :       |   + <-+------------+ (scope `t` ends) |���+52 :       |   |                                   |���+FC |<------+---+-----------------------------------+ (scope `s` ends)�,�,��\�, | (end)�<�,���,���,A> The point here is that everything spawned into scope `s` will���,?< terminate (at latest) at the same point -- right before the���->; original call to `rayon::scope` returns. This includes new���-EB subtasks created by other subtasks (e.g., task `s.1.1`). If a new���.FC scope is created (such as `t`), the things spawned into that scope���/B? will be joined before that scope returns, which in turn occurs���/B? before the creating task (task `s.1.1` in this case) finishes.��0���0DA There is no guaranteed order of execution for spawns in a scope,���0GD given that other threads may steal tasks at any time. However, they���1FC are generally prioritized in a LIFO order on the thread from which���1FC they were spawned. So in this example, absent any stealing, we can���2GD expect `s.2` to execute before `s.1`, and `t.2` before `t.1`. Other���2C@ threads always steal from the other end of the deque, like FIFO���3GD order.  The idea is that "recent" tasks are most likely to be fresh���3A> in the local CPU's cache, while other threads can steal older���474 "stale" tasks.  For an alternate approach, consider���4 [`scope_fifo()`] instead.��5�ԗ5 # Accessing stack data��5���5A> In general, spawned tasks may access stack data in place that���5DA outlives the scope itself. Other data must be fully owned by the���6 spawned task.��6�\�6����6ҽ��6%" let ok: Vec<i32> = vec![1, 2, 3];���7����7*'     let bad: Vec<i32> = vec![4, 5, 6];���7     s.spawn(|_| {���7A>         // We can access `ok` because outlives the scope `s`.���8%"         println!("ok: {:?}", ok);��8���8NK         // If we just try to use `bad` here, the closure will borrow `bad`���9MJ         // (because we are just printing it out, and that only requires a���:IF         // borrow), which will result in a compilation error. Read on���:         // for options.���:*'         // println!("bad: {:?}", bad);�T�;    });�<�;ۚ<�;���;���;EB As the comments example above suggest, to reference `bad` we must���;EB take ownership of it. One way to do this is to detach the closure���<DA from the surrounding stack frame, using the `move` keyword. This���=FC will cause it to take ownership of *all* the variables it touches,���=1. in this case including both `ok` *and* `bad`:��=�\�>���>ҽ��>%����>����>*��Ԗ?     s.spawn(move |_| {���?%Ͱ��?'$         println!("bad: {:?}", bad);�\�?׍�@���@IF     // That closure is fine, but now we can't use `ok` anywhere else,���@2/     // since it is owned by the previous task:���A1.     // s.spawn(|_| println!("ok: {:?}", ok));�<�Aۚ<�A���A���AMJ While this works, it could be a problem if we want to use `ok` elsewhere.���BKH There are two choices. We can keep the closure as a `move` closure, but���BPM instead of referencing the variable `ok`, we create a shadowed variable that���C+( is a borrow of `ok` and capture *that*:��C�\�C����Cҽ��D%����D����D*����E<9     let ok: &Vec<i32> = &ok; // shadow the original `ok`�ԽEʷ��EFC         println!("ok: {:?}", ok); // captures the shadowed version���F'��\�F׍�F���FMJ     // Now we too can use the shadowed `ok`, since `&Vec<i32>` references���GPM     // can be shared freely. Note that we need a `move` closure here though,���GHE     // because otherwise we'd be trying to borrow the shadowed `ok`,���H,)     // and that doesn't outlive `scope`.���H30     s.spawn(move |_| println!("ok: {:?}", ok));�<�Iۚ<�I���I���IQN Another option is not to use the `move` keyword but instead to take ownership��J of individual variables:��J�\�J����Jҽ��J%����J����K*����K���KTQ         // Transfer ownership of `bad` into a local variable (also named `bad`).���L[X         // This will force the closure to take ownership of `bad` from the environment.�ԁM         let bad = bad;���M?<         println!("ok: {:?}", ok); // `ok` is only borrowed.���MOL         println!("bad: {:?}", bad); // refers to our local variable, above.�\�N׍�N���NHE     s.spawn(|_| println!("ok: {:?}", ok)); // we too can borrow `ok`�<�Oۚ<�O���O�d�O���O���OEB If a panic occurs, either in the closure given to `scope()` or in���OB? any of the spawned jobs, that panic will be propagated and the���PB? call to `scope()` will panic. If multiple panics occurs, it is���PA> non-deterministic which of their panic values will propagate.���QEB Regardless, once a task is spawned using `scope.spawn()`, it will���QDA execute, even if the spawning task should later panic. `scope()`���RDA returns once all spawned jobs have completed, and any panics are��S propagated at that point.�,�S��m�.�������������S���S������x��S�������m�S����$�SƔ$�T
��.���m���S4�S������T����������������m���m���U����������������m�m�����.��/��V��wWWQ��np��UDA Creates a "fork-join" scope `s` with FIFO order, and invokes the���V@= closure with a reference to `s`. This closure can then spawn���VHE asynchronous tasks into `s`. Those tasks may run asynchronously with���WFC respect to the closure; they may themselves spawn additional tasks���WEB into `s`. When the closure returns, it will block until all tasks���X-* that have been spawned into `s` complete.��X���X���X���XIF Tasks in a `scope_fifo()` run similarly to [`scope()`], but there's a���YEB difference in the order of execution. Consider a similar example:��Y�\�Y���Zҽ��Z��ܸZ rayon::scope_fifo(|s| {���Z&#     s.spawn_fifo(|s| { // task s.1���Z,)         s.spawn_fifo(|s| { // task s.1.1���['$             rayon::scope_fifo(|t| {���[52                 t.spawn_fifo(|_| ()); // task t.1���\52                 t.spawn_fifo(|_| ()); // task t.2���\˙|�\�\�\׍��\&#     s.spawn_fifo(|s| { // task s.2�\�]׍��]��<�]ۚ��]�<�]���]���]@���^�t�^�l�^��,�^����^ | (FIFO scope `s` created)���^%" +--------------------+ (task s.1)�Ԇ_ +-------+ (task s.2) |���_+( |       |            +---+ (task s.1.1)���_ |       |            |   |���_74 |       |            |   | (FIFO scope `t` created)���`:7 |       |            |   +----------------+ (task t.1)���`/, |       |            |   +---+ (task t.2) |���a/, | (mid) |            |   |   |            |���a@= :       |            |   + <-+------------+ (scope `t` ends)��b :       |            |   |���b/, |<------+------------+---+ (scope `s` ends)�,�b��\�b֢<�b���b���bGD Under `scope_fifo()`, the spawns are prioritized in a FIFO order on���cFC the thread from which they were spawned, as opposed to `scope()`'s���cDA LIFO.  So in this example, we can expect `s.1` to execute before���dDA `s.2`, and `t.1` before `t.2`. Other threads also steal tasks in���eEB FIFO order, as usual. Overall, this has roughly the same order as���eEB the now-deprecated [`breadth_first`] option, except the effect is���fGD isolated to a particular scope. If spawns are intermingled from any���fB? combination of `scope()` and `scope_fifo()`, or from different���gHE threads, their order is only specified with respect to spawns in the���g same scope and thread.��h���h85 For more details on this design, see Rayon [RFC #1].��h���h>; [`breadth_first`]: crate::ThreadPoolBuilder::breadth_first���i]Z [RFC #1]: https://github.com/rayon-rs/rfcs/blob/main/accepted/rfc0001-scope-scheduling.md��i�d�i���i���iGD If a panic occurs, either in the closure given to `scope_fifo()` or���jEB in any of the spawned jobs, that panic will be propagated and the���kGD call to `scope_fifo()` will panic. If multiple panics occurs, it is���kA����lEB Regardless, once a task is spawned using `scope.spawn_fifo()`, it���l?< will execute, even if the spawning task should later panic.���mHE `scope_fifo()` returns once all spawned jobs have completed, and any���m(% panics are propagated at that point.�T�n���m�.�����������n���n�	����	�x��n�	������m�n��$�nƔ$�n
��.���m���n4�n}����o����������������m�����p����������������m�������/��/���/��@.��T|���x\��pB����pD����qDɁ��qF����rE��s���s���sJG This is just like `scope()` except the closure runs on the same thread���sGD that calls `in_place_scope()`. Only work that it spawns runs in the���t
 thread pool.��t�d�t���t���tNK If a panic occurs, either in the closure given to `in_place_scope()` or in���uB����uKH call to `in_place_scope()` will panic. If multiple panics occurs, it is���vA����wE����wMJ execute, even if the spawning task should later panic. `in_place_scope()`���xD����x��t�x���m�.�����������y���y�	����	�xܷy�	������m�y
��.���m���y4�ylnqs��y���z�	����������������;t����	�����m�.���������z���z���z�	����	�x��z�	������m�z
��.���m�D�z���z4�ztvy{�|����������������m������|{�|��	����������������;t����	������������������;t����	�w���|
��D�|�Ée�ǀD�����@���́H�����F���݂E�����-��у��ՃOL This is just like `scope_fifo()` except the closure runs on the same thread����LI that calls `in_place_scope_fifo()`. Only work that it spawns runs in the��������d����������SP If a panic occurs, either in the closure given to `in_place_scope_fifo()` or in���B�����PM call to `in_place_scope_fifo()` will panic. If multiple panics occurs, it is����A���‡JG Regardless, once a task is spawned using `scope.spawn_fifo()`, it will����RO execute, even if the spawning task should later panic. `in_place_scope_fifo()`����D��쥉���ʉ���m�.���������������	����	�x����	�����m��
��.���m���4މsuwy�ӊ����	����������������;t����	�����m�.�������������������	����	�x�ċ�	������m�
��.���m�D������4��|~��������������������m����Ԛ��.���x���4�����N����	�	����������������;t����	�w����������������;t����	���x�Ѝ�
��.��,�D�����e��?< Spawns a job into the fork-join scope `self`. This job will����?< execute sometime before the fork-join scope completes.  The���@= job is specified as a closure, and this closure receives its����>; own reference to the scope `self` as argument. This can be���(% used to inject new jobs into `self`.����l��
 # Returns�������@= Nothing. The spawned closures cannot pass back values to the����@= caller directly, though they can write to local variables on��˒74 the stack (if those variables outlive the scope) or����(% communicate through shared channels.�������B? (The intention is to eventually integrate with Rust futures to����63 support spawns of functions that compute a value.)����tƔ��ٔ�\�����ҽܔ� let mut value_a = None;�ܴ� let mut value_b = None;��ԕ let mut value_c = None;���������     s.spawn(|s1| {����B?           // ^ this is the same scope as `s`; this handle `s1`���;8           //   is intended for use by the spawned task,����FC           //   since scope handles cannot cross thread boundaries.�������         value_a = Some(22);�������HE         // the scope `s` will not end until all these tasks are done����         s1.spawn(|_| {����#              value_b = Some(44);�|ę�\ؙ׍��������         value_c = Some(66);�\��׍<��ۚ�ʚ" assert_eq!(value_a, Some(22));���" assert_eq!(value_b, Some(44));����" assert_eq!(value_c, Some(66));�<����˛�tӛ # See also�����A> The [`scope` function] has more extensive documentation about���� task spawning.�˜��Ӝ [`scope` function]: scope()�,���	�	�x������������$���	����	�x����	��ڙ�����$Ν���.4՝
��.��$��body�$�����<����������������������6���m>Sw
0������<۟�������������������������ƢOL Spawns a job into every thread of the fork-join scope `self`. This job will����NK execute on each thread sometime before the fork-join scope completes.  The����NK job is specified as a closure, and this closure receives its own reference����EB to the scope `self` as argument, as well as a `BroadcastContext`.�|���	�	�x�����������$���	�	����	�x""�$�%���L7M���	�ҥ(�	�	�����"��$�����$����4��
��.��$��™$�����<ߦ������������������<����������������������T�����������������""�$�%���L7M�����ũ�.���x���4ʩ��N����	�	����������������;t����	�w����������������;t����	���x����
��.��,��D��ϫ����������������n�԰n���?ۈ�߬?�����@���>�����(��خ�t��������>; This method is akin to [`Scope::spawn()`], but with a FIFO����A> priority.  The [`scope_fifo` function] has more details about���� this distinction.�������)& [`scope_fifo` function]: scope_fifo()�T۰�	�	�x����������$��	����	�xԗ��	��ɫ���$����4��
��.��$��™$�vx�<����������������������6���m>Sw
0������<����������������������������O����Nǜ�ӹN�����E��|���	�	�x�����������$���	�	����	�x""�$�%���L7M���	���,�	�	����"��$���$���4��
��.��$��™$�����<ɼ������������������<����������������������T������������������������.������������4�����N����	�	����������������;t����	�w����������������;t����	��������
��.��,���D�����������������������������������;t��������qd����	�	������������lf���]vqq�s�<����`��4���l��4�������߸$���߸D��߸���߸$��߸�.4��
��.߸$�����np����m�����	�	���5�5I�5��4�5���4�5��4榦�����||�~�<ľ���B0�߸����4�������$���߸$����	ɹ$���߸$��۹4��
��.߸$�����bd����������������߸�����/��������/���	�\Y��juϺ���qD����	�	�	������������������;t����	�w߸�m��4����������$��������l��߸��m��
��.߸�m$����,���$��Z\^`���\\�����߸��4�����$����D����	
��.߸��$���$��68���y������߸����������������;t����m��4��������$��������l������
��.߸�m��$���$��EGIK���:d����	�	��������
��.$��������������	�	������
��.$�����)�.���x��_�4�����:���	�	�	�	�x�	�^�^��^��[�^���[����e�S��	������
��.$��������-�.���x��_�4�����:���	�	�	�	�x�	�^�^��^��[�^���[����e�S��	������
��.$�����	XD�����������ym>Sw
0�������y	XQ����y��
��yfhD����������)���������y$���y���)���������$���y�����������y�
���4����	�	�y�	�y����
��y$��L�,��������RLm���Š<��;���,��;��CachePadded�\�����D������4�����8\����7t�����W������_��|���������\�pd�D����������������b\�����D%�����*+-�1 tC����7���{����+{����+���,����ٮ���z������(,�����z��	%D�	��z��
�$�	��%L���z��
�$���%L���z��
�$���d��ܯt����t����L����#\�̆d��̝d����<����������������%������
���9$���	�	������������������G����F�����,^�����y���
�$�ordering�D���\d���	�	���y�y�����
�$�	old_value�L�	new_value�L���D��� (�� ��	�	���� �
�$� ��#���#��	�	���:�y��:���$�������$!����z�$�����$�$
���$�$increment_when�t�$UW��*1��*��	�	����*�
�$�*��2(��2��	�	����2�
�$�2��7I��7��	�	���y��7�
�$�7��L�8��<4l�<�
��W$�<shift�,�<��=#T�=�
��W$�=l�=�y��������=�=��y��
��W$�=��>+��>��y�y��
�$�>��@4d�A��y�z��
�$�A��B-��B��y��
�$�C��C3��C��y��
�$�D��F-��F��y��
�$�F��G!�y��_���GD�G�	�	�	�	�y�	�^�^��^��[�^���[����e�S��	����G�
�$�G��G܍�	��2�	�	�	�	��,����)Jfp�t+����7������?�?��?���:�?�	�:$x��Lk����������u��� �{����D��������
L�
���=�����=���;�[�0�T��[�0�T�������d����\�4������
d�
����z������� ���T�����������������,�����
�	n_threads�L���������������������Dl��	�	�������
�$��d���T��	�	�����
�$����l��	�	�	�	���	���	�o�>��>������������������$�
���$�
idle_state�T��,�has_injected_jobs���np��-|���	�	���z���
�$����,���	�	�	�	���	���	�o����>��������������$�
���$���T��,�����>@��8KԵ8�	�	����8�
�$�8���8��<L��<�	�	����<�
�$�<num_jobs�D�<queue_was_empty�|�=��DL��D�	�	����D�
�$�D��D�D��|�D��F8D�F��	�	����F�
�$�F��D�F��|�F��P0��P��	�	����Q�
�$�Qnum_to_wake�\�Q��S4��S��	�	����T�
�$�T�,�Tt�[������[T�[��	�	����[�
�$�[��\\�\��	�	����\�
�$�\L�,�������!D(����4=���ÈN���Ib�5�����F����P����R����]���O�q����|���K����T��l6�DI�tW���@�hHE Puts the task into the Rayon thread pool's job queue in the "static"���DA or "global" scope. Just like a standard thread, this task is not���A> tied to the current stack frame, and hence it cannot hold any���DA references other than those with `'static` lifetime. If you want���B? to spawn a task that references stack data, use [the `scope()`���  function] to create a scope.�����,) [the `scope()` function]: crate::scope()�����FC Since tasks spawned with this function cannot hold references into���A> the enclosing stack frame, you almost certainly want to use a���A> `move` closure as their argument (otherwise, the closure will���A> typically hold references to any variables from the enclosing���%" function that you happen to use).�����@= This API assumes that the closure is executed purely for its���EB side-effects (i.e., it might send messages, modify data protected���$! by a mutex, or some such thing).�����DA There is no guaranteed order of execution for spawns, given that���@= other threads may steal tasks at any time. However, they are���	B? generally prioritized in a LIFO order on the thread from which���	GD they were spawned. Other threads always steal from the other end of���
DA the deque, like FIFO order.  The idea is that "recent" tasks are���
A> most likely to be fresh in the local CPU's cache, while other���FC threads can steal older "stale" tasks.  For an alternate approach,���&# consider [`spawn_fifo()`] instead.����� # Panic handling�����=: If this closure should panic, the resulting panic will be���JG propagated to the panic handler registered in the `ThreadPoolBuilder`,���
@= if any.  See [`ThreadPoolBuilder::panic_handler()`] for more�d�
	 details.��
���
UR [`ThreadPoolBuilder::panic_handler()`]: crate::ThreadPoolBuilder::panic_handler()���t�������DA This code creates a Rayon task that increments a global counter.���\�����ҽ��FC use std::sync::atomic::{AtomicUsize, Ordering, ATOMIC_USIZE_INIT};�����;8 static GLOBAL_COUNTER: AtomicUsize = ATOMIC_USIZE_INIT;����� rayon::spawn(move || {���63     GLOBAL_COUNTER.fetch_add(1, Ordering::SeqCst);�<�ۚ<���,��u��������D��u����u$��u<�
��u�$�HJ��kD��	�u�	�����������D�����$���<�
��u�$��D�:<��kL���	�u�	���l���������D�����$���<�
��u�$��D�:<<���������������u����u��'E��B? Fires off a task into the Rayon thread pool in the "static" or���B? "global" scope.  Just like a standard thread, this task is not���A����D����GD to spawn a task that references stack data, use [the `scope_fifo()`��� ������85 The behavior is essentially the same as [the `spawn`��� 52 function], except that calls from the same thread��� B? will be prioritized in FIFO order. This is similar to the now-���!FC deprecated [`breadth_first`] option, except the effect is isolated���!>; to relative `spawn_fifo` calls, not all thread-pool tasks.��"���"8���"���"63 [the `scope_fifo()` function]: crate::scope_fifo()���#*' [the `spawn` function]: crate::spawn()���#>����$]���$���$���$���$=����%J����&@ʂd�&���&���&SP [`ThreadPoolBuilder::panic_handler()`]: crate::ThreadPoolBuilder::panic_handler�T�'�u������'��D�'����$�'��<�'
��u�$�'24��)pl�)�	�u�	������*���)��D�*����$�*��<�*
��u�$�*�D�*:<|�\��������$������"���$����������!D����� \�����)d�����1������2������ ,����� �����-,�����-�����.,������0T������/L������Z������J������,�������*��I��5����*�L���\����6����qt��9gjX[d�M��(+��������0�������D��t����
��,) Represents a user-created [thread pool].�����MJ Use a [`ThreadPoolBuilder`] to specify the number and/or names of threads���KH in the pool. After calling [`ThreadPoolBuilder::build()`], you can then���A> execute functions explicitly within this [`ThreadPool`] using���EB [`ThreadPool::install()`]. By contrast, top-level rayon functions���KH (like `join()`) will execute implicitly within the current thread pool.������ ## Creating a ThreadPool����� ```ignore-wasm���ҽ��OL let pool = rayon::ThreadPoolBuilder::new().num_threads(8).build().unwrap();�<�������ZW [`install()`][`ThreadPool::install()`] executes a closure in one of the `ThreadPool`'s���	[X threads. In addition, any other rayon operations called inside of `install()` will also���
/, execute in the context of the `ThreadPool`.��
���
^[ When the `ThreadPool` is dropped, that's a signal for the threads it manages to terminate,���\Y they will complete executing any remaining work that you have spawned, and automatically�t� terminate.�������<9 [thread pool]: https://en.wikipedia.org/wiki/Thread_pool���>; [`ThreadPoolBuilder::build()`]: ThreadPoolBuilder::build()���
.+ [`ThreadPool::install()`]: Self::install()�T�
�{�Nqv�������
D�
�����|��{�������������������U��63 Deprecated in favor of `ThreadPoolBuilder::build`.�Use `ThreadPoolBuilder::build`���6����~��������������������q�aX�{����������lf���]v�����
�
configuration�l����,�����������������������q�aX�{�}��#���г��\�
����[<���%f��=: Executes `op` within the thread pool. Any attempts to use���<9 `join`, `scope`, or parallel iterators will then operate��� within that thread pool.�����  # Warning: thread-local data�����;8 Because `op` is executing within the Rayon thread pool,���96 thread-local data from the current thread will not be�|� accessible.����� # Warning: execution order�����LI If the current thread is part of a different thread pool, it will try to���EB keep busy while the `op` completes in its target pool, similar to���DA calling [`ThreadPool::yield_now()`] in a loop. Therefore, it may���HE potentially schedule other tasks to run on the current thread in the�̖ meantime. For example���������ҽ|� fn main() {���OL     rayon::ThreadPoolBuilder::new().num_threads(1).build_global().unwrap();���MJ     let pool = rayon_core::ThreadPoolBuilder::default().build().unwrap();�İ     let do_it = || {���         print!("one ");���         pool.install(||{});�ܑ         print!("two ");�T�     };���,)     rayon::join(|| do_it(), || do_it());�,���<�������EB Since we configured just one thread in the global pool, one might���41 expect `do_it()` to run sequentially, producing:���d�	 ```ascii��� one two one two�<�������IF However each call to `install()` yields implicitly, allowing rayon to���JG run multiple instances of `do_it()` concurrently on the single, global���85 thread. The following output would be equally valid:���d����� one one two two�<�����d���� ��� 85 If `op` should panic, that panic will be propagated.�� ���  ## Using `install()`�� ��� ����!!    # use rayon_core as rayon;���!    fn main() {���!WT         let pool = rayon::ThreadPoolBuilder::new().num_threads(8).build().unwrap();���"-*         let n = pool.install(|| fib(20));���"         println!("{}", n);�D�"���#���#"    fn fib(n: usize) -> usize {���#!         if n == 0 || n == 1 {���#             return n;�l�#����$\Y         let (a, b) = rayon::join(|| fib(n - 1), || fib(n - 2)); // runs inside of `pool`���$         return a + b;�L�%��<�%��<�%�	�	�{������������%����%���%���l�%������%��$�%��$�&
�����$�%���%bdgi4�&�������������������������4}��&MJ Executes `op` within every thread in the thread pool. Any attempts to use���'HE `join`, `scope`, or parallel iterators will then operate within that���'���(���(JG Broadcasts are executed on each thread after they have exhausted their���(KH local work queue, before they attempt work-stealing from other threads.���)EB The goal of that strategy is to run everywhere in a timely manner���)LI *without* being too disruptive to current work. There may be alternative���*DA broadcast styles added in the future for more or less aggressive���+" injection, if the need arises.��+���+ ���+���+;���,9��|�,��,�d�-���-���-B? If `op` should panic on one or more threads, exactly one panic���-=: will be propagated, only after all threads have completed���.! (or panicked) their own `op`.��.�t�.���.���.����/!����/63    use std::sync::atomic::{AtomicUsize, Ordering};��/���/Ϻ��0WT         let pool = rayon::ThreadPoolBuilder::new().num_threads(5).build().unwrap();��0���0NK         // The argument gives context, including the index of each thread.���1PM         let v: Vec<usize> = pool.broadcast(|ctx| ctx.index() * ctx.index());���2-*         assert_eq!(v, &[0, 1, 4, 9, 16]);��2���285         // The closure can reference the local stack���3,)         let count = AtomicUsize::new(0);���3FC         pool.broadcast(|_| count.fetch_add(1, Ordering::Relaxed));���4.+         assert_eq!(count.into_inner(), 5);�D�4��<�4��L�4�	�	�{������������4����4���4�	���""�$�%���L7M���	�5�	��������5��$�5��$�5
�����$�4���4������:*��6?< Returns the (current) number of threads in the thread pool.��7���7���7���785 Note that unless this thread pool was created with a���8?< [`ThreadPoolBuilder`] that specifies the number of threads,���8DA then this number may vary over time in future versions (see [the���9.+ `num_threads()` method for details][snt]).��9���9+( [snt]: ThreadPoolBuilder::num_threads()���:�	�	�{��:�
�$�:��B3��:=: If called from a Rayon worker thread in this thread pool,���;@= returns the index of that thread; if not called from a Rayon���;;8 thread, or called from a Rayon thread that belongs to a���<*' different thread pool, returns `None`.��<���<B? The index for a given thread will not change over the thread's���=C@ lifetime. However, multiple threads may share the same index if���>&# they are in distinct thread pools.��>���>���>���>63 Currently, every thread pool (including the global���?<9 thread pool) has a fixed number of threads, but this may���?DA change in future Rayon versions (see [the `num_threads()` method���@52 for details][snt]). In that case, the index for a���@;8 thread would not change during its lifetime, but thread���AB? indices may wind up being reused if threads are terminated and�t�A restarted.��A���B+����B�	�	�{����B�
�$�B��M>��CB? Returns true if the current worker thread currently has "local���DA> tasks" pending. This can be useful as part of a heuristic for���D?< deciding whether to spawn a new task or execute code on the���E1. current thread, particularly in breadth-first���E@= schedulers. However, keep in mind that this is an inherently���FB? racy check, as other worker threads may be actively "stealing"���F tasks from our local deque.��G���GA> **Background:** Rayon's uses a [work-stealing] scheduler. The���G74 key idea is that each thread has its own [deque] of���H<9 tasks. Whenever a new task is spawned -- whether through���H?< `join()`, `Scope::spawn()`, or some other means -- that new���IB? task is pushed onto the thread's *local* deque. Worker threads���I?< have a preference for executing their own tasks; if however���JA> they run out of tasks, they will go try to "steal" tasks from���J?< other threads. This function therefore has an inherent race���KA> with other active worker threads, which may be removing items���K from the local deque.��L���L@= [work-stealing]: https://en.wikipedia.org/wiki/Work_stealing���L=: [deque]: https://en.wikipedia.org/wiki/Double-ended_queue���M �	�	�{����������������;t�����M�
�$�M��O���N?< Execute `oper_a` and `oper_b` in the thread pool and return���O<9 the results. Equivalent to `self.install(|| join(oper_a,�t�O oper_b))`.�$�O�	�	�{��������������������P����O���O���O���P��t�P���P��$�P��t�P���P��$�P��$�Q��$�Q
���������$�P��4�P��4�P���������Q�����������������������������Sz��Q:7 Creates a scope that executes within this thread pool.���R0- Equivalent to `self.install(|| scope(...))`.��R���R'$ See also: [the `scope()` function].��S���S,��,�S�	�	�{���m��.���������S����S���S�	����	�x܈T�	������m�T��$�TƔ$�T
��.���m$�S���S4�S�����T����������������m������W���T:����UGD Spawns from the same thread are prioritized in relative FIFO order.���U52 Equivalent to `self.install(|| scope_fifo(...))`.��V���V,) See also: [the `scope_fifo()` function].��V���V6��T�W�	�	�{���m��.���������W����W���W�	����	�x��W�	������m�X��$�XƔ$�X
��.���m$�W���W4�W�����X����������������m������Zk��X;8 Creates a scope that spawns work into this thread pool.��Y���Y0- See also: [the `in_place_scope()` function].��Y���Y>; [the `in_place_scope()` function]: crate::in_place_scope()�t�Z�	�	�{���m��.���������Z����Z���Z�	����	�x܆[�	������m�[
��.���m$�Z���Z4�Zsuxz��]t��[IF Creates a scope that spawns work into this thread pool in FIFO order.��\���\52 See also: [the `in_place_scope_fifo()` function].��\���]HE [the `in_place_scope_fifo()` function]: crate::in_place_scope_fifo()���]�	�	�{���m��.���������]����]���]�	����	�x��^�	������m�^
��.���m$�]���]4�]tvy{��bP��_C@ Spawns an asynchronous task in this thread pool. This task will���_FC run in the implicit, global scope, which means that it may outlast���`JG the current stack frame -- therefore, it cannot capture any references���`;8 onto the stack (you will likely need a `move` closure).��a���a@= See also: [the `spawn()` function defined on scopes][spawn].��a�܃b [spawn]: Scope::spawn()�,�b�	�	�{�������b����b��D�b�����$�b��<�b
���$�b���bHJ��gU��cC����dF����eJ����e;Ѐ�f���fJG See also: [the `spawn_fifo()` function defined on scopes][spawn_fifo].��f���f)& [spawn_fifo]: ScopeFifo::spawn_fifo()�T�g�	�	�{�������g����g��D�g����$�g��<�g
���$�g���g;=��kq��iN����iO����jO����k2��|�k�	�	�{�������k����k�	���""�$�%���L7M���	��k�	��Ј���$�l��$�l��<�l
���$�k���k����p(��m,) Cooperatively yields execution to Rayon.��m���mKH This is similar to the general [`yield_now()`], but only if the current���n)& thread is part of *this* thread pool.��n���oTQ Returns `Some(Yield::Executed)` if anything was executed, `Some(Yield::Idle)` if���oQN nothing was available, or `None` if the current thread is not part this pool.�L�p�	�	�{����������������;t����|��p�
�$�p��t*��q74 Cooperatively yields execution to local Rayon work.��q���qMJ This is similar to the general [`yield_local()`], but only if the current���r)���r���sTɊ��sQ��\�t�	�	�{����t�
�$�tĿu�{�����u$�u�	�	�{��u�
�$�u��v�{��_���v:�v�	�	�	�	�{�	�^�^��^��[�^���[����e�S��	����v�
�$�v��v��.��xC@ If called from a Rayon worker thread, returns the index of that���xFC thread within its current pool; if not called from a Rayon thread,���y returns `None`.��y���yB����zC����z&���{���{C@ See also: [the `ThreadPool::current_thread_index()` method][m].��{���{+( [m]: ThreadPool::current_thread_index()��{���|���|���|6����|<����}D����}5����~;����~B��t�������+������
����9��@= If called from a Rayon worker thread, indicates whether that����DA thread's local deque still has pending tasks. Otherwise, returns����*' `None`. For more information, see [the����@= `ThreadPool::current_thread_has_pending_tasks()` method][m].�����74 [m]: ThreadPool::current_thread_has_pending_tasks()���� ��
����#�߄,��������JG If the current thread is part of a rayon thread pool, this looks for a��ۅLI single unit of pending work in the pool, then executes it. Completion of����A> that work might include nested work or further work stealing.�����PM This is similar to [`std::thread::yield_now()`], but does not literally make����KH that call. If you are implementing a polling loop, you may want to also����B? yield to the OS scheduler yourself if no Rayon work was found.�Έ��҈TɊ���SP nothing was available, or `None` if this thread is not part of any pool at all.�L����
����%���7��ȋ��̋J����IF single unit of pending work in this thread's queue, then executes it.���OL Completion of that work might include nested work or further work stealing.�������NK This is similar to [`yield_now()`], but does not steal from other threads.�������TɊ�ݎS��\����
�T�4�����H��"���$��*��AssertUnwindSafe����S��ˢ�S���4����l�{��$m,�NP\�+��\t��u��������������������q�aX������������������l��u����
��u���$�=?BD��A����
�payload�<���d��|�5��@W����/+���|ԋ�|�����$��	�	�|���
�$���d��������3|7��H|L��]|a�lrLv���Dh$l�L�,��d�D����t����?/Z/Z@Z@ZQZQZ�� bZbZtZtZ���Z��+�Z�Z�Z�Z�Z�Z��9�Z�Z�Z�Z�Z�Z�� [[[[��3([��';[� M[�� 2_[_[q[q[�[�[L�!�[��!8�[�[�[�[�[�[��%!��"VS Returns the maximum number of threads that Rayon supports in a single thread pool.��"���"c` If a higher thread count is requested by calling `ThreadPoolBuilder::num_threads` or by setting���#ZW the `RAYON_NUM_THREADS` environment variable, then it will be reduced to this maximum.��$���$a^ The value may vary between different targets, and is subject to change in new Rayon versions.�|�%
���,%��&B? Returns the number of threads in the current registry. If this���&C@ code is executing within a Rayon thread pool, then this will be���'<9 the number of threads for the thread pool of the current���'FC thread. Otherwise, it will be the number of threads for the global���(���(���(C@ This can be useful when trying to judge how many times to split���)>; parallel work (the parallel iterator traits use this value���)! internally for this purpose).��)���*���*���*8����*;8 builder that specifies the number of threads, then this���+:7 number may vary over time in future versions (see [the���+.���,���,)& [snt]: ThreadPoolBuilder::num_threads���,
���3.��/UR Used to create a new [`ThreadPool`] or to configure the global rayon thread pool.���/Ş��/85 The following creates a thread pool with 22 threads.��0���0����0ҽ��0PM let pool = rayon::ThreadPoolBuilder::new().num_threads(22).build().unwrap();�<�1���1���1HE To instead configure the global thread pool, use [`build_global()`]:��2���2����2ҽ��2LI rayon::ThreadPoolBuilder::new().num_threads(22).build_global().unwrap();�<�3���3���3,) [`build_global()`]: Self::build_global()���3�#��г��3�����+������������-�3�t��5\�5��ĥ6��6����7(l�7������88|�8������������������;t�������������lf���]v������������8T�8������9(l�9������:&d�:������;l�;������<l�<����?d�?����Ad�A����C\�C����D"�~�����D<�D�~��
���G�~���H��HVS Creates and returns a valid rayon thread pool builder, but does not initialize it.��H�~��
���J6��IVS Note: the `S: ThreadSpawn` constraint is an internal implementation detail for the���ILI default spawn and those set by [`spawn_handler`](#method.spawn_handler).��#��г�J�\�J������K>��JDA Creates a new `ThreadPool` initialized using this configuration.�,�K��Ȫ��
���$�K��S=��L>; Initializes the global thread pool. This initialization is���LDA **optional**.  If you do not call this function, the thread pool���M63 will be automatically initialized with the default���MDA configuration. Calling `build_global` is not recommended, except���N in two scenarios:��N���N30 - You wish to change the default configuration.���OA> - You are running a benchmark, in which case initializing may���OFC   yield slightly more consistent results, since the worker threads���PC@   will already be ready to go even in the first iteration.  But���P   this cost is minimal.��Q���Q<9 Initialization of the global thread pool happens exactly���Q30 once. Once started, the configuration cannot be���RDA changed. Therefore, if you call `build_global` a second time, it���R<9 will return an error. An `Ok` result indicates that this���S30 is the first initialization of the thread pool.�d�S����������������������q�aX�}��
���$�S��U�~���`���UGD Creates a scoped `ThreadPool` initialized using this configuration.��U���USP This is a convenience function for building a pool using [`std::thread::scope`]���V,) to spawn threads in a [`spawn_handler`].���WJG The threads in this pool will start by calling `wrapper`, which should���WEB do initialization and continue by calling `ThreadBuilder::run()`.��X���X,) [`spawn_handler`]: Self::spawn_handler()��X�t�X���X���XRO A scoped pool may be useful in combination with scoped thread-local variables.��Y���Y����Yҽ�Z���ZA> scoped_tls::scoped_thread_local!(static POOL_DATA: Vec<i32>);��Z���Z:7 fn main() -> Result<(), rayon::ThreadPoolBuildError> {���[&#     let pool_data = vec![1, 2, 3];��[���[0-     // We haven't assigned any TLS data yet.���\%"     assert!(!POOL_DATA.is_set());��\���\'$     rayon::ThreadPoolBuilder::new()���\         .build_scoped(���]=:             // Borrow `pool_data` in TLS for each thread.���]DA             |thread| POOL_DATA.set(&pool_data, || thread.run()),���^85             // Do some work that needs the TLS data.���^DA             |pool| pool.install(|| assert!(POOL_DATA.is_set())),�|�_         )?;��_���_B?     // Once we've returned, `pool_data` is no longer borrowed.�ă`     drop(pool_data);�t�`     Ok(())�,�`��<�`��d�`�~�L�m��������������������q�aX�m�}��L��������������`Г�`���`�������a��������$�a�	��m�	�{��a�	�m����m�b
����m�m$�`wrapper�<�`	with_pool�L�`������<�b����������������m�m���.������-�����X��1�H���~���mD�b����������������m�m��١���.������-�����X��1�H���f����������������m�m����s�g�#��г�g�������������������;=������g0- Sets a custom function for spawning threads.��h���hKH Note that the threads will not exit until after the pool is dropped. It���hKH is up to the caller to wait for thread termination if that is important���iOL for any invariants. For instance, threads created in [`std::thread::scope`]���jNK will be joined before that scope returns, and this will block indefinitely���jPM if the pool is leaked. Furthermore, the global thread pool doesn't terminate���k#  until the entire process exits!��k�t�k���k���kRO A minimal spawn handler just needs to call `run()` from an independent thread.��l���l����lҽ��m:����m2/     let pool = rayon::ThreadPoolBuilder::new()���n%"         .spawn_handler(|thread| {���n41             std::thread::spawn(|| thread.run());���n             Ok(())�t�o         })���o         .build()?;��o���oB?     pool.install(|| println!("Hello from my custom thread!"));�t�p��,�p��<�p���p���pSP The default spawn handler sets the name and stack size if given, and propagates���q'$ any errors from the thread builder.��q���q����qҽ��q:����r2����r%����s85             let mut b = std::thread::Builder::new();���s30             if let Some(name) = thread.name() {���t0-                 b = b.name(name.to_owned());���t             }���t?<             if let Some(stack_size) = thread.stack_size() {���u1.                 b = b.stack_size(stack_size);���u����u*'             b.spawn(|| thread.run())?;���v��t�v����v���v���vHE     pool.install(|| println!("Hello from my fully custom thread!"));�t�w��,�w��<�w���w���wQN This can also be used for a pool of scoped threads like [`crossbeam::scope`],���xOL or [`std::thread::scope`] introduced in Rust 1.63, which is encapsulated in���y [`build_scoped`].��y���yOL [`crossbeam::scope`]: https://docs.rs/crossbeam/0.8/crossbeam/fn.scope.html���z*' [`build_scoped`]: Self::build_scoped()��z���z����zҽ��z:����{$!     std::thread::scope(|scope| {���{63         let pool = rayon::ThreadPoolBuilder::new()���|)&             .spawn_handler(|thread| {���|B?                 let mut builder = std::thread::Builder::new();���}74                 if let Some(name) = thread.name() {���}A>                     builder = builder.name(name.to_string());���~                 }���~=:                 if let Some(size) = thread.stack_size() {���~;8                     builder = builder.stack_size(size);�������41                 builder.spawn_scoped(scope, || {����HE                     // Add any scoped initialization here, then run!��΀$!                     thread.run()����                 })?;�Ԕ�                 Ok(())����             })��ʁ             .build()?;�����MJ         pool.install(|| println!("Hello from my custom scoped thread!"));��         Ok(())�Tڂ     })�,���<���l�����m���J	��
��J����J����"��"��K��K���+�������T������<��m�����Г����m����&�m���١t��
����m$��� ,��NP���)����	�	���	���ӈ�
���$؈���"|���	�	������
���$������������������������������������	�	�	��	��	yk���9���������������������ҏ��������������������=|���	�	��������
���$���,đ���j���96 Sets a closure which takes a thread index and returns���� the thread's name.�\�����m�������Г����m���ړ�m�����4��m<�
����m$���<��XZ���8�ҔC@ Sets the number of threads to be used in the rayon thread pool.�������:7 If you specify a non-zero number of threads using this���?< function, then the resulting thread pools are guaranteed to����)& start at most this number of threads.�Ӗ��ۖA> If `num_threads` is 0, or you do not call this function, then����74 the Rayon runtime will select the number of threads��ݗ30 automatically. At present, this is based on the����63 `RAYON_NUM_THREADS` environment variable (if set),��И.+ or the number of logical CPUs (otherwise).����41 In the future, however, the default behavior may����:7 change to dynamically add or remove threads as needed.�������@= **Future compatibility warning:** Given the default behavior��Ț<9 may change in the future, if you wish to rely on a fixed����>; number of threads, you should use this function to specify��̛?< that number. To reproduce the current default behavior, you����:7 may wish to use [`std::thread::available_parallelism`]��Ϝ,) to query the number of CPUs dynamically.�������EB **Old environment variable:** `RAYON_NUM_THREADS` is a one-to-one��ҝEB replacement of the now deprecated `RAYON_RS_NUM_CPUS` environment����GD variable. If both variables are specified, `RAYON_NUM_THREADS` will��� be preferred.�\��������
���$���
\����+���=: Use the current thread as one of the threads in the pool.�����à]Z The current thread is guaranteed to be at index 0, and since the thread is not managed by����B? rayon, the spawn and exit handlers do not run for that thread.������\Y Note that the current thread won't run the main work-stealing loop, so jobs spawned into��բ[X the thread pool will generally not be picked up automatically by this thread unless you����\Y yield to rayon in some way, like via [`yield_now()`], [`yield_local()`], or [`scope()`].����Ğ� # Local thread pools�����ä[X Using this in a local thread pool means the registry will be leaked. In future versions����A> there might be a way of cleaning up the current-thread state.���������
���$�����=����	�	��������
���$���������96 Normally, whenever Rayon catches a panic, it tries to����>; propagate it to someplace sensible, to try and reflect the����96 semantics of sequential execution. But in some cases,����52 particularly with the `spawn()` APIs, there is no���96 obvious place where we should propagate the panic to.����0- In that case, this panic handler is invoked.������;8 If no panic handler is set, the default is to abort the����:7 process, under the principle that panics should not go�|� unobserved.�������;8 If the panic handler itself panics, this will abort the��ȬA> process. To prevent this, wrap the body of your panic handler����.+ in a call to `std::panic::catch_unwind()`.�lȭ���N����N�����ߞ֭�ߞ�����ߞ�����ߞ$���ߞ$��ߞ<��
���ߞ$ݭ�l�{}�ί)tѯ�	�	�������
���$��ϰ6���-* Sets the stack size of the worker threads�Tְ������
���$��T��½&�̱@= **(DEPRECATED)** Suggest to worker threads that they execute����.+ spawned jobs in a "breadth-first" fashion.�IJ��̲?< Typically, when a worker thread is idle or blocked, it will����C@ attempt to execute the job from the *top* of its local deque of��سC@ work (i.e., the job most recently spawned). If this flag is set����96 to true, however, workers will prefer to execute in a��޴DA *breadth-first* fashion -- that is, they will search for jobs at����DA the *bottom* of their local deque. (At present, workers *always*���A> steal from the bottom of other workers' deques, regardless of���� the setting of this flag.)�ٶ���<9 If you think of the tasks as a tree, where a parent task����;8 spawns its children in the tree, then this flag loosely���?< corresponds to doing a breadth-first traversal of the tree,����?< whereas the default would be to do a depth-first traversal.�����;8 **Note that this is an "execution hint".** Rayon's task����>; execution is highly dynamic and the precise order in which����85 independent tasks are executed is not intended to be�|�� guaranteed.�ƺ��κA> This `breadth_first()` method is now deprecated per [RFC #1],����?< and in the future its effect may be removed. Consider using��ػ*' [`scope_fifo()`] for a similar effect.�������]��4use `scope_fifo` and `spawn_fifo` for similar effect���Llɽڬ������
���$۽���#����	�	������
���$�����=����	�	�����ɿ�
���$ο���s���2/ Sets a callback to be invoked on thread start.�������IF The closure is passed the index of the thread on which it is invoked.����JG Note that this same closure may be invoked multiple times in parallel.����JG If this closure panics, the panic will be passed to the panic handler.����A> If that handler returns, then startup will continue normally.�l����ߞ����N��������ߞ��L��ߞ���ß$��՟$���<��
���ߞ$���"l��gi���;����	�	��������
���$�����q���1. Sets a callback to be invoked on thread exit.�������I����Jİ���J�����@= If that handler returns, then the thread will exit normally.�d����ߞ����N���������L����	ß$��՟$���<��
���ߞ$���"d��MO����~����������������[X Creates and return a valid rayon thread pool configuration, but does not initialize it.����~��
����B���6ݦ,���~ި��
�$�����j���<9 Deprecated in favor of `ThreadPoolBuilder::thread_name`.�\���~�u�~�����������u������u�����4����<��
��u$���<��RT���A���<9 Deprecated in favor of `ThreadPoolBuilder::num_threads`.�\���~�~��
�$���
\���������>; Deprecated in favor of `ThreadPoolBuilder::panic_handler`.�l���~�N�~��N��������������������������$�����$����<��
���$���l��wy���6���;8 Deprecated in favor of `ThreadPoolBuilder::stack_size`.�T���~�~��
�$���T�����&���>; Deprecated in favor of `ThreadPoolBuilder::breadth_first`.�l���~�~��
�$�����|���>; Deprecated in favor of `ThreadPoolBuilder::start_handler`.�l���~���~��N���׾�������L���������$����$����<��
���$���"l��ce���z���=: Deprecated in favor of `ThreadPoolBuilder::exit_handler`.�d���~���~��N���׾����L����	��$����$����<��
���$���"d��IK���*d���~�~��
�$������}�����/���}�}��
��	$����� t���	�	�}����
�$�����+������*��������#�}��������\���	�	�}�	����
�$�����24���	�	�}����������������;t����	������
�$�����*�}��_����8���	�	�	�	�}�	�^�^��^��[�^���[����e�S��	������
�$��������F���=: Deprecated in favor of `ThreadPoolBuilder::build_global`.�%use `ThreadPoolBuilder::build_global`����=T�����~��������������������q�aX��
�config�4�����+�#��г������_����8���	�	�	�	���	�^�^��^��[�^���[����e�S��	������
���$�������������������/*�������&����_����8���	�	�	�	���	�^�^��^��[�^���[����e�S��	������
�$��������������������������������lf���]v���������������������������������������lf���]v�ڬ�����������������������������������������������������!�~��_����8���	�	�	�	�~�	�^�^��^��[�^���[����e�S��	������
�$�����t��́������́��
��RD��t��́�������DA Returns `true` if the closure was called from a different thread���� than it was provided from.�D���	�	́����
�$��ܠ
L�
�o�j�ֻ�`B���
,�
���ٮ(#�
H�o��_�!#�	�	�	�	�o�	�^�^��^��[�^���[����e�S��	���#�
�
�,�
����=
L�>
�pȩ���C���t�>
�>
����T�>
�>
�����($�=
I�p��_�!#�	�	�	�	�p�	�^�^��^��[�^���[����e�S��	���$�=
�
�,�=
����J
	L�K
�qE�E�[�U����K
T�K
����o(%�J
J�q��_�!#�	�	�	�	�q�	�^�^��^��[�^���[����e�S��	���%�J
�
�,�J
���S

T�S
�q�M�8ù������S
<�S
���ٮ��S
$�S
����r(&�S
K�q��_�!#�	�
�
�	�q�
�^�^��^��[�^���[����e�S��
���&�S
�
�,�S
���1�=�1�1�1�8�01�p1��1��
�
�����1��
��� 1���d��t:3�K]�.�+'���t(2�R�t��_�!#�
�
�
�
�t�
�^�^��^��[�^���[����e�S��
���2��
�,���83�S�t���!#�t��
��4�<�4��
�
�t���4��
� 4�jV\��������u���<����u�ujVL��u�u��
��uce�����u(5�T�������_�u3�u��_���PR�
�
�
�
�u�
�^�^��^��[�^���[����e�S��
���5��
��u,����6�<�6��
�
�u���6��
��u 6��J�q.bT�����
G�K�a��p:H������K�a��������������K�La�K�a ��f�fStorage��f��f�f��f��,هk�p�?������K�a���������������K�>a�K�a ��p�?�������䮮#T���v�g�q��\Ѯ$Ѯ��� b��i�v(c��j�v���"$�
�
�v�v�c���
�,��(d��k�v��_�"$�
�
�
�
�v�
�^�^��^��[�^���[����e�S��
���d���
�,����He��l�vl�v���57�
�
�
�v�
�v�e���
�L����f��m�v���"�)+.08�:>@�
�
�v�f���
���Pg��n�v���"$�
�
�
�v�
�v����������������;t������Less��������Greater��ji�/޾�g���
�T���*h��o�v���"$�
�
�
�v�
�v���h���
������j�q.b�̼�Ք�J�k�a�ƒ�K�������k�a���������������k�La�k�a ��f�f���f��f�f��f��,هkƒ��k�a���������������k�>a�k�a �ƒ�Ԇ+D���y 9��-����\�$���� ~�z�y(�{�y���!#�
�
�y�y���
�,�[X,����zi
�}x�����z[X5��z��
�,���� ��|�z(��}�z���"$�
�
�z�z����
�,�(��~�z��_�"$�
�
�
�
�z�
�^�^��^��[�^���[����e�S��
������
�,���H���z�z���57�
�
�
�z�
�z����
�L���P����z���#%�
�
�
�z�
�z������
�T�����
5����{�Z����Q����T�������<������8��
��{���#%�{��
�t���ʐ30 Result of [`yield_now()`] or [`yield_local()`].�:,���|F_I65��������D����  Work was found and executed.�:1���|DF���|$����  No available work was found.�:1���|DF���|(���	��|���$&�
�
�|�|�����
�,�� ���	��|(���	��|��_�$&�
�
�
�
�|�
�^�^��^��[�^���[����e�S��
�������
�,����H���	��|��|���8:�
�
�
�|�
�|�����
�L�������	��|���$�+-028�<@B�
�
�|�����
�����-��-*' Error when initializing a thread pool.�<��-�}��aE���<�|�-$�-���}(��-��}��_�#%�
�
�
�
�}�
�^�^��^��[�^���[����e�S��
�����-�
�,�-��t�.=L�.�}P$�q9GyW����������ܲ�}�.=���}���}��.=���}���}�X=�X��
��X�Xܲ�}��ڑ	L�.��ܲ(��.��}��_�#%�
�
�
�
�}�
�^�^��^��[�^���[����e�S��
�����.�
�,�.����=��<TQ Contains the rayon thread pool configuration. Use [`ThreadPoolBuilder`] instead.�Use `ThreadPoolBuilder`���=/>l�>�	�~����fSk��Ԛ><�>�	���~8��=��~���#%�~��
�������GD Provides the calling context to a closure called by `join_context`.�@L��́�h^U�/�}��t��D�������<�������γRҹ��^=x(���	�́��_�%'�
�
�
�
́�
�^�^��^��[�^���[����e�S��
�������
�,�������jz,|y}� �&�,�}1�$7Y�<h�A��F��K�P`�U�Z�4`�4f��k��p�uR�z�U��|���0
����1
� ��q��v��������[
��\
�^�����W������e
��q
�`���r
��s
�����t
�����8����� ��&A�,�2��8��>��D8�J��PC�V��\��b]�h��n]�t�|%���6����;�����������B��7��/��������>��������I��������b����$�
|�����@�"��(ӄ0�6x�<�C�SJ�nQ�yX�z_
fBm��uˋ}���
��������ե�������(������������������������N�����
����V�w�$��,��4��:��B��J��P9�V��\\�b��hF�n��t��z����G��H����^�����������������������D������������c�����#���
���5ƨ
�#��)J�/�5�T<��B�XI@�O�[V��\�^c�in�o�u�l|)��l��M����)���v��v�e}��b��R��R�mP��E�JA�:��9�7��-�G-��,��+�����
�)����#�()��1��9�%?��G��O�$U�#[�#a;$gb"mh"s#yc!i!�"�F �L �!�������v�!�����m�5��������v�|�����	QW��!('.-�3�9�?$E*K�Q�
W�
]�cG
iM
o�u�{��>��	��	�@
������&Wdt��������������������������������lThreadPool::install�crossbeam::scope�	crossbeam�Self::spawn_handler�5https://docs.rs/crossbeam/0.8/crossbeam/fn.scope.html�"std::thread::available_parallelism��0�
yield_local()��B�,��scope_fifo()�	install()�ͦ	ThreadPool::join��K�	std::thread::scope�ThreadPoolBuilder::num_threads�� ��	��	��	�B���spawn()��Jƨ	ͦ	�	Self::build_global�#thenum_threads() method for details���	� ���	���	Ohttps://github.com/rayon-rs/rfcs/blob/main/accepted/rfc0001-scope-scheduling.md���	��	scope()�ߩ	�Jƨ	build_global()���	��	� ���	��	�-�LSelf::build_scoped�RFC #1��	std::thread��join()�«	ߩ	�J��,߫	��	�-���	�Lyield_now()���	��	��	�	ڧ	Ƭ	�0�۬	«	��,�,�߫	�L�-���	ڨ	�K��	��	��	��	ڧ	�Ƭ	���0�۬	��B���	�,�,���	�Kڨ	ThreadPool::spawn_broadcast()�crate::ThreadPool::broadcast�crate::ThreadPool�"crate::ThreadPool::spawn_broadcast�ThreadPool::broadcast()��Bͯ	��	�	��	��	�B��	ͯ	�	���	��	�B*../rayon/slice/trait.ParallelSliceMut.html���	the par_sort method�ݱ	��	ݱ		 ThreadPoolBuilder::spawn_handler�"ThreadPoolBuilder::spawn_handler()��J��	��	�J��	�J���	-�0�.��	�	scope function��KScope::spawn()�Scope::spawn�scope_fifo function�«	��	'crate::ThreadPoolBuilder::breadth_first��-��.crate::ThreadPoolBuilder���	�0�	��	�K��	³	«	ӳ	��	�.��-��	��	�0���	�	��	�K��	³	ӳ	«	��	��	��	��-3crate::scope��spawn_fifo()���	�	�3�"ThreadPoolBuilder::panic_handler()��K'crate::ThreadPoolBuilder::panic_handler�the scope_fifo()function�crate::scope_fifo���Jthe spawnfunction���	crate::spawn�the scope()function���	���	��	�	��	�3Ƕ	�K�	��	��	�Jܷ	��	���	��	��	��	��	��	Ƕ	�	�3�K�	��	��	�Jܷ	��	���	��	���	�crate::in_place_scope�,ThreadPool::current_thread_has_pending_tasks�std::thread::yield_now()�
Self::install�ThreadPool::yield_now()�the in_place_scope() function�ƨ	��	�"the in_place_scope_fifo() function��.
theThreadPool���	ThreadPool::install()��	the scope_fifo() function���	�Jƨ	��	�.�8theThreadPool::current_thread_has_pending_tasks() method���	��	ThreadPoolBuilder::build���	�	the scope() function���	��	�Jƨ	 ThreadPool::current_thread_index��	��	��	���	��	0https://en.wikipedia.org/wiki/Double-ended_queue��	��	�J��,��	�	��	�ThreadPoolBuilder::build()���	+https://en.wikipedia.org/wiki/Work_stealing�ݾ	deque��	�the ThreadPool��,�,���	)https://en.wikipedia.org/wiki/Thread_pool�ȿ	
work-stealing���	ݾ	��	�³	�B�,��,-the ThreadPool::current_thread_index() method���	thread pool���	ȿ	#the num_threads() methodfor details���	��	��	³	��	�B�,��	��	���	��	��	��	��	ScopeFifo::spawn_fifo���	³	�B���	��	��	��	��	+the spawn_fifo() function defined on scopes���	��	std::thread::yield_now���	ThreadPool::yield_now���	��	&the spawn() function defined on scopes���	��	�/Ƭ	��	���	���	��	��	crate::in_place_scope_fifo���	��	�/Һ	Ƭ	��	��	��	��	��	л	��	���	�/���	Һ	Ƭ	���	��	�.л	��	�"��t���������H���������������I�I�I�H�J��������3��������H���������������I�I�I�H�J��������3���`���������H���������������I�I�I�H�J��������3��"��������H���������������I�I�I�H�J��������3P��������H���������������I�I�I�H�J��������3����������H���������������I�I�I�H�J��������34The global thread pool has already been initialized.4:The current thread is already part of another thread pool.:��	��	��w;�d��a�P�l)�^�l���_v56�S��b�|�g�E�I�E`Ϧ����q�'t7���S䋤2�����~��!Q�$��Jo�Z
� ��fy"G�u���N�+𼑬{JG���
m��`��Z��g�A}qDB�B��p��t���g@N��j�J�>:�Sg#=>k�eL@	��Q���oz��#��ܶw�s#Dg-"�{���+��0�:��j��S�wtY�(�vHFa�l����T1dd����PN������К|��3����Lq�4�� x�fQ��?���>hG��p��EL��k����ݨ���|:
�����MG�a���c˳c�Q��O3�g�N�"b[aȡ�\�X�9�SQ
34�����A�D(p��CPn�VH�Wo��|�O72�N�O�@�\�9x�xEٕ�2V-��vS��N���^��c���a�d���L`sC8}M��ʉ��1J�h��i�]qD;�.�ùG�H�u��?¯F���>Y8�xa6�Fi��Rû�<�}kW��8a���>��CTr����+�g�hj���P8�uN��0%lj��ןc��[M�Ow��Z� �=@A&��,��xl�Έc3?4p���@��n��A�<�VҒ��b�6p���VAn��U�m�-06ƉD��&�f�\�BcҢ�x#�j�8�'�Q�3�0��䋄�)�3����G���C�D��XmZA��4-���9� #5��@d�a$�Y�Ė���t^c�!
�S��c"�6֤�g�#i(��O6C�aG��yt��NA���߼��l&EC�����xv���^ua�O�.*��2���ā�v� �I���O�3J�l�quu���,�G�P0\ڒ������01z+��댍g(����f�7�Q��hh��أ��W �L�z�/�&�5/�-֠e�:�s�{��%��fg���-1���p��^*�-\]���34��v}�����<��%P.��%�a�{����K�)�͌O��ڣ:���Ǜ�a�F)��s?�e�<�s�J[bv��a�`��@Ǵ��P2t�X��`%
�G���Q��'K)���i���E$����K_*����H
���\8��V}Y�/1
�vZ��R�u��W<�܁�w���̷/ݴkܓS�DH���wT����,�K*��-�K7�'�.��v����@�~ݝL���Y`��`.
�h�tkmy��g��7��B��	��	������m	b�;�
�P�6��]�s���Hp���p�]bcޮ�K��#a�Rנ{u�h��)��XjZx��$��\�	��9�nZ.��e��HB�:=�y����DޭUF�(E��r�C%;���)&(�L���@yiJ��`�l㌲�:ڄ;';p���f&W;_��=�]���ov�rÓv�II��Yk!������u)�x�%TdpO�m�g~��h�Bǁ5 ���͋������Jhr00�-�������h�{)��|)��.�m+P%��s��H�T�z���7P������Yj&`�R7`x_4��+�r7L�y�j���� f��s�p�l�޻࡛[�N����qR��������<߲f_��eק������
�ԚZʋO#x��T��U�Vnv��XҰIvU���0�ʟ��Yz�v��_c���k��H��±�	�>��}���ٛ��ʽ��5? "_!��
2�L�S�~�WV�j�9�k��vI{�3X�l!s�P���Q��.�i��qe���"�؁c��ј�sT��Fx�!	�K��ο����?ijh�
I���jD��ɷG�cDO$`�HɌ����9˜p�:����Mh\'�v�B�:{��cM�v���8�;����PE)�6��z$�)��j�)�f/a�ހa��!�gdj�E�o󨢲��~^�Nq�d�zT-{%�Qug�I��V�@��Y��U�0�y��݀!pySk�&hc��]�X6#^o;XTVK)�M{��4�XحՈ�~CWO
����@%��#�du��b�/�N��e�n�}g�\�>�1U�{@���U�q��lr���{hd8��+(��SG�����EL��x��+t6ĝl5+<x$��+T=)@�F�@Q|��]�S�c�g�ݪ�����P�l�����.����G��/�i8����aU\�����21�Ս�Y;��g�KҌ�@99����q1�����b �a�����eWQ��)�3��;�*���}�{�ҍgf<��L�����2���q'_�@�o�Z��5.l3�-�C�5��%\P�[e<�h��H��_ɐ��A�������L���aӺ��"i�W��R�C��_���7Q�m�AjZ�R7�U�9G>��2�k���{1��R>��u��t��@f��ĭ��F6D;��hw��w���Z��!��{�(���8��G �5_,����4�z�ƨ/����K��c�3h��^\�T�{I��rNj)Ԟ���	7�3�q��b'���H:S�͊��
��_`w�T����E7�5�����b\>W�4'����ܛbL/�C<��>E�C��)T	�v�I9��M=dH�p臁�Z�r��o��%ͅ�eE���,]KL�F�F�Q$�۞d��e�1Z%1�wj�ۉLG��4Wl~tX��"�+Ƙ���+�����h,�`8[�p�WCz��([E'}W����Ele�z�+�oL7��֋S�W������&~��.���s1Y���xG�Cu鯲"��5���e�э��.3|&|�rR��T�?1�<='`9��GA)��i��S0P��;�ukM�5
�9©@��4�;{ʗߘ�,�y��]���2m.��u�2L�7O��$�ԁ�,��I6���8˨g���!��Fu"e��í���]������[��a�=�Oh�l�H�|7C�沙nI�~��;��e�1����)V7۫��~�9�vՕF�0�m��ne��ă
U�s�ȣq�S̪U_����K���\`K�2qSs���[	T'>�e��k>��^>C�"�
p����џ�_vZg���]A���?l�]�"�޹���#�cC���l�­*I�$?���&��"I$��
�Cd���MD�tS��S\���Ąaڵ��f��ҏރ$��͓8A���Yj|��>?Ba����;[^C��wKu�r����&��Grb'��+�#D>��Tb���Q�8TYe5��F��US��m�*P���Tp��j��_�h�O~G��묖.�3Yn.ìM��ޔJ'��O��>�C:�9��fK��is(چ��i�nS�m�~�J�~.����W�ؒۋ�:��/��r+a1`�O���
�.�(�
��4�a�G)��d
�d���Х��T	�z��U,4g��o��*���2�j��(#r����w�2�������g���Dy,F�ɷ�}�袚Z��Tٿ~G�])����3~%�YS�p��
��ƺ�Nk*=�3:Ä��q�70���7B�g�hP �S����a���'���"�?~P��l��K�У�/@�I�zgc�[�V��"�`����-|��Z�7�x�M��Is�
&X�[׉J���H�Y��#�T�9���B(�`��S�	U�^pD��zv�~ܳ��F��g�7F\���CA��#Ȩ��s�aE��b�ÅDB��t��ԯ'w]@Gj��
�1sw�v԰E�v"�s�[��<u�Q2��U�����A{�l��?	���2�����fjM���<�B���~Tvu��B����̶ё+�;2 ��.�6���{������������D͐�T.ˁ��>�6��}�9�0�i��
�)�f��O�2�3�#��,�8��&>2eN+X@�H_��D}#&}�B9�j�I\������h�~Ӱ�7s^1(3G\Pz�(��DFB�P%�=ܽ�݀��9ƒ����G�oi�j�ֻ0@�g�V/܀86{�w�`��0~^C�)��O�ֶ��5i���䧖xC�Th;��	�e'`ey�w�/��H1�薻GK<k����PG��s��Ā��*o��8�������m���6
(��t~��L��2��5PR>��h~=�0��Gb�/�����_}�I��)��‡�	_1��2ؔ΋�o��L~���e#x���ʹ�����( N���#g���w�#�Z���b��5)��� `yYBK�\�]
P[m�N�|�A��>M��a ����Z�v#p	�s8��C{5H#�Tf�?/�l�U<���*#���x����GF0�F�S���K|��5͋L3xXʍ;^�F�V"����2�GdY�P#�O�ϥ38�V
������\�a���p���*3->L�
�������4��cZ�q�hL�D���'�b}�Ȣ'f��t�)�u[dqm������X�%�'L�i��Z+[]v�\,l����#6%b|��lU�}#Yg�|��E!����;�W�T�:H�_-�G�I>QŚ̾���nW=%�уo6ёU-,�uD��
0��5�&Q�2�W�V׎���qy��5{�Vh��7�
�/� ��ʩ_��V���DZ���?�FH�$F�(�7�
�\�UIm�}Tr��ioXo��rz$�#8ee���tE�:�0v�m�(��{���?��M�0��Q1����IƋCN΀�gZn�Y;_\~0_�2���ΗU�$gRBD'8�>q-���v_=�����	���>�n��I.����~炅6ѝ��MFƙk+�B�K�:̦AԸ�;'W�g'���0'���m��ǕWt�������� �@ܰ�X�й�$�-|�Vwܜ��!
m`��9�<4tΈo�k*a�$^�xL
5�ˡC��>���t/��w���ٿ�G�b�~e�nF��֢��{yn�(Z3DWf
t���a�#J��g���(W�|��xQ��C����	xKQ{��,͇R9�C���s4�-� #�*���������iWs��R_W�o������#�>��p�u��Ti�sS�<p'�`��B�w�H�Q�i��M�r.���TE�
�`7w�ĵ0��Qt-��=l�y���ҵ�N�����ds�1�)�P�v�
|`��8���d�	B=�L7���]%$�� �@�7xJ��
�R�nE]��~���p%���I֟j�xNk.�z4yA4[�g�bQ����}���w�z���q�ڵ����vfe]	�^���lX����Ԛ@�lJ���"���sY���\����"�ā��=�מe}"3C$�����h1Ѐ�r�x6ryX>�@淤������&�O�l��b�g���f��ë	�?ۻr{\�#N'jD]�R�}r�<1�"(�x����Dx+Q��{���j���&��AT[����:�;�T�z(�B�艸~i,���=�F%k	0�B�r
K�iEk����e�$��Z��a$uT��ʅ�;��aT�Y�i%�<6�%�g>���fCn���=9TWodYb�0'u'��%3C�丑�V_J�T�Ⴘ��b;l�!ç=Čj�1��#$�����z�����_�^\�(fƢ!�A����eo�>.Yӯ�{¹&
�F?d��7����dɢsKN�OrxtP"�B$�v��X��Qʼn4���՛kP���/�?9�~7��*��4�e���F}o�e�
�E�����6�v�������z	D�{Ԥ�����5Vא{���7A��9�X6������?�=P\uL�r�h��csQ6]5�-0���t� �ҙv#)��'$�ת\���U�0��ۘp��p��b�˸c��7Y��CF�9���J�d�h��׈�{pD-��$��}i�17�
��qC«ͥ�E�8�r;����̵��b���ϖ"�J�dty=���wԚ��!�6F��}�Y�y���T��LE�;�\���ʣ���oQ����k���Ay��߄WJ��%�pF�	B�\�Ju;`��~�CrHH��_������g�9��>O�E�����R]̩��$��4n��o�-����c�o�:���v!(&��t�G�R�i/xQ�痢��A(-����>���=pΚK�C���b��Qj�]�-Z-��������z/&VO  �U�A�����,}�dk
Ai�\3o,|W*��j��q�xz�I�u'ʡ{MڤV�B�6�,�EC˳7��a��ՙ[���S�R3�u��
���7���Z��p�~��E���gj��s��}N#�"�(	��,��p;3�l�/�����Lp��"l�qPcc�̄n�٢+M�{IQ�x:	�2#!
�%��]���^�;�H�φ�+޴W��s��4�v9~��ڄ��H�q�bOH���v��5��޾C�:�s��ݧ`LQ���}*B6�y�~aD���`x�5�Ҩ�ÿX�"����D�J� ;�6w��;#�+��5�����Dj�`G/l��v]�It��|ġz7�0Ă)�r����Q!��q b��w���ʓ�g
��t8�^
8u���3��rY����q�d�ȫJ�I��`G�z�.G�>���\�{	�[Hk��4������AY���[�X
au3xRcB�<�L����.4sm'�q7�h�������W:$c��5�͸)�]����-��_	����u�L�nD<.	���{�iz�)P����@w��6�>�?���%�c'tl%��⣸�ִjb�Ã
gneB�� \��JF���������_S�rX�OR�G�;���
�E��Y��)�G��.8�����I�6M�bY`_�}����`�Iu�ę\1ά9p�ì�"�C&~���Z5�ۊp�[���+�}j���\~pg�+;��s�/�^B:3+�������
oq��Ϟ�s�g�_�%0����*��ZDR%�Xp�FF%��'�2
Fi�l��s�F�K�)H�b��✹�n�R�WO���|a#u��.Qu�b����A]��s��S�6���� `ا@�&-7�|�@Q#��*�e�!��+�� ;��ɯ z��c�����
�(�z�l��J�1����2���q.�?�f�ڵ4}{gk���*�,��Βi�"ˬ,��Mڭ��]Ų췻�f.A�h���ڹ�:��yOSh�տ� I|߾���H�#�;�4󸮷 g6���s*(9���(.K����P%�5�5��=q���	��IT�r#��C!c�r�81�bI�y�8n	�ǝ��j���5�?�g��3j~`�'��3"�w#<L�I/��+�5$����.g�����4�#u]8��c��!�$�Khc��I,&/.;��1���'�	
���R�~�bP�2a�gIv�:��ZE�	sF�QU=)}4B�=�C�wi��oE����-�p]y���#o�G��@�ۄJH���>�V �R%�ϻТ�����!h_!��Y�
3E5���Z�/����i�����Ĕ)��\`��pnDB�lO�v��+�د�^�����V)�j�
��|6���M$�U|Mл��dSk�*��"x����xhb����?���w Mk�f�;�`V@��8D��.B�hߝ���.s#�p��������q?hLfdy�sC�H\��e5���ռ��Rb*��Q�
�v��W���B�[ݮД�Gm��:�u"�bw9]�:�_9�m�?(s���s�C����EXL�m��8��*���)My?�M���P�>�¸{ٱ�$��΀���ͱT��e��A
�/%�eI�!�4b�o��Ii�)a�� _A�и.�j���0=$�n4�����L��X����DҷўQ��٩\g�P�hf�_��+��U��
*!z'R#���[��-��K�Ш	��&�/��&˻���X*��x*g�9��ue�F�od�#���E��e��F����*w��E�o.x�*&9�+�#3���p����	�'��W��*�O��0��4!��ՠ�K*Z�?8vU
�%[�*�_��:�\b}����R�6r�秈�x�X^����r�m����h'GէN��6";(�ς�����ߦ���d\���c&��p�ʡ�W�+�-z$b���CEx��&'"嵱k�7MbⓈ��8�A���ǿh,*�[������/S��������F���9y3W����9�*�О�]{�E`�Ht�eܫ�yR
�TzQ�����,��ҔA)^�z8���w8��pU�)#=���?��wg�����@?��Jơռ���k�h�_b���W&�SX6�`
�oşs�3�gL��C��-��T�
%$S��vHٟ�Dx�n}pO\��1vV���v��ν)����8���%����G�<�VSC�����b��.F�
��w�g����HN��H�&g��
�Xd@0�5
����dOsC6Ѐ�@��8��`�]����R�X�D] �Ϧ���ہ��U���(,R���椫Υ��.��-"�5ԷÝ��žtΕ�mEr�T.�x�B
"���$C��p��R�o|&���E�2B���R�����B#� Ʒ�P*�#��T�.����"# �&�B���q���F�Ą,j����[���*ZX��`B�1�ix���
X誈ִ�w�����Z������Y��G�I��:�y�]D#��l�����#r0�[����|<� �^�[&8R�틀�%�sh��x�6�>r.�����i"�e�G���A�Pq=�8��ï��X��^�x�;��(��0`��q���u�g�#�Ѽ6�����5�{���,?+gk�����^lp�P���Hv@ց�a��u�.N���p��H[�w��ܿz�-��Ȓq�G�0׺���w+�Nw|�����S����3���rP��T�+��7���)�UQ��A�v�#��"�Q�.A�'9��q�`��V$eA������}�6�������cm$���X����Z�e�,<.#S�HT�#��j?mRo�v}0�k�ʗ�<�K���o��:�ŪѲgJx����q��8i�c��aF&���L�#����#o�����s�:�*�? C�g���T��g�(�<�L
k$�U-�o
[SS�	!#M��Z比Mn�f+�7>~u�/(��ۍ/���v��@b�9(�����_��4*����F�Yy�u@5=�Y"�Ƌ�`�Y���t�o#�Pʄ�Y��dK���(��jiC>��t�L�M#�۱�=��0���*�9�|h����̷�O^f(�U06�)˥(-��n�x1��@��MM���N�d�L����[62��q���"ᑥ��|������B�s:-�<5@���2[�̢—)�!k92�f2�&O��f��|�):�%���M��
�Fo����8�r>,�,����[�nD{��f�CTpMC˼�l�a�eA�s@�="��Sy�[��)�6�I�^����f�>{��8cd����k���tQ�6ϡ��ǂڽ�q�zX��ݚ��
�(Q�:D����D�T��Eϳ�9S�9i��p��8�ҏc�^��l��7��g�τݽ���lT�����gN���]�\��@g,<��߀)=BX�,A�Y3!�I�˘�	M�7aJ��ż�[U�-�{GG��q&����H�ե�Ң�硊 �q��3SS�0.��»NME�[��+3
,�)�������^�{��bk�k%s�6?h��dE�iTy��*<�� ������(ܽ�9���aF�Uz<�h�O�lf�7ì_�8X8x�`c
K��zLB���0��E��}��N��[�AZ4my�ܷ�Fɘr�^*�	���9��%o�{�^Nh��r��;�gE�
�+M{(1SL>��m��LVeht><`g
<��iE�#��RC�N9犌
&%F�	|-�!���2^�S�5F��e�$�˭��9y���'��o���r5���Vh$m@p�=�qt��@&Pr r+P.���uet5��dr��Dn��S���p�jS	�P��V�?��c��(�r�v<&�
R����U���M�i��H�N}!ƛݒ��$PIu{��z�t>��H��x��>R�z1jF��D���V/��-�HM�t ���L��:��[�_E�ʡ�!B|�n�c$�&v���t���H���Qx�:k-�xϒg���;�)h��D:�D00�	/톞_C�co���F݉�Rl
b���,~��8h��6���F�P0�(;�?�I6n��oG�!�A\�$r�����o��y�rH_DL[Ԩ�e�z�#�O����	�n\��|�[�_
q�$4��i�,����jЫĵ�g�d�k�1W␮�
9
�dq�6� �j�Ò���Y:i��Cy��c�L��0p�@����ys@\�I0�����XT,aԆ�X�m-�x��D����cm���p�O��r�!v��-�Ҟ̬�);@��	!O�V��+Nz�dF��kϫ���+B��1/b�L0������ї��_����	�
x�N��,
�O��-���#Xq�<��Q��_�R/6-�ag�������D������~��w������O������U��SSSS	S
S
SSSSS!S#S%S'S)S+S-S1S5S7S9S;SSSSSS3S/SESCSGSv$j�
o����v
��$���	fgy�!��7[8mFm�mo�o�	p�t�w$xAx�x�x�y�zJ|v|�}�~SB�����y�������k������f�}����F�`���������.�����1���U��X���
�R��M�����@����O�����`�y���a����u��������I�t�����&��������Q���0������f�����m�T�}����j�������
��B�y����l������o�	�$�G�b�|�����C�����&�O�������9��������7������T�o����������������~��q� �=���<�W���������'�@����M���#����z�����������Q��"���,����b���*�n���*�d��]�z��������
�~���
�����N���?�����o������]���?����������R�
�]���$�w��������e�����Y����g����������(�m���������d���������S����E�����L����d����f������A�����Y����f���*������������_�{�����;������J�&�B������K�g�'�4'�'CN(�67�7;L<�<�=fA�BCMCP4D�LzM�MwP�PCQ�QRS~
S�UVV�V+X�X�XVY�Y�ZI[�\�]�^�_s`ua�a@brb.c`cd�d�de[e�e�e�fXg�g�g�ghCh�h�h�h�h�hi)i>iSihi�i�i�j!kvkCl�l�lIm�m�m�m2nrn�n�n2oro�oVp�p
q)q�q�q�q�qrrMr�r�rXs�s�tu�u2v�vw�w�wEx]x�xy3zO�������P���P����S���nE�;��*��
�����U�E�����	��x�Y�X���0�n��������8���,����
��������K�g�������������
��$���������������������'�@�U�j���������x�q��}��%�)�������V���M������q���
X�����A��K��y��Km�� �!r"�"�"#d#~#�#�#$�$�$�%�&�&�'�'(�(�)l*�*6+T+,,`,v,>-i-�-�-P.}.�.�.�.�/�/�/�/�0�0�0�01�1G2�2�2d3�3�3	4�4�45�56*6h6�617�7�7�78898�8�8Z9m9�9�9:�:�:�;�;8<N<�<�<O=�=�=�=>->K>�>?#?:?X?�?�?w@�@�@A/A�A�A�A�ABQB�B5C�C�CD.DMD�DE2E�E�E+F�F�F�FpG�GHEH�H�H�H�I2JUJtJ�J'KBK�K�KGj@m�o��������\
���[�:�U����fgy��������������� �-��B�G�mx�xa|�������@���������������'���N���X���n�������]�+��������>���������C�N����,�!���������
��������P�����������������l������6C�QpYYbGc]deHee�g�gui�m~o|p�q#rRx�����'��W��	�����X���>��
�"�#�$�&�'(B+,m,c-�-u.�.�/�/�01n2�2t3I4�4�78+8�8j9}9:�:�;�='>=>�>3?J?�?�@�@!A�AB�B�B�C&D?DE$E�E�F�F�G�G�G�H,JfJK�K&))(''




 %%









&

&&%



%(((('Fj>mLm�m�mo�oHs�v�w(xEx�xHz
|�|�}'�����o�����ۅ���C�h����!�J�d�ЇC�ވ��5����m�Ȍ��S�ێU�؏����d��v�͒����O�x��;����#��b�ĭ{���Z������ϴ����W���ߵ/���Ķ1�u�
�(�K�f����X�ڹd�Ǻ��N����L�Ӽ�X�s�����Ž�*�����4���R���@�[���+�U��S���'����~�������#����7���A��?���0�h��a�~� �������"�������c�����<�q���r����� ����g��r���9���$�������o����n���������>�t��������"�i����"�[��b����z���&�|�-��W�o����|�������������Q���������*�F������O�k�A&�54:;�<�@|AcC�KQO,R�T
W�Y_[�\�^�_�`�a�a�bvc dd�d�e�eg]g�g�ghXh�h�h�h�hii-iBiWi�i�i�j6k�kXl�lm^m�mnGn�n�noGo�o\p�pq/q�q�q�q�qrbrsms�s�tu�uGv�v,w�w�wrx�x	yσd���e��˒��ғ��h�f�L�c�ճ
����g�e�!���y��s���M����e����������5�|��������������*�����Q���������������+�D�Y�n���X�����������c��Q�&n��L��WBX�%��\ � �!�"�"%#j#�#�#2$�$#&'�'�'3(j+4,-D-m-�-V.�.�.�.�/�/�/�0�0�0'12M2�2�2�3�34j4�45�5606�6�7�7�7L8�8�9A:�:�;=<T<�<�=�=�=^>�>�>
?k?�?�@BA�A�A�A1B�B�BCcC�C�C`DEE�EdF�F�FvG�G�G	H0HJHvH�H�HJ6J�J�J,KGK�K�[�l�l�lm
mmmm&m-m4mBm�m�mo�o�p�p�p�p�p�p�p�p�p�p�p�p�p�t�t�t�w�wx x?x�x�x�x�y�y�y�zE|k|q|�}�~�~�~O>������u�҂��j�o�t�x�|�����������Z�g�����ą���,�b�y�φ�B�[�}��������)�{�Ĉ������-���P�ً���S����M�֍�����H�Ǝӎ�.�;�����J�����ߐO�\�t�đё\����c�p����������E�p�Օ�!�������������������������������Ǩ������,�z�v���������q�~����a��������g�P�F�K�P�T�X�\�a�e�i�m�q�u�y�˳�e�Ǵܴ���>�t�ŵ�g������j���� �C�^�x�������>�����"�J������5��������1������P�k�������ؽ����ݾy��l��8�{�%�+�8�U�������~������#�<�������I�����������������������������������������������%�+�1�8�?�D�J�P�W�^�e�j�p�v�z�����������v������������M�����'����^����%�i�����&�`��X�u���������z���	�������H�����;�����&�e�k��������W�����;����������M����X����r�
�����������������`���������S����b����������"�h����������_�}�������N����?�����F�����^���
�`�������;�����S�����`���%����������������Z�v�����5������������������������������������������������
�����F��"�>���������F�b�"''#'0'�'>(}6�6�6�67�7�:�:�:�:(<.<;<H<�<�=>AEARA_A�B�B�B�BC@CGCJD�L�LuM�MbPrP�P>Q�Q	RRSxS�U�UQV�VX&X�X�XQY�Y�Y�ZC[�\�\�]�]�^�_�_�_``m`Uabaoa�a:beblb(cScZcdid�d�d�deeIeVe�e�e�e�f�f�f�f�f�f�f�fHgLgPgTg�g�g�g�g>h}h�h�h�h�hi%i:iOidi�i�i�jkpk1l>l�l�lDm�m�m�m-nmn�n�n-omo�o:pApFpLpRp�p	q%q�q�q�q�q�qrHr�r�rSs�s�t�tu�u�u-v�vw{w�wAxYx�x�x�y�y�y�y�yz=�J�ۄ�z����>�K�܊�ɌΌՌی���������
����!�%�)�-�2�6�:�@�F�L��
�N���\�i��*�7���a�n�{�����O�
��'�4�A����������������s�4�:�G�T�3�9�F�S������+�\�i��������3���&���{�
��������������������� �G�c��������������� �-�2�8�>�D�I�O�U�\�a�g�m�s�x�~��������������������������������������������������������#�<�Q�f�{�������s�_�l���y�������%������r������G���	���k����R������;���E���s���DZg�� w!�!_"l"�"�"	#^#x#�#�#$�$�$�%�&�&�&�'�'�'(�(�)g*�*0+N+,,[,q,:-e-�-�-L.y.�.�.�.|/�/�/�/�0�0�0�01�1C2n2�2�2_3�3�34T4�4�4�4�45�5
6'6=6b6�6+7{7�7�7�7878�8�8T9k9�9�9:{:�:�;�;1<K<b<�<�<I=�=�=�=>(>I>�>�>??4?V?�?�?q@�@�@
A-A�A�A�A�ABLB�B
C0CtC�C�CD'DKD�DE0E�E�E&F�F�F�FlG�G�GHHBH_H�H�H�H|I.JOJrJ�J"K=K�K�KTLYL_LeLjLoLtLzL�L�L�L�L�L�L�L�L�L�L�L�L�L�L�L�L�L�L�L�L�L�L�L�L�LMM
MMMM#M(M-M3M9M>MDMJMOMUM[MaMgMmMtM{M�M�M�M�M�M�M�M�M�M�M�M�M�M�M�M�M�M�M�M�MNN
NNNN%N+N1N7N=NCNINQNWN_NeNkNqNwN}N�N�N�N�N�N�N�N�N�N�N�N�N�N�N�N�N�N�NO
OOO!O)O/O7O?OEOKOSOYO_OeOmOsOyOO�O�O�O�O�O�O�O�O�O�O�O�O�O�O�O�O�O�O�OP	PPPP#P)P/P5P;PAPGPMPSPYP_PePkPrPxP~P�P�P�P�P�P�P�P�P�P�P�P�P�P�P�P�P�P�P�P�PQ	QQQQ"Q(Q.Q4Q:Q@QFQLQRQXQ`QhQnQvQ~Q�Q�Q�Q�Q�Q�Q�Q�Q�Q�Q�Q�Q�Q�Q�Q�Q�Q�Q�Q�QR
RRRR"R(R.R4R:R@RFRLRRRXR^RdRjRpRvR|R�R�R�R�R�R�R�R�R�R�R�R�R�R�R�R�R�R�R�R�R�RS�lmmmmm#m*m1m:mHm�m�mo�o�p�p�p�p�p�p�p�p�p3s�t�t�v�w�wx$xAx�x�x�y�y3z�{o|v|�}�~�~����m�r�z�~�����������\�m�����Dž���/�f��Ԇ�F�`����.�Ɉ�����
��1���ۋ����X���
�؍���O�Ȏ׎0�@�Ï������Q�`�Ƒ֑a���e�u�������K�t��&���������������������������̨����M�x���������s���f���m�V�I�N�V�Z�_�g�k�s�w��г�j�˴���
�B�y�ʵ�l����q��	�$�G�b�������C�ŹO����9����7����V�o�����ýܽ��~��q�=���)�-�<�W��������'�@����O���������������������������������������"�(�.�5�<�G�M�T�[�b�m�s�}�������#����z�����n�����"���,���*�����,�d��]�z��������
�~�������N�������)�i�o�����]������������R���
�]���$�w����������������������Y����i���������(�o���������d������E���L����d����f�����A�Y����f������������{�����;������������������������������������������������ �&�B��������K�g�,&''%'�5�6�6�6:�:�:�:;,<0<=<�<w@CAGATAfA�B�B�BECMC�K�L;OdPRR�T�U�VX�Y�YI[�\�\�]�^�_�_�_b`s`Wadaua�ajbrbXc`cdld�d�d
eKe�e�e�e�f�f�f�f�f�f�fNgRgZg�g�ghCh�h�h�h�h�hi)i>iSi�i�i�j!kvk3lCl�l�lIm�m�m2nrn�n�n2o�o>pIpOpXp�p
q+q�q�q�q�qrMr�rXs�s�t�tu�u�u2v�vw�w�w]x�xy�y�y�yz��?�O�݄�|�щ@�P�ފ�ь،ߌ����������'�+�4�8�>�D�J�ǒ�����^�S��,�Q�c�p�7�N�������)�6���������������R�8�<�I�P�7�;�H������ �d�^���^���8�����O����������������������"�g��������������&�5�;�A�L�R�Y�d�j�p�{���������������������������������M�����������������'�@�U�j���C�a�����}��
��t�������M�q;��X���6��A,���B����\�F � y!�!a"r"�"#d#~#�#$�$
&�&�&�'�'(T+,�,@-i-�-R.}.�.�.�/�/�/�0�0�01�1I2p2�2�3�34W4�4�4�45�56*6�6�7�7�798�8�9.:�:�;8<N<�<�=�=�=K>�>�>?X?�?�@/A�A�A�AB�B�BCaCvC�CMD2E�E`F�F�FrG�G�GHHGHbH�H�HJ2JtJ�J'KBK�KXL]LcLhLmLrLxL~L�L�L�L�L�L�L�L�L�L�L�L�L�L�L�L�L�L�L�L�L�L�L�L�LMMMMMM!M&M+M1M7M<MBMHMMMSMXM^MdMjMqMxM~M�M�M�M�M�M�M�M�M�M�M�M�M�M�M�M�M�M�M�M�MN
NNNN"N(N.N4N:N@NFNNNTN\NbNhNnNtNzN�N�N�N�N�N�N�N�N�N�N�N�N�N�N�N�N�N�NO
OOOO&O,O4O<OBOHOPOVO\ObOjOpOvO|O�O�O�O�O�O�O�O�O�O�O�O�O�O�O�O�O�O�O�O�OPPPP P&P,P2P8P>PDPJPPPVP\PbPhPoPuP{P�P�P�P�P�P�P�P�P�P�P�P�P�P�P�P�P�P�P�P�PQQ
QQQQ%Q+Q1Q7Q=QCQIQOQUQ]QeQkQsQ{Q�Q�Q�Q�Q�Q�Q�Q�Q�Q�Q�Q�Q�Q�Q�Q�Q�Q�Q�Q�QRR
RRRR%R+R1R7R=RCRIRORUR[RaRgRmRsRyRR�R�R�R�R�R�R�R�R�R�R�R�R�R�R�R�R�R�R�R�R�RSӓ�$&J8JSm�m�s�t�t�v�w�w2xOx�xy�y�ynz0|]|}}�}�~�~)���]��R������d�y�������	�!�Y�r�����)�T�n��������&�l����=�����'�?�ʊ�������2���ߌ5��������.�i�Ў��8����.�d���ː��Y�n���ΑH�����.�m���ѓ�5���ܔ1�W�����d���Ζ��������Ĩ$�������r������������{�����Y�������۰)������4���ش����'�j����V�����Y����4�W�r���ݸ&������:�{���ٺ$�u���ѻ�'�z����(�d������ѽ����̾b��[��(�h���5�L�g�����d������� �5�������.���3����������	�����<���
���������E�����"�T�����
�8�t��m���,�������+����O�M����������������S�}���������������������<����G�����a���a���*�����;�����(���@�����6�����G�w���������U�|��������.�u�������<�����5�q���4�����C�����N����g���)�����>�����E�����l������G�������'�g�����#�}������6�R������[�w��& '-'v'�'6�6�6�6G7s:�:�:�;8<E<�<�=�@OA\AB�B�B�B2C'D2L�L$M�M�OlP�PQ�Q�Q�RZS*U�UV�VHW XmX�X6YkYqZ�Z
\�\f]�](^\_�_�_!`j`a_ala�a"bUbcCc�c9d�d�d�d�de2eSere�e�efg�g�g�g-hlh�h�h�h�hi!i6iKi`ipi�ivj�j_k�k;l�l�l*mrm�m�mn\n�n�no\ozo!pdp�pq7q�q�q�q�qrrwr�r:s�s!t�t�t|u�uvrv�vXw�w(xMx�x�x�G����:���ͅ�H����Ғ����6�f���'�4�}���k�x�r���>�z��$�1�>����������h����U���D�Q���C�P�Z�����(���f�u������#������t��S��������@�S�������h����������������6�L�a�v�������i�C�i���d���-���"�k�7���1�|�|���1�����P���S�y��<���d�%�k�/E��i�J�)�d�o !�!
"i"�"�"�"L#r#�#�#$�$�$r%�&�&�&�'�'�'(�()�)�*+>+�+,H,h,(-L-y-�-5.^.�.�.�.e/�/�/�/v0�0�0�01�1-2T2�2�2H3p3�3�3&4�4�4�4�45�5�5"696X6�6�6s7�7�7�78'8t8�8<9f9y9�9:i:�:�;�;<F<]<}<�<�<�=�=�=>#>9>�>�>�>?/?F?�?�?Z@�@�@�@A|A�A�A�ABBB�BC)CmC�C�C�C"D;D�DE E~E�EFkF�F�FUG~G�G�GH;HUH�H�H�HeIJHJbJ�JK7KRK�K<LMm�m�s�t�t�v�w�w*xGx�x�x�y�ybz$|L|q}�}�~�~�~dS���F��&������^�q��������Q�j�����#�L�f�������݇ �`����������7�ŠW�݋���*���׌-�T�ڍ��&�V�ʎݎ�2����&�Q���Ð�S�f�{�ȑ@�����g�����������(�Q�z�ە�W���ŖC����������������A�u�z��������u�����(���������������� ���Ҵ����!�a�����I���ݶ�L�x��+�N�i�~�Ը�s�����(�r���к�h���Ȼ��m�����"�[�v�����Ƚ�����ƾU��N���"�_���/�C�^�����W��������,�z�����%���*���������������/������������8�s����K�p�����2�k��d���#�������%������8�����q�����P�����J�t������������P���������/�����:�����T���E����������������v�����������9�q����������L�v��������%�l�������.�d���,�h���&�|���5�����@����Y����s���
�����7�����;�������#��������a������o�������-�I������R�n�Q&'''E'�'�5�6�6�67B:�:�:;2<?<]<y=�@IAVA�A�B�B�BCDL�L�L�MoOfP�P�PTQ�Q�R)S
U�U�UgV+WX<X�XYXYcZ�Z�[�\I]�]�]0_�_�_	`d`�`Yafa�abBb�b0c�c$d�d�d�d�deeMe]e�e�e`g�g�g�g$hch�h�h�h�hii0iEiZiji�iij�jRk�k5ltl�lmlm�m�mnSn�n�noSotop^p�pq1q�q�q�q�qrrnr�r-s�st�t�t`u�uvev�vKw�wxGx�x�xڃA���߄!�~����B�����̒���}��`���!�.�L���e�r�e�}�1�1���+�8�V���������0����$���>�K���=�J�>�����"���`�h�������������n��/���������7�M�������S�����������������-�F�[�p�������`�.�c���[�������:�����v�d���#�������"�a��3����[�tS�!-��`�2� �^�f � {!�!c"�"�"�">#l#�#�#�#�$�$d%�&�&�&t'�'�'(�(�(�)}*�*8+�+
,?,b,-F-p-�-'.X.�.�.�.W/�/�/�/h0�0�0�0�0�12N2�2�2:3j3�3�34w4�4�4�4�4�5�5636@6y6�6B7�7�7�7
8!8e8�8-9`9s9�9�9Z:�:�;�;
<@<W<e<�<�<`=�=�=>>3>w>�>�>
?)?@?�?�?K@}@�@�@AmA�A�A�AB9B�B�B CdC�C�C�CD5D�DEEnE�EFeF�F�FFGxG�G�GH2HLH�H�H�HVIJ?J\J�JK.KIK�K,LUm�mntqwx6xSx�x�yrz4|_|�}�~-�����V����Ȅ}�������
�%�_�v��+�X�r��������p�����Չ+�C�Ί΋6����9�ˍ2����%����<���ϐ8�r���L����V���ۓu��6�Y�����i���Ӗa�q���w�O�L���^�ܯ!��.�����ڴ���)�o���
�[����	�^����9�\�w����+������<������)�z���ֻ�,����	�*�i�������ֽ����ξg��`��*�m���Q�l���i����:�����3���8��� ������������A����������J����Y����:�y� �r���1�������-����T�p�����!�������Z��������������������A���L�����f���������-�����;�����L�y�������	��Z�~��������3�z�������A�����:�v���9�����H�����S���l���.�����C�����J����q����������,�i�����(��������;�W������`�|��&{'�'b6�6L7�:<�<�="AmB�B4C,D�L)M�MAP�P Q�Q�Q�R_S�UV�V�WrX�X;YmYvZ�Zj\�]-^�_>`0a�a'bWbcEc�cDd�d�deFe}e�ehg�g�g�g2hqh�h�h�h�hi#i8iMibiri�i{j�jdkl�l�l/mtm�m�m nan�n�n!oao|o&pfp�p"q9q�q�q�q�qr r|r�r?s�s^t�t�uvwv�v]w�w-xOx�x�x-�Äb�҅.�ĊԒ����K����D�w���C�ߵ��]��ͺZ������C�z������%���!���v�������E�U�������r��������������� �;�N�c�x�������n�U���i�����p�<���;���6�����U���X���A�q�i�*��4}�n��.@�t ]!E"�"�"�"Q#t#�#�#	$�$�$w%�&�&�'�'�'(�()�)�*+@+�+,M,j,--N-~-�-:.`.�.�.�.j/�/�/�/{0�0�0�01�122V2�2�2M3r3�3�304�4�4�4�5�5$6;6]6�6�6x7�7�7�78)8y8�8A9h9{9�9:n:�:�;�;<H<_<�<�<�<�=�=�=>%>;>�>�>�>?1?H?�?�?_@�@�@�@A�A�A�A�ABGB�BC.CrC�C�CD$D=D�DE"E�E�EFmF�F�FZG�G�G�GH@HZH�H�H�HjIJMJdJ�JK<KWK�KALMm�mIs�v�w�xIz|�|�})�������E���#���E�����
��o���!��U�W����������x�������Q��=���$�����c�����~��������Z�����1�����3�w����Z���f�����P����N���"�+�����6���T�����V������$����8�B��A���2�����f�����?���t�����"����i�!�t���<���&�������q����q�A�v����$�^��d����|���)�~�0��Z�q��������������T�������B&�55:;�<�@~AfC�KRO/R�TW�Yb[�\�^�_�`�a�a�bwc#d�d�e`gh[h�h�i�i�j9k�k[l�lmam�m	nJn�n�n
oJo�o^p1qdrsos�s�t u�uIv�v/w�wxux�x��f����g�������i�g�M�d�������h�f�"���z��t���N����f���������7�}�����R���Y�����������e��R�'p��M��YCY�&��] � �!�"�"'#�#3$�$+&'�'�'4(k+6,-F-�-X.�.�/�/�0(12N2�2�2�3�34m45�5�7M8�8�9B:�:�;�=_>�>�>l?�?�@CA�A2B�B C�C�CaDFE�EeF�FxG�G2HxH�HJ�JK�KKs�v�xJz|�|�}*��ޅ�F��ӇE����r�͌$��X�ۏ����y�В�����=���(��g�ɭ�������Z����1���ƶ3�ø�[�ݹg�ɺ��P����N�ռ+�����6���T���X����$����8�C��B�������g����@���u�����"����j�!�t���<���'�������q����A����$�^��d����|���)��0��Z�q������������T�E&�58:;�<�@�AgC�KTO0R�TW�Yd[�\�^�_�`�a�a�bxc_d�d�eh[h�h�i�i�j9k�k[l�lmam�m	nJn�n�n
oJo�odrsos�s�t!u�uIv�v/w�wxux�xуg���h�ړÔk�i�M�d�ֳ����k�i�#���{��t���N����f�������}�������Y����������f��T�(q��N��ZEY�'��] � �!�"�"'#�#3$�$+&'4(k+6,-�-�.�/(12�2�3�3K4n45�5M8�8�9B:�:�;_>�>�>l?�?�@CA2B�CaDFE�E�F�GxH�H�J�K�m7s�v�x7z�{z|�}�~SB�����y�ւ��ʅ2�؆��2�͈	�\�����D�Ǐ���ڑe���y�����
���*����Ш0�Q����j����q�Գn�F�}�ε�p��� �����G�ɹS����=����;�¼����#�u�A���D��r�����&�0��b�.��������
�����R���?���+���a���?���������V��a���(�{��������e�����^����-����S��J�����Q����i����k������F�����^���
�k���*��������������@�0&4'�'�5�67#:	;L<�<|@kA�BRC�K�LzM@OwP�PCQRS�T�UVV�V+X�X�X�Y�ZN[�\�]�^�_x`za�awbecnd�ehGh�h�i�i�j%k{kGl�l�lMm�m�m6nvn�n�n6o�oQr�r�r\s�s�tu�u6v�vw�w�wax�x��S����ՉT�����W�;�U�;�R�ij��E�������V�T����h���b���<�����T�������$�k�������G�������)���������R������v@�]��;��F1�G���K � �!w"�"#�#!$�$&�&�'"(�(�)l*�*Y+#,�,�-�.�/1�1r2�2�3�3Y4	5�5h6�617�7;8�8�90:�:�;�<�<O=�=M>�>Z?�?�@1A BCxC�COD4E�E�F�GHeH�HvJ�K�5�56'6|6�6�6I7S7�7�788�8�8�8;9E9O9�9=:G:;y;�;�;<B<�<E=y=�=�>l?v?�?@=@7�78B8�9�9�9�:�:�:�:�:�:�:�:L<�<�<�<�<�<�<�<=�=�=�=�=�=�=!>T>�>G@�t�t�w�y�y�~�~�f�(�������������Ҏ:���[�Бo����������ƨ������������}�����
�7�����"���$�����������������������������"'/'�6�6�:�::<G<QA^A�B�B�LnP�U"X�\�]�_�_l`aana�deUe�e=l�t�uI����J��h�)�6�m�z��&�3�@�������F�S�E�R���*�h�������k�
��$�~��������f�!k"�&�45U�U�B(C~C�C*D�VXDL�LM�M�NYO�PQ�Q�R(S�SsThVE�FDG�H4J�JYX�X�UgV'C}C�C)D~EXXX�LM�M�NXO�PQ�Q�R'S�SrTU�V�FCG�H3J�JCL�XY�]�޺X��d�4�>�H CvC�C"D�L�L�M�NQO�PQ�Q�RS�S6T�T�F<G�H,J�J<L$CzC�C&D�LM�M�NUO�PQ�Q�R#S�S:T�T�F@G�H0J�J@Lztyw�y|z>|�}�~����t���C�����F�?�����C���T���	�����>�!�n���v�~�d�Y�������t����`�����c���6��������.����1������l�
�e��r�v���@�����F�������O�a��	�y���������������F���Q����k��������������Q�_���F�?�{�>�����M����X���q�3�������O���������-���'t6�:<�=4AB7D�LPPS�UX�Zy\�]�_M`Ba�a2bcd�e7hvh�h�i�j�jikl�l�l4mym�m%nfn�n�n&ofo+p�rDs�sgt�t�uv|v�vbw�w2x�x�x5���j�6�����T�
�Q�|���H���o���$�#����L�������&���{�
�������������s���r�����?������J�~�r�3��=�s��3I�y f!N"�"#V#$�$|%�&�'�(�+R,2-?.o/�0�1;2R3�3�3�56~8F9�9s:�;#<�>�?d@�@�ALBD�D�EF_GoI�JFL#�����t�����7�7;=�=����?���Dj8mFm�o�w�xJ|����k����}���������U�R�M���O��y����I�ٕ���T�}�����o�|���&���������T�����ľ �����������M�����������n�*������g��m���������_���������C�QVY@b.cd�de[e�e�fXg�ghi�mroVp)qrExy�Œ�������K�������������
��$�K�����,�}����"�#�$�&�'�'6+,`,>-�-P.�.�/�/�0�0G2�2h3	4�4�788�8^9q9�9�:�;�=>1>�>'?>?�?{@�@A�AB�B�B_C�CD2DEE�E^F�FpG�GHEH�HJYJ�J�K�mxׄ9����F�g��8���I������������Rd�gup�q�����'\-n.�/�0d2>4�7�=�>�A�B{F�G%JKvmx˄-�׉��:�[��,�
��=���|����������Fd�gip}q֒�u��'P-b.�/�0X224�7�=�>�A�BoF�GJKBELPTX\`dhlp~�����������������*1HQ^lpw����������
+26:>HLPTX\`dhl|����������������"19AHT_fjqx�������������			9	=	D	K	X	_	f	j	q	x		�	�	�	�	�	�	�	�	�	�		


"
.
2
:
E
J
O
T
Y
^
c
h
m
u
~
�
�
�
�
�
�
�
�
�
�
�
�
<AFT\dins����������������"0@KPXj}���������


 
(
0
8
=
E
J
R
W
_
u
�
�
�
�
�
�
�
�
�
�
�
�
$)16>Painv�����������������$).38=BGLQV[`ejoty~��������������������&.3;CKV[cv�������������4H_s����������/4<DIQY^fnsx��������":Rj����������5Fhz�������������#+>CKS[l��������&9ANSXins{��������������	"',16;@EJOTY^cp~����������$).@HPX]bx���������
;CKSX]emu}�������������������1=EMRbjr����������#(08=EJRW_gnsx}�������������0FWj~�������5Pk�������&>CKPUZ_l���������/Dax�������   0 7 < A F K P X ` p x � � � � � � � � � � � � � � � � !!!!!! !%!*!/!4!9!>!C!H!M!_!g!l!t!�!�!�!�!�!�!�!�!�!�!�!""!")"1"9">"F"N"V"^"c"k"s"{"�"�"�"�"�"�"�"�"�"�"�"�"�"�"�"�"##
###"#*#2#:#B#I#N#S#X#]#b#x#�#�#�#�#�#�#�#�#�#$$/$;$H$X$n$r$v$z$~$�$�$�$�$�$�$�$�$�$�$�$�$�$�$�$�$�$�$�$�$�$�$�$�$�$�$�$%%%'%/%I%Q%h%p%x%�%�%�%�%�%�%�%�%�%�%�%&
&!&%&9&B&J&R&W&\&a&e&m&u&}&�&�&�&�&�&�&�&�&�&�&�&'''5'='E'^'x'�'�'�'�'�'�'�'�'�'�'�'�'�'�'�'(
(((1(5(=(S(y(�(�(�(�(�(�(�(�(�(�())) )%)*)/)4)8)@)D)L)P)`)q)y)~)�)�)�)�)�)�)�)�)�)�)�)�)*
**+*?*D*I*Q*V*]*e*x*}*�*�*�*�*�*�*�*�*�*�*+
++$+0+5+:+B+G+O+T+Y+a+f+n+s+{+�+�+�+�+�+�+�+�+�+�+�+�+�+�+,,,",',/,4,<,A,F,N,S,[,s,�,�,�,�,�,�,�,�,�,�,�,�,�,�,�,�,�,--'-/-3-;-K-o-t-�-�-�-�-�-�-�-�-�-�-�-.	....#.)./.5.;.A.G.M.S.Y._.e.k.q.x..�.�.�.�.�.�.�.�.�.�.�.�.�.�.�.�.�.�.//// /'/./5/</C/J/Q/X/_/f/m/t/{/�/�/�/�/�/�/�/�/�/�/�/�/�/�/�/�/�/�/00000#0*01080?0F0M0T0[0b0i0p0w0~0�0�0�0�0�0�0�0�0�0�0�0�0�0�0�0�0�0�01
1111&1-141;1B1I1P1W1^1e1l1s1z1�1�1�1�1�1�1�1�1�1�1�1�1�1�1�1�1�1�1�12
222"2)20272>2E2L2S2Z2a2h2o2v2}2�2�2�2�2�2�2�2�2�2�2�2�2�2�2�2�2�2�23	3333%3,333:3A3H3O3V3]3d3k3r3y3�3�3�3�3�3�3�3�3�3�3�3�3�3�3�3�3�3�3�34444!4(4/464=4D4K4R4Y4`4g4n4u4|4�4�4�4�4�4�4�4�4�4�4�4�4�4�4�4�4�4�455555$5+52595@5G5N5U5\5c5j5q5x55�5�5�5�mx�����;����I�i��>�I���K������
������Ud�gwp�q�����'^-p.�/�0f2A4�7�=�>�A�B�B}F�G�G�G'JK�x�x�xb|ʆ������ԋՋ֋׋΍*�+�,�������‘Z�������ų_�7�8�9�:�;�<�
���������@����������������ؾپھ۾.��������������������C�D�E�F�G�H�I�J�K�L�M�N�O�P�Q�R�S�T�U� ����������������������������������r�s�t�<C=C>CRRR�Y�Y�Y�Y�Y�Y�Y�Y[bIc�e�g�g�g�g�i�i�i�i�i�i�i�i�m�m�m�m�m�m�o;r<r=r>r?r@rArBrCrDrErFrVxWx<�=�>�?�@�A�B�C�D�E�F�G�H�I�J�K�L���)�Y�����\�]���`�a�b�c�d�e�f�g�h�i�j�k�l�m�n�o�p������������"�"�#�#�$�&
(D+,o,�-�.�/1��2v3���4��-8�89:�:�;?>L?�?�@#AB�CAD&E�E�F�HhJ�K�moKS�W�XYY[]�$c d�$d�"dY!e�"e��'�����xg|ˆ������؋ҍ-���Ñ^�����Ƴ`�=������E����������ܾ3������������������V�!������u�?CR�Y`bNceHe�e�g�i�m�oGrXxM���.�^�����^���q���"�#�$�&(I+,p,�-�.�/
1�2{3�4828�8j9�9:�:�;'>D>3?Q?�?�@�@(AB�C&DFDE+E�E�F�HmJ�K}���R�T^kJnp|���]��jI�m�{�~��SiHlKoz�q�-.���4���Z����w;�d�Hn>�S�/.$crate::thread::local_impl::thread_local_inner�p�j�qWb��athread_local_internals����
�f�f��w;�d;
.�!���]�J�qWbV�����
�f�f��w;�df�h���l��
�1}��core_intrinsics�fmt_helpers_for_derive��_�_��w;�d�FWYK-R�t,*<}�J���derive_clone_copy�����w;�d
Xɟ��X�:�5e�f\��	derive_eq�������w;�dh�:�{}��t#�8���������w;�dQ����;����=����w;�da�l��\�����<����w;�d����2F4��������w;�d=*�4���<�
�0��w;�d��sCF6q6$crate::thread::local_impl::thread_local_process_attrs�$�i��Gb��/$b������w;�da�͊`mF����I��Gb:������w;�d`6��f�	�0p�����_�_��w;�d3=�n��~,$�u�����������w;�d�N��	��������w;�dm۾m���:�8��O\�������w;�d߹���ڌ~#$�����������w;�dz�B�����.i����w;�d6@�U̚	�@�2������_�_��w;�d�8|N?��#&<m��\������w;�d	��ׅ�6��$)3��w;�d�b=�"����r/5�����_�_��w;�d���z���S
\����w;�d�k�/�g$���=�����w;�du��q����O��w;�d�ъ��t�t+�>���������w;�d*-!��'n��:�;'�����_�_��w;�d����M�uP���-N����w;�dA7f�Q��><�=��j������w;�d�"��2��#�;���\������w;�d�rM�����#5��w;�da��?Q��B.�����_�_��w;�dY�1Z�ҁ���J
?����w;�d��5Cꔄ0���
l����w;�d�MkOݖ���������w;�d/��/c�˅~+$�/��������w;�d��G��ּc~:$��e��������w;�d�u��N���5@�����_�_��w;�d��q�~����,\A�������w;�d@B.7����=�9������_�_��w;�d	�R��7���#v::����������w;�d(l���n����=
	����w;�d^-5����Et:�?���������w;�d��#i:�Q����,o	����w;�d8�wr+=3��������w;�d�F �#��<�O������w;�d�A��r����,A��������w;�dN�!9
���<M=@	�����_�_��w;�d���fJ����h
����w;�dae��0�h��#�9��������w;�d����U���8�8���w;�d�X��W��܊9��w;�d/�"��{p���
����w;�d�|W�%����5<�
�������w;�d&�k&�t���U3�
�����_�_��w;�d��n��,g@�
�����_�_��w;�d�#�Pg��#I9�
�����_�_��w;�d�~wî	��$����o�߃b������w;�dˆǞ-�O�����H7������w;�d2�=u��R��z3z�y�y;z�y�y'z�y�y+z���y�y/z�y�y7zz�y?z���yLzCzz�y�yz�y�y�y�yz�y�yz"z�y�y�y�y�yGzzPzA����������/�G~�|ӆ����|vz��ŀ�~�|ބ����}h{�A����}*{�~R|Z��F�&�C3}�z=�Z�~�{$�s�ނ����r���t~|����
}j�[�xfzZ�����Ӂ�1�-�J�d~�|���Æ�|�z����~�|������}�{�c�΂�}X{�~v|��1�r�K�h�}{b��7~�{J����ޅԃ�����~B|΄6��3#}�p����ODHT /����( N�
�����_M��a ������M*�A����j�8�'�QW$uT��ʮ���� �\�\�{	�[H:���
�(�v����	�'��bY`_�}�V�=9TWo�a��!���s@�="�~���p%�a���p��%Pq=�8��IV
��#��,�8����#��a�p;3�l��k*a�$bYj&`�R7��v��X���Wt����[�;�)h��&VO  �U���� `اo�<1�"(�����#�>u�I6n��o	G��q&����	�e'`ey�~^C�)�����4*����U�m�-06�S00�-��G��.8��Ti��S0P��b�7s^1(3G��и.�j�D:�D00�	�c3?4p��N���34��v|�9�X6�����Z�7�x�|ġz7�00@�&-7�pW�T�:H�_5\�Ju;`����
3E5��Ĩ�C��>���d*Z�?8vU�	0�B�r
�<�VSC��Dy,F�ɷ���GF0�F/b�L0��'����Mh\'��=�Oh�lp�q�bOH�"�#��T�.�4^f(�U06��<�}kW��CR%�Xp�Fdï��X��^J���[����٩\g��4�#u]8���c�^����
��_`w�>��{hd8���2
Fi�l�f��M�i�����i�nS���ioXo�E9˜p�:��cZ�q�hL)I��rN9��is(چ�4Wl~tX��O~�CrHH��Y�(�vHFac&��p�ʡ�S��vHٟ��%�sh��E���Hv@ցS�F�Yy�u@�۫��~�9�u�"�?~P�нV/܀86{��p臁�Z�GdYb�0'u��GdY�P#�!F%��'ed����k��]�\��@g�!c�r�81����q��8i�q���R�X�D%�P2t�X��g�KҌ�@9qR������Y��G>�c���a9��͓8A��k����ݨ(��ʣ���o�r�!v��-�!��a�P���x��>{��8c�`��Z��g��:D����D�.g��������+�g�Fc�!
�S�`s��ݧ`L%���5�{�O�2B���R�1���(�׈���k�h�_��}�6f�l�a�eA��zLB���0���1J�h��<cҢ�x#�V���ǿh,*�J�I��`G�8,aԆ�X�m��,��I6j�D��XmZ["�+Ƙ�P�q7�h��@1����2x�DZ���?�A���8˨g�k����#A��D͐�T��CN΀�gL<4tΈoaL��x�	sw�v԰E����.B�hߝ�!��ՠ�K���|<� �^C����XT�y��݀!p����
�(Q�s���Hp��Ś̾���n7ͥ�E�8�r��������Oh�տ� I|�{��4�Xح��HɌ������5$������Z��p�~-��K�Ш	�/�����Lp��-�p]y���@�~�h��)��X�ޭUF�(E� Ʒ�P*�3,~��8h���b��5)	�s8��C{�I\�����
|`��8����G���A�H��S���p��şs�3�3C$�����dE�iTy��B��	��	��tkmy��Z��Tٿ~��M��Is�������A���7Q�m)�v� �Ik�x6ryX>�t���g�&��"I$����-"�*@d�a$�Y�^\Pz�(��D���9�*�О�o�-��r�T.�x�-�q�70�����&Q�2�W�;~0_�2��N炅6ѝU��6�>�?�I�	�?ۻ�L���@yiJ�9��GA)��a#&}�B9�j���CA�����޾C�:�$Óv�II�صo��Ii��;XTVK)�M��m�*P��֗w�H�Q�iy��>R�z1��I��V�@���q�zX��ݬs���[	T'|sC�H\���r0�[��BW:$c��B���f�7�rJ��g��k2a�gIv��)��j�)��c���k���e�n�}g���#o�G���3��rY��6��s1Y�Z�MD�tS�����tQ�6�>Y8�xa6�AbI�y�8n�n�x1���{)��|)�Ͽ��}�9�Yg�|��E3g�#i(�b�[����"�J��φ�+���{���?Iؒۋ�:��5H#�Tf՛kP���/������Q�D��&�TI.����~TB�1�ix�:Mڭ��]�~��묖.���Qx�:k��/@�I���.*��2i���{�iz�G�&�B���q6(�����_���`�]�$���A(�Yk!���ö1����)V7t�џ�_v���b���ϖ�WJ��%�������(��9����q1 ;��ɯ t-{%�Qug�r��o��%�H��\�	�ͨ	���9����#�T�9���H��±�	��X�9�S/x�fQ��?%�����2��������mh�Bǁ5�b[aȡ�\.��MFƙk+Vn4������������&X.;��1���O6C�aGc��B������Ϧ����q��K�)���Q!��q b2s@\�I0��G)��d
�-�G�I>Q6=�����	Rl�޻࡛�
t���a�#j��‡�	_1¯F���@���`�Iu�WE)�6��z$�qm������-—)�!k9��j���� f���������rP��T]�c��aFr_*������U�����Y3!�I�˺�l�quum�5�����@�<u�Q2���Ht�e��ִjb�L��Rb*�ۿZg����)������R�C��_(j)Ԟ��:�?	�����d�	B=��t� �ҙv��pF�	B��j��
�1�����	�n\�أ��W t�.�ù>��"�`���qC«������F�&g��
�X ��A��$���B�s��+3
,����5? "_!�(fƢ!�A�5=�Y"�Ƌ�D-��$����{��%��x
�%��]A
�/%�eI�G�])������,�G�n.l3�-�C �i�,������01z+pLq�4�� $Q
34��0�� g6�����!�4b�����[62����)�6�I����0�:��j˭��9y���\�>�1���?�=P�x�6�>r.�F�v��@b�9���+B��1&��CF�9��B�K�:�Wk�7Mb����N��[����O�3JljS	�P��V���+Nz�d$��yR
�T���/S���2^�S�5F��`�Y����
�vZ��R����2[�̢�bw9]�:��w�`��0�����b�����c�o��8x�`c
K���Rl
b���Q��hh�s���xhb���b��Qj�]����i"�eGEXL�m��8�&��Grb'�v"�s�[����s�����R3�u��
�Yz�v��_��:�u"�� ��fy"G
�qy��5=�4�;{ʗ�e���|:
�)Q���}*B6&�%o�{�^N��V)�j虯���s��@�ۄJH���l�­*��x:	�2#!��b'���H<.����Wڢ�� \��JFN�����@?
�Jo�Z
��H_��D}��]D#��l�@�0�i��
�	!#M��Z�|^pD��zv����ޔJ'ɜS�0.��»�o��y�rH_<k����PG����m��ǕZ�ì�"�CY���z�����W��*�O��_�����#3���p���M����}�袚���Y��)�SݝL���Y`���M�r.�z͌O��ڣ:���p��^z�AjZ�R7�*.Qu�b�l�S\���ĊNq�d�zT�'�`��B�xB
"���$C.q���"ᑔҢ�硊 ����dr��Dn�>?Ba�����u鯲"��\�{ٱ�$����_S�rX�P�0`��q�L��;��e�s_����	)�d���Щ��p��R�o/C8}M��ʉ;�˸c��7Y�G�a���c�+��	M�7a���o��*̬��T�
%$\`K�2qS{ϡ��ǂڽ��g'���0'Y,<��߀��v�B�:{���q�S̪U_y�,��Βi�|-���������К|�"";(�ς��������b �%lj��I��
�ԚZ��U<���*#�+Q��{��tl%��⣸K����Z�ei�m�~�J�~�.��u�2Lh���w�z��
m`��9�`O�l��b�g�T�Ⴘ���M$�U�L��X�����w8��p
�}N#�"�(z�l��J�w��
X誈�;�:�*�?v7xJ��
�R�R�~�bP������Jhr�\�����21ޮ�K��#a�k�*��"x�������z/\uL�r�h�O�ϥ38�"����d���;��a����"# 5��aӺ�&{¹&
�F?���`.
�h����6
(�U�)#=��]���2mg���e#x��+��7�^�^>C�"~zQ������bk�k�pMC˼�$r�����6�S��b��� `y	|-�!����rxtP"�B$�-� #�*q�,<.#S�HjX�%�'L.�Q��'K)���P0�(;�?��u)�x���)�_��,�y�f9�nZ.��e��3Yn.ìM���M�0��J�O72�N�44yA4[�g����.4sm'?���7������8��=�3:Ä���LE�;�\���e�<�s�L/�C<��>C/�^B:3+�_����B#�2�K�C���gdj�E�o��=)@�F�@QvՕF�0�v�(.K�����L�M#�ۊ&>2eN+X@���gN���|�@Q#�qFi��Rû�BF��US��P �S����&��AT[���o
[SS�{[�p�WCz�S���iWs��s�Ս�Y;���i��Z+[]/Zn�Y;_\MY���\������]�X��b;l����#�cC�����ds祀�T��e����?��c���7B�g�h�C�Th;����_9�m�?(�&Pr r+P��w�s#Dg��s�p���^
8u��5V-��vS�7��w;�d���ov�r����	xKQ{n���.s#�p��ܿz�-�W�7>~u�/~Ո�~CWO�����~
$b���CEx����G���CZe�z�#�O��:ڄ;';���w�#�Z�AԸ�;'WX��֋S�WW�ё+�;��bQ����}�T�#��jkƨ/����K6H1�薻GK���Ay��߄�c��ј�s����H�Y��d�#����*&9�+��iE�#���u�r�������g
��t84�Rנ{uԥ*��-�K7×#r����w���r�C%;�|��]�S�c

�9©@�d't7��-"�{���+�F)��s?�$����K��g�ݪ���Т������+<x$��+T����cm�#Ȩ��s�a��.�i��qe���
0��5:���)�3��Y���	��IT���6���F�֢��{ynh��t���H��O�ֶ��5i����}�{�����Ǜ�a��rz$�#8eF������m	� ���͋������3��\R%�ϻ�U�0��ۘp�W=%�уo68}����R�NME�[����|�[���!��{�2F��kϫ�%��c�3h7��p��b��C���s4�p�k���{1�,���^�;�H��+�#D>�Ė���t^_�ҏރ$�v}0�k��m��^�{��������rs�P���Q��Ҟ̬�);"��*<�� �ă
U�s��xI/��+�٢+M�{IQ�c�Q��O3,�9�k��v�j����[�8zgc�[�V�!����;�4��v��5#�s��S�6n-�x��D�+;��s�^>�e��k>�}$�� �@��r7L�y���,�K��e�$�ʬf�\�BU���T	�z�><`g
<����'�	
����	��,��gE�
�+M���e�$���3����#'9��qcgj��s�O�@�\�95eWQ��)�
p�����Mn�f+}
�/� ���?��"l�q1��#$���"�w#<L���5��%\P!!(&�����%�c'J_
q�$4��;#�+��5,B�6�,�E�$�-|�^2 ��.�6��w�/���`G/l��.�v��+�د�)˥(-������.3|&|^�(Z3DWfi(���8��3s*(9�����:�;��^�z8���	�8�r>,�,��)My?�M��6Ѐ�@��8#G�!�A\�
��HB�:=��
�Cd���L�nD<.	F�p��EL��'����Ele�U�g�7F\��FH�$F�(B�v]�It��/hc��I,&/�!	�K��������K���zt>��H��x���c�L��0�
x�N��,*�P%��F�Q$�K0��Qt-�}�[&8R��D�%Tdp�@ܰ�X�й]��*ZX��`9���[��aoDL[Ԩ�
��_�^\똼7ì_�8X��y�~aD�'z��c��u=>k�eL@	�[e<�h"���g���)�f��O�G�oi�j��@N��j�J����Yj|���Tp��j�����2�j��(�g��3j~`�z�+�oL7V�B��p��A}qDBi�]qD;=R_W�o���t?hLfdy�9S�9i��p�(�r�v<&�����wT���,��xl��MѲgJx���pF�Uz<����!B|�n��>��}������~Tvu��aڵ��f�����J�d���y���T����0��4�DB��t���wԚ��!�����A�D(p1T����E7?�S䋤2�	��+����Q�g��7���Tb���Q���5͋L3x���Ԛ@��+𼑬{J��$��4n���'��3��lJ���"��"�ā��k��4����;�i�����Ī��ہ��U�')=BX�,A���7�
�\�UC�`��Vd{�Vh��7�>d��7���=��0��椫Υ��.)�d\������i���E��7O��$��i�jЫĵ�1W␮�
9jM���<�B�a����������Dj�-�ΗU�$gROh�O�lf����^\�T�{8�ٛ��ʽ��@淤��	�ǝ��j�Vwܜ��!_(�
��4�a��g�������F�Ą,7kܓS�DH��t~��L�YBK�\�]!ç=Čj��Q����k��U�q��lr�_��:�\b�H
���\8��S�p��
���^���lXːPcc�̄n�c��!�$�K�ę\1ά9pXJ��ż�[�,��ҔA)b\>W�4'A	D�{Ԥ��s��H�T�z���P�l������4�(��2ؔ΋	�%����G�{MڤV�ݒ��$����߼�e�A{�l��k
Ai�\3o��✹�i��yt��NAd�����&���^����������L�%�?/�l����āj��`�l㌰��#�du��d���L`s:����ܛbB`x_4��+�
R����U���rR��T�_
���'��f��|�)�x����Dx���Y��dK��ת\������
2�L��"����D�J*&���L�#s��?���w ���lT�����2�����"ˬ,��}:S�͊�=��S�	U��G���
m����8�ҏ�hj���P8G^�xL
5��c��Q���o��x���2�3�#�D]�R�}r�*�-\]{E��e���jZx��$��T��x:-�<5@��L�z�u�|a#u��kI�E`���.���w���Z1v�\,l�0;�ukM�5c��&'"嵱�z��#���9� #5��]t�o#�Pʆr�^*��A��4-���\���0=$������4�z�5Qʼn4�������#6%b|1
��|6�������8�A���*�9�|h��I��:�y?�AZ4my���dty=����}4B�=�C����P�>����pnDB�lO�W���B�[��gL��C��-��eE���I�nE]�����Gm���)H�bhh�
I���沙nI�~r9��M=dHF.�m+P%���FB�P%�=�1�)�P�v�����R]̩���TE�
{��lU�}#2sF�QU=)�m��LVeht��o�Z��5�:��ZE�	�����[�nD�<߲f_��e�SX6�`
�o[�X
au3x=E��b�Å���[�_E�����q�d�ȫ7�8TYe5�����vfe]	� C�g��w��N�d�L��T�Y�i%�<��m��ne��wwi��oE����Dx�n}pO��CTr��E�W��s��e���tE�:G.���uet5�ԯ'w]@G�%�a�{������{�����,}�d��3~%�Y��]{�E`<�܁�w���Y��U�0�>O�E����g�τݽ���l����V׎��<�|�g�E�}�����}�O#x��T��:�%���uN��0H�N���^�8����\�$)P����@wH����-|���g�_�%0�b���q��H�ե���=�מe}"�Z�/����>���=p���Z����=Im�}TrD5���e��]�a��u�.T@��MM�����
�E�R۞d��e�1Lm$���Xh�R>��u��-�tΕ�mE,��p�u��v�*�e�r�y����D���ʹ����
�E�����C�����Q��C�m���+�}j�\6F��}�Y�����5V��"e��í��m�+t6ĝl5
�#Xq�<�,
�O��-��+;_��=�]��]���nڄ��H!�r#��C�P�6��]��.F�
��wx�xEٕ�26��q�ڵ���]A���?l��f�ڵ4}z5�5��=q�L
k$�U-�z
�Fo��՞8a���>D:�9��fK����*��ZDc&˻���X�����z��S���K|�t�)�u[d,��'��o��3�0���X
����@%�2�����f�d@0�5
!�V"����2 !h_!��Y�L7���]%�Y:i��Cyfg���-1�y�u���N]����-��Dp�@����yT1dd�� �xNk.�z�XҰIvU���ƺ�Nk*���E���t�G�R���*3->L�&T��Fx���/��r+�}�I��)����eo���h�~Ӱ���PN��!ɢsKN�O��s�F�Kg6#^o����7P��?9�~7��2�f2�&O�H�N}!ƛ����"�؁�r{\�#N'j��([E'}WT��B(�`����)&(��,|W*����*���5�-0����\��1vV��	7�3�q;�*��4�e�����r5�����c"�6֤�a4�v9~�� ֠e�:�swXʍ;^�FRcB�<�L�>I�$?��� �=@A&��L��VAn��R�l&EC�f��jD������fCn������A]�m
&%F����I֟j�{(1SL>�����CPn�V2<��%P.��~S�~�WV�j�
�%[�*����p�]bc��a�`��J[bv�0��Gb�/p���f&W�O�m�g~�ݹR>��h~=�Ã
gneBMMk�f�;��K�iEk����P�hf�_�{��f�CT��U�Vnv������*o��8���E�o.x�����q.�?yĂ)�r���1^lp�PRVh$m@p��=�qt��@��`7w�ĵ|����xv��g��\~pg]ܽ�݀����g�N�"-�h1Ѐ�r�"�Q�.A�b������h����w����3'�.��v����6r���8�;����P��ՙ[���S~��.��Y-���v_Q���F6D/���>�V ���b�/�N���]�"�޹���@��n�O�����������S�[���>�n��Sܷ�Fɘ���Jơռ
�dq�6� �l)�^�l
P[m�N�|Q1����I�K���I�6M�U���䧖x�jF��D���A�<�V�P�췻�f.HN��H�:���v���ue�F�o�[�N������艸~i,����=�F%k���`x�5�(ySk�&hc�)T	�v�IEBD'8�>qPb�~e�nF�g� ;�6w�+������5�͸)�C�Ѽ6��Nco���F݉z�.G�>��9�����~^���O��>�C�����E��Z�v#poq��Ϟ�sa.ˁ��>�6���G��/�,]KL�F�J�2��5PZ��a���j����DҷўQ��e5���ռ�F����*w�X^����r���A��>��v��ν)] �Ϧ�&����su��E��}����ߦ���_	����uE��!Q�$�$eA����e�c$�&v�����b�6p�QM�Ow��Z�K;����̵��gf<��L!��+��s|&���E0^����f��Q�
�v����ҵ�N��U�{@���?mRo�l��
�.�N���pUg�d�k�ןc��[J����������9���a��u��W�b�;�
����w����<g�(�<�y��p�O�� #)��'$���#g�)a�� _A�@��	!O�V#����#o��t��q'_�@*��x*g�9��W�+�-z��h,�`8RёU-,�uD9��,?+gkP}i�17�
�'��%3C���U,4g�/�&�5/�-vG �5_,4#�;�4���9y3W����g�9����o��:�Ūo�3��;�*q��3S�?1�<='``U�9G>��2+%s�6?h����@Ǵ��UQ��A�v`RC�N9犌�E�C��D�G�cDO$`��T��Eϳү��<�K��n�ۉLG��NHM�t�'GէN��6�+�Nw|Z ���L��:���csQ6]�i/xQ���>:�Sg#+(��SG�Ti�sS�<pw�_��V��@丑�V_J�I{�3X�l!�n�R�WO��j��(,R���(
&X�[׉J��)��\`���^ua�Oh�f/a�ހ�/6-�ag�.����dOsC"t��@f���.���f��Ý���>hG�&;��hw�0�0v�m�(H5�ۊp�[[j��q�x	�Ȓq�G�XG�H�u��??�cM�v������6�v������xG�C[�=l�y��~z�I�u'ʡ
�:��yOS��H�|7C�q�(W�|��xl��F}o�e��
*!z'R#���Sy�[��U�-�{G�ק�������+��U����?��wgT�z(�B�OR�G�;Q��!��Fulh��׈�{p������?ij�_�h�O~G��o��L~
l��7癳��댍g(�q(��ۍ/����V/��-��P0\ڒ���o-�xϒg���j�Ò���t/��w��es���s��`%
�G���~ܳ��F��`V@��8D�|Mл��dS�5ԷÝ���+/톞_C�������
`}�Ȣ'f�+{gk���*{��S�wt��AY���<jiC>��t�6�%�g>����Q��_�R-�x�;��(�K�"i�W��'��̷/ݴ��ٿ�G�fҨ�ÿX�)��u�g�#M�΀������D���'�b*��&�/�����0�ʟ�����5�?��,͇R9o����̷�O�PIu{��z��ֻ0@�g��m����h�����ї��(�>.Yӯ��A�h���ڹ��V}Y�/1�H�Wo��|3;[^C��wK�l��K�У���H��_ɐ#���_v50׺���wY�������cgZ%1�wjMi8����aU�a���'�Ҽ߾���H��&~���ZZ��H[�w�V�{���7A��b���W&�h��r��;�a1`�O���-Z-������|���C˳7��a�
9ƒ�����v/[&a(eK�$P\[�7r���px`|mav~S*S7�S<�}��c	Ke#r;V	/pb�h*����[#����`�6[���iQ�#/�
M_g����`����M_���E&'CT`0POF@ ��wh=L:E�53Vq"
�_#���T���7�R��Q�R"�{LE&G�Ek/������������ i�E�q6�-lIm*3����T}N%��/�8���L79\>VF{?8��<?,	v4����=�uOfo@������y<����?�����b`6�3������LZJ���"�O��l�z�L?���������l]%l5b}����l&����k
���_�n��K�����s��F;�pP��3E��wEI��X7z�g"J����o���O��3dz�?jb�5����`��8��/�_�����a�;Kn��3f���fr�q)A6.}����wf����KB1d�(������D���j����3�a*�e:Y�nm�/	C~;T.�\0
W,B9�����@�� E�y].$���a!`����JD|5h��(_�������f�q-%+2*`#����H)Q����XLQc��}|?2�����Db/	�#oH'L��9�$���$m#}>osrd]/���#J!v'~8R0{/xb*!H\7@`enLgh7D,e��0f�)���^@y�/�u]A`BUeAz\�2������??X3]n8k)T��������90D��?4�u20����F���4l^��6��v�vw��	f1<y$&�~z�]�2&@�x�3�~L�B^���Tc�y(u���L�m H�QE{UDXW`..\����E|RV4q��������(3}Px29=8E�'?<!'�-����++�����>�%%BRySF�Yja;��1��p%~*o02��y*#�7���{�����4i02���vl8)U�41kf$/	e	C�������G�d�v�(;o+
��"�iE���y�<%e!wm��F&j����8�z��]�e�8XUd@��"arW>3���
yE^��mtqMVkg{<^	TE8���\0�0N�L,�Y��4x'kX}
0
B
@t8KWgp�7~:��`Cov��8E@s(< %PGSbYz�����*+dE��_"j�^��!ox)E=�^E��0e���U.TC1ZGe%8-��
=NEhE���iy7A ^��||Q@FB91�v}���%Ze%��]���SV�ljNGe�7f9.X�	Yw0	-P��Xnge������o��L���OH>4<@�oIa��'nMz1v?��$��^]T
:��"��27<BeU[iV����SF'�}X�#���~L2,�Lvz���MN��UOp���AC;E�P�~�Eg����9�h�GQB"E]"_
t����P�W�,�k�n�����s�g�����.�e$Q;|6>8[j
%",�������>27�r�,<��H'g<��q=G�WDS��K�7�X��Q'%7��(���['�
@5���+0@[}����DR�lEx��n9#B��H�xmTdv`H�5��d���+l�����5���T�1���
u��+nZ!SF/*|aJ(8 �Z\�����3�H9qZe�}��s��()���v�/"��RwM{OmL�^6>c\ni�t������7���B5\1$
x_caDM���Y�!�89oi(0RQ^;w9>~:XpU�O��RZ���&	"C�l���N��������������Q���r���8U��-0+\E}~��Q��+�p��� ��="5���vT\KU)^~;F[0i�����wx
.K
8vOW%`����@i!�baX�����-a��wZ!
P)A<2``P:85#?LV@��ZQ`m9�H��o�")bKE��?��K:N)X�������b�Z����������R��f1P�H'kL	U
\����>%Q����H�;15*iAG��[I����TMt�����R�bv/[&a(eK�$P\[�7rh/home/palash/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/rayon-core-1.13.0/src/broadcast/mod.rs� _�́������4�����*�$*/
MOQQ4F@*.
;6OPP3LL#:;<9"A, L5+0"W#J$QP4)-/A-+7<JIK%<U.
$!$,;C&;<)[ <JIK<N:-CJ
,,ME.()D(�F�Œ��<�v�2n@i/home/palash/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/rayon-core-1.13.0/src/broadcast/test.rs� 
�`u#�����#(Rs��B�01@KF2@KI/%KID2%KIB%KIU2%K%JJ"7+KTJ(-%E
/K%JJ59"A7+K%TJ(9-%=1E*
/+%I43")'C+!*(;&%
&+1+%I43&)'C+"*(;&"%
&+1K6I&,OLL'-F@D1@6-46+,�&�����U��?\�jAc/home/palash/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/rayon-core-1.13.0/src/join/mod.rs� �&�ʧ~<4w�E;���5�+
C7G9:FFEDDHHINEKI%GGEX*-4#/*+	8B;3<!"

!>>AGGD
G?CF<<G-CCCE:D
D''Y,M4;ABR,''DI(SCFCE#%BB84&+N;-(
(GF#"!	+"4eK�z.V����w�æd/home/palash/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/rayon-core-1.13.0/src/scope/mod.rs� %�-1R)nޅj����D](4'K.
Q*QO/QC45"%NLPE&QCEEGFFBGCCEIJ==((--44/FE=FGAQ0%%8@A"(#11"AA6666666666GB@?FGCCEHGGHDHB8BE&+B&ONJ+FFEG2&+&(J32NLQ,&+=G(NQI-4R&+U\@PI
FCCBFEE),
"D?EAIGF.JF'-(66'A&,8;00A0HGEEFFHCI9?^
HFHBF@I).0
"H?CEEGFKH
OCLBFNE2% ^%E8/!&7>0XG(0
EAIGF.PM
TCQBKSE7)%c)E</U4DDEC-EE<-G;#   G@K$M($'''F$*
6(0D,E3SR24TSSJ4
O(/D,T6(!U47H"DDEC-CF./
:(0D,E3YT48H<8
TSSJ4
S(/D,T6(!?U@-',49!
D
(2
=
+572%2BO
G.&[B?
CG?W
:+2A9:'RJV=DD
&@DI9.
,A"8.J0A&38.JPQED-D-:$��<0����(��/i/home/palash/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/rayon-core-1.13.0/src/sleep/counters.rs� ��Y������i^��k�J�0#IH/@A<SQO2.25+M,JQM,#OKH,1$ $1010$+'?;;<16',(
C@=@1c[3JHSJ+/>OQQ>3;9:DO&"
FJ8#8].TJc**H8=&FE@/].TJc**P.X8^'(B
7"
&&2SP3
;04=41:@:%$:41$K2%"399藵	��~��X��]�d/home/palash/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/rayon-core-1.13.0/src/spawn/mod.rs� �f>��c��
�0�/�\�0�IEBEC!-GBBB&AF%EACHEBG'>KA
VEG<7";4.<D"A>BC5]-&D"@;*-)J
CCBEH!96CG?97+?^>KA
T";93<I"A>BC5]-VQ&3*
�QЍx�ZM�%tL�A1
j/home/palash/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/rayon-core-1.13.0/src/thread_pool/mod.rs� ��
/;:	}R�T������G;0<?$6
-NLBFLP[\0_]=?/;;\E'2
0$BA!%@>#QJIM#TR $ 1
J9NO==&\2#
'&a.
"-RMOPJQI'%@>GB&&;\SU2=1K3
5
2>?D$=DI301$BE@/GH+$;AI:@G0:4GFD6EG$F<ADGDFDFEBE4+DAG
"".?5,14
0#?L:1;9
4(@5C=
)4N:MB
-9HKO@E $
'>7HKO@O.)
'><STT7.
>>E1P.YV/4<R.YV14!#!A'?.DGCD'D, 7=E6<C,
1
6AE+A8
<
6+-KMBQLCUT&
8!8KJPOUT(
8#4-%%
���2��Q�$/��ʳ�k/home/palash/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/rayon-core-1.13.0/src/thread_pool/test.rs� P	��7�������ǟz��i�0D,A!K@U,-.0E.#:K@U6J5E.#D;/$.E>38=(KLQQ@*86+ &% @NI5;+86+&$-BCJ?21KII5KJJ =AM-KJJ =19A5=M-KV0 )?-*" !,5&K1JK;I ?."%&)(K(JK-IK5S
.:"UQ) '
 K'$H9
3K:W
2:'UQ) '
 K'$H9
3K"I#R6" K'I(R6 " 0?>-O>(0?>-O>(�e�%^�C������]	s^/home/palash/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/rayon-core-1.13.0/src/lib.rs� i=�TtJ��4';дN���5dRPhS�Wv}w^'!4_c^Xcac`d`'Y$POO6B?GIHL
(


	

I*'5C*=1'<'">Wd[b$RCD=GD?" 9<;/*(5+"" V9QIM-18EFHK.1>60./,*@G-U0 G/?GFK1FFK0D%'!#! )"
[WMIE CI;I8FKH A8IA8D>&LX1OJ1W#F?+5*,BI=IG
d
A%%*C8B><F!5PPTSU(W#?7*9G
X,#?7*=85D6/M
VTT/#?);.G<FB@9M)R
Q
34+9/3)/-/
:0 C8)"0&"08+-;08$ 
AD0>8
-8
H?D.F<8;39?EACD?1JJL?(
BbGa`a`F2(
5D">C>:>5@?@F3@
<<
102=,
E3DHH>IIF#A@DD@C=FD/bQ-#
*AD"7NOOF@
.<
@B!6NOOE>
.:
`$/
;I0A8
-:
AH>
CI
<B
@=<
C-5
CI
.B
BG
.@
?16&'^.<-B&$XU:
9e.
-?\_/
>>I<.? $!?#1G)
TPPN,/=84.424$?HF#%"
I#% �}3��;ӟs�Xs_/home/palash/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/rayon-core-1.13.0/src/test.rs� ��=�ɒ����IAy����1�60KJ03GK2H9"$#+( '#?B<K2H9"$"+( %':?B<K(2H?>#@"?)($#5
( &$''J8:D4F@KJ0W#*K%$%;> "&"&$K3KJNKB( "6KA"*G> %�a#�jAA�	&��`/home/palash/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/rayon-core-1.13.0/src/latch.rs� c_�f�.Ío�I�t^�u�0/#LMKEFE
GH9G<*GCGeH*G?GG+OMP)&+-D%@DD.(
GF'.RCF!/UCF!#]
LEF/C))2!,
DD."! GDC.C*)1
NN&E%
) %,'5CDECG*FCDEH?N1AED=F
G-"
Y*01
" 01
'3 D9FCGBFFBF'*
?6-$1F
!,@<GG;TT2TTZVG!:S#*I8@8@
>#S. :-<13-
%H)>':H@)@
'AA=!+""9/KQ
G$ 6!
1$D +'hzWٙuE�х���t7c/home/palash/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/rayon-core-1.13.0/src/registry.rs� h�Ƞ�����cx��!���-^
a9(
0VL#K)P0O #$?(0)'3?GCE%BEFC$C,,)
8*
#3FC/*'/C#%,..,AIIP'Y[WVb0"L7-E=<1aW<I-DF'#:3A4_@41$<`]GKN:c_Sd[G:T6%$
*#+1
JW9C0''0"P10"+O*,02997Q+d)661:8:?`V]Y>FHN
8/98"+!
EF'39)08
LC<5
8,II0
0 :6X4<*
EGA-) 
G<.)!
PE4E@H;5[0&
GE28FCD>:4=/:)'3/9-#
LN-Kb=
>JGHL>B?L&
)6
KQOR57
59)(F:DJ0+
8
5RO>%AC."+`X
5J?D6!=?*'/CF@GGBB%CDDG>EDF5LRKGG"%FK[
NRD>GE0D9E=A15&')
L!-;6(=FED^,-#%"!('
'6 FC(5"G39'(;6T*46C9(8AGF<,"
)9-#
)EE%Q+)
:DBEG/0'LA7#P#66']%"[IP.
H.E( B58);,A?9A%&:.!"# !
0&"# !
71D(C4#C.
#:+!3+>3:.**!)
L-5.-%16GD@,882,)772IBEEEE,1

4%@F,&,
C:BP3?I$
$
& .$.*�;q���C�ț�So��d/home/palash/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/rayon-core-1.13.0/src/sleep/mod.rs� ���W��{�\RX�sn�]�E#"!,8ZVYXCX=FDEDF1@B3$0E1%<
3+W-
K-3
&Q2C7!$25!$=>$!>$!H>
4J$24!
CE%G'"%
AA@DQPM+*!<A
.Q4CS24!KO'1LBOQMN!  L
!AGB6R8GDEN8S:9141EEEE?DN8S1G?PWHKD8
?!<0FG8@02U0
792&* 
;<E!.GEB=FEBD1
5 +59m����<�E��_^/home/palash/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/rayon-core-1.13.0/src/job.rs� e&���7��0̂d��;�(
 FGFF2HDE(E)GD=&G:
(-
A4)()(FEGD$!
!& !
@/6
7?025(!
),*76!;@D"E 0"EA6C)1A
'!)5CA0!EA6B51@
* )546'+
G;11/#@
1"$
B_`Y")B,'D9#
ŭ۩Yg�:��Z�"$Qb/home/palash/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/rayon-core-1.13.0/src/private.rs� Qe�9Ԟ���;6� �FFC7B7(A7FG*
b������1�M��V�pa/home/palash/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/rayon-core-1.13.0/src/unwind.rs� �����9��=eP*����GD0*GFCA0D" A!�2f,s���$SU��8k/home/palash/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/rayon-core-1.13.0/src/compile_fail/mod.rs� �4NA�6�'�Cz�3��T�W8�o�C\J��q/home/palash/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/rayon-core-1.13.0/src/compile_fail/rc_return.rs� z$Vȓ�?���<���X��33�n�\>D�†}���<.��2���;��������	,�
�h%�x86_64-unknown-linux-gnu��@��q�Y�k+2oD�
rayon_core�-683451861a2493f2���w;�d����b�����
���R�����������(�����)��(�
�)��
���
��
�������������)�������������������������)������������
������ ���������3�����Еrust-end-file