📄 libcrossbeam_deque-39548485313d4b56.rmeta
/home/palash/git/iron_learn/target/debug/deps/libcrossbeam_deque-39548485313d4b56.rmeta
Language: rmeta • Lines: 1449
rust
�#rustc 1.92.0 (ded5c06cf 2025-12-08)��١�	�T�6a��D�
-5080178c80bf7a93���	ⷄ�ۆ��p��-225863f279df55c4��uӰ]����d��!�-06039bcfba61f665��**�٭T��HО�9�-3e2e950d4bac10b5��	�t�#3Ҵη��Ǣ-d25e598578fbf080�rustc_std_workspace_core������Nm��gmY���-327ea4f353b4eb8c���y.:i���gy"1�r-94fdfaf0af91a65d�miniz_oxide�M�^�yTLm�L�d=B-5312b588e5cfab93�adler2��;~�7�ɴ,P?���-1e0b0d62df36c85c�	hashbrown�L�ϫ	2݆y��q-2ed6a8f06fc51a9d�rustc_std_workspace_alloc�a���p��H����6Z�-05b02707a5b2a256�
std_detect�	c�LN����=1�ʶӐ-5978f0713dd5442d�rustc_demangle�X�Fq��UՃ�>7z
��-43b2ff22c18e1125�cfg_if�֦<����ɐ¬�-6a40188dd7d989d2�	addr2line���,2�!xb�"6�!�	-11d54e777384a9e5�gimli��2��I.�ġ�����-35018e994bad7042�object��T �f��Y�
hQec-2dc10b344e05b569�memchr��xZT9�C��I�Mg�-09f2ab7e0d97e07a��~ݤ	����h���-932f22f820d1e5ec�crossbeam_epoch�"����"�@�a
K��V�-898edee4616dca8c�crossbeam_utils�ɟ��P�#�}
�Gr�-30ff13b172e89a74���deque�	

MIN_CAP�	MAX_BATCH�FLUSH_THRESHOLD_BYTES�Buffer�%�%�%cap�)�+�+�-	+�+at�+write�+read�3�3�6�Inner�8�8front�8back�8buffer�=�=�Worker�@�@inner�@�@flavor�@_marker�F�H�Hnew_fifo�Hnew_lifo�Hstealer�Hresize�M	Hreserve�His_empty�H�	Hpush�Hpop�S	U�U�Stealer�X�X�X�\�	^�
`�`�`�	`steal�`steal_batch�`steal_batch_with_limit�`steal_batch_and_pop�`steal_batch_with_limit_and_pop�i�i�l�l�WRITE�READ�DESTROY�LAP�	BLOCK_CAP�SHIFT�HAS_NEXT�Slot�v�vtask�v�
z�z
wait_write�Block�}�}�}slots�����LAYOUT���
�	wait_next��destroy�Position�������Injector����head��tail����������>����
��
��������������	�������������
is_success��is_retry��success��or_else��F����������I�Flavor��Fifo��
�Lifo��
��������Steal����Empty��
�Success��
���Retry��
������ ����!��"����08182858?8L8M8O8P8Q8R8S8W8W8W8b8c8d8e8e8f8f8g8g8h8h8k8n8n8n8|8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8��%%�
'�(�
yO�-��*������88�:�;�<��L���������������(������_�����������@@�B�C�D�E�2y��������_���XX�
Z�[��}K#V/��������_������������!�GƧ���������_���������������p��8�������������_��H��)%F@\X��3%��iX��6%����=8����U@lX����������������^X�������������_�������H�
@��"�",�#64��
 �"�#�",�#32�<��
)@�$9	��"M
�$i.�"y
�$��-$�",��$��1_����"���o�",��%1����"���p�",��%2�۶�"�Ķq�",Ӷ%4���@�"���r�",��%64�<��r�"��"1	3r�"0�"_�"�ӷ!s�",��"�0�r�"�r�"_����"���t�",��%1����"��u�",��%1�L��s�"�&�"18<s�"	BLOCK_CAP�4׾��

��
�}}}����4I��a�d�Z������l��4��	
%$��
�}24����\���"%����
4��������	s� �@]�!�"]���@	

���";
H	
`
g�G�"]
�^�"	��	!�]	�
�� �]
�S�����Ӿ�
������}���}/i݄���
4���0��.0,�"+�0-� ��]q����	Arguments���pieces��[����[����[k�ĉ������/��/��/��/�layout�U_�

�/>�/"1�p�/M�/U]<��
���)�4�;B����D����,����
<�X��4�@����$! Concurrent work-stealing deques.�%��)_\ These data structures are most commonly used in work-stealing schedulers. The typical setup���b_ involves a number of threads, each having its own FIFO or LIFO queue (*worker*). There is also���c` one global FIFO queue (*injector*) and a list of references to *worker* queues that are able to��� steal tasks (*stealers*).�����_\ We spawn a new task onto the scheduler by pushing it into the *injector* queue. Each worker���c` thread waits in a loop until it finds the next task to run and then runs it. To find a task, it���[X first looks into its local *worker* queue, and then into the *injector* and *stealers*.���d�	 # Queues�����]Z [`Injector`] is a FIFO queue, where tasks are pushed and stolen from opposite ends. It is���FC shared among threads and is usually the entry point for new tasks.�����$! [`Worker`] has two constructors:�����_\ * [`new_fifo()`] - Creates a FIFO queue, in which tasks are pushed and popped from opposite�\�   ends.���_\ * [`new_lifo()`] - Creates a LIFO queue, in which tasks are pushed and popped from the same�T�   end.�����ZW Each [`Worker`] is owned by a single thread and supports only push and pop operations.��	���	b_ Method [`stealer()`] creates a [`Stealer`] that may be shared among threads and can only steal���
_\ tasks from its [`Worker`]. Tasks are stolen from the end opposite to where they get pushed.��
�t�
 # Stealing�����+( Steal operations come in three flavors:�����%" 1. [`steal()`] - Steals one task.���VS 2. [`steal_batch()`] - Steals a batch of tasks and moves them into another worker.���c` 3. [`steal_batch_and_pop()`] - Steals a batch of tasks, moves them into another queue, and pops���
!    one task from that worker.��
���
b_ In contrast to push and pop operations, stealing can spuriously fail with [`Steal::Retry`], in���74 which case the steal operation needs to be retried.���t� # Examples�����b_ Suppose a thread in a work-stealing scheduler is idle and looking for the next task to run. To���63 find an available task, it might do the following:�����85 1. Try popping one task from the local worker queue.���DA 2. Try stealing a batch of tasks from the global injector queue.���HE 3. Try stealing one task from another thread using the stealer list.�����52 An implementation of this work-stealing strategy:���<� ```���52 use crossbeam_deque::{Injector, Stealer, Worker};��� use std::iter;����� fn find_task<T>(�ԃ     local: &Worker<T>,��     global: &Injector<T>,���      stealers: &[Stealer<T>],��� ) -> Option<T> {���96     // Pop a task from the local queue, if not empty.���      local.pop().or_else(|| {���?<         // Otherwise, we need to look for a task elsewhere.���"         iter::repeat_with(|| {���GD             // Try stealing a batch of tasks from the global queue.���1.             global.steal_batch_and_pop(local)���LI                 // Or try stealing a task from one of the other threads.���MJ                 .or_else(|| stealers.iter().map(|s| s.steal()).collect())�t�         })���YV         // Loop while no task was stolen and any steal operation needs to be retried.���$!         .find(|s| !s.is_retry())���85         // Extract the stolen task, if there is one.���&#         .and_then(|s| s.success())�T�     })�,� }�<��I����$! [`new_fifo()`]: Worker::new_fifo���$! [`new_lifo()`]: Worker::new_lifo���" [`stealer()`]: Worker::stealer��� [`steal()`]: Stealer::steal���+( [`steal_batch()`]: Stealer::steal_batch���;8 [`steal_batch_and_pop()`]: Stealer::steal_batch_and_pop�����8�$���8�|�$�8�$���8�$���8warnings�D�$�8rust_2018_idioms���$�8�,���8�L�$�8unused_assignments���$�8unused_variables�������������������
�X���@�!$'��L�,�"#$%8@Xopqrstuv}�����d�handle_alloc_error����43�Box�L�	p$a�+
UnsafeCell�Tg�-�}�
���*PhantomData�\���Y�mem�$��MaybeUninit�\�������$��X[\��\L��Yb\����D���I��5epoch�,�Atomic�4�uOwned�,��Backoff�<�� CachePadded�\��!�6����|@��U����Dx�D��Ĕ��u�^aD�T��HI4�>A14%(t���/$�������'������<��"��L��"��"���"��4��&&�����yO�-��*'(\��%%�T��%%�"��!�**�_��	��	�,,�_�	�-/012��	!,�	�"�++
-��
�	�
-<closure_kind>�.<closure_signature>�.<upvars>�..-.��"�����Y��uninit�������B1}-�hn��.��<���.++
/�$���+�����_+�+
0�$��,���:,�����c�b�.+�+
1�$��,��$���5$�����c�b+�+
2�$��,�ܨ�44�_��5�5��,�����3�3
5�$�Ԁ�77�_��	|�,��99�_���L����:;<?!��,�88��[�v��XP���jO���� $� 88�h�� &4� 88���\�����u��� uu�[wdata�x����#k���� �>>�_� �?�?��!$�!����.=�!=
?�$�!��.��' A worker queue.��'���'^[ This is a FIFO or LIFO queue that is owned by a single thread, but other threads may steal���(UR tasks from it. Task schedulers typically create a single worker queue per thread.��)�t�)�E�)���) A FIFO worker:��)�<�)�I��))& use crossbeam_deque::{Steal, Worker};��*���* let w = Worker::new_fifo();�Ĥ* let s = w.stealer();��*�t�* w.push(1);�t�* w.push(2);�t�* w.push(3);��*���*-* assert_eq!(s.steal(), Steal::Success(1));���+! assert_eq!(w.pop(), Some(2));���+! assert_eq!(w.pop(), Some(3));�<�+�I�+���+ A LIFO worker:��,�<�,�I��,)�l�,���, let w = Worker::new_lifo();���,�m�,�t�,�mt�-�mt�-�m�-���--�m��-!�n��-!�n<�.�I4�.�AA�_�.�2y������BCDE ��.!,�.@@�5�5I�5��4�5phantom��4�5��4榦��������\�����u��� ��B�B�BGlobal�����I����/4�/@@�+�+p�+��*�@��n�*{�t�04�0@@���0<�0@@����YRҹ��^=x�.��1'�GG�_�1���$�1���1�II�_�1�JKLMOPQRS��3��1  Creates a FIFO worker queue.��2���230 Tasks are pushed and popped from opposite ends.��2�t�2�E�2�<�2�I��2  use crossbeam_deque::Worker;��3���3&# let w = Worker::<i32>::new_fifo();�<�3�ID�3�HH
J���9��7  Creates a LIFO worker queue.��7���72/ Tasks are pushed and popped from the same end.��8�t�8�E�8�<�8�I��8 �v�8���8&# let w = Worker::<i32>::new_lifo();�<�9�ID�9�HH
K���>#��<%" Creates a stealer for this queue.��=���=@= The returned stealer can be shared among threads and cloned.��=�t�=�E�=�<�=�I��= �v�>���>&�y��>�m<�>�I<�?����H�?H
L�$�?��@'4�@����"�.H�@H
M�$�@new_cap�<�@<�GM�`N�`N�aNNMN��$�.�.��Shared���h��U$��;	���J%<�J����"�.H�JH
O�$�Jreserve_cap�\�K��S��Q)& Returns `true` if the queue is empty.��Q�<�Q�I��R �v�R���R�o�R���R assert!(w.is_empty());�t�R�mܒS assert!(!w.is_empty());�<�S�ID�S���H�SH
P�$�SԬW��T-* Returns the number of tasks in the deque.��U�<�U�I��U �v�U���U�o�V�ܚV assert_eq!(w.len(), 0);�t�V�m��V assert_eq!(w.len(), 1);�t�V�m܀W assert_eq!(w.len(), 2);�<�W�I�W����"H�WH
Q�$�W��Z��X! Pushes a task into the queue.��Y�t�Y�E�Y�<�Y�I��Y �v�Y���Y�ot�Z�mt�Z�m<�Z�I$�Z�����.H�ZH
R�$�Z�$�Z��e��b Pops a task from the queue.��b�t�b�E�c�<�c�I��c �v�c���c�lt�c�mt�c�m�d���d! assert_eq!(w.pop(), Some(1));���d!�n��d assert_eq!(w.pop(), None);�<�e�I�e�������������������;t����H�eH
S�$�e��S�`T�`T�aTTST��$�b��.�с �VV�_ց�W�_W���8���������^�^��^��[�^buf��[����e�S����������������������q�aX�.ÅÅą��:����U��U
W�$���������ۂ'$ A stealer handle of a worker queue.�������)& Stealers can be shared among threads.�������KH Task schedulers typically have a single worker queue per worker thread.����t���E���<���I���)�lʄ��΄�ot��mt���m���Đ��m���-�m�ׅ-* assert_eq!(s.steal(), Steal::Success(2));����(% assert_eq!(s.steal(), Steal::Empty);�<���I<���YY�_Ɇ��}K#V/��Z[���!,��XX�rtه4هXX���(�]]�_���u$������(�__�_���u$����ň�aa�_ʈ�bcdefgh���ވ)����<���I��� �vʼn��͉�o���m���Ԗ� assert!(s.is_empty());�t���m�Ȋ assert!(!s.is_empty());�<��ID�����`��`
b�$��ԩ��ی-́���<���I��� �vƍ��΍�o���m���ܗ� assert_eq!(s.len(), 0);�t���m�ʎ assert_eq!(s.len(), 1);�t��m��� assert_eq!(s.len(), 2);�<���I������"`��`
c�$��������! Steals a task from the queue.����tő�Eؑ�<���I��)�l�������otƒ�mtْ�m������m���-�m�Ó-ُ<���I,������`��`
d�$�����8�؟@= Steals a batch of tasks and pushes them into another worker.�������^[ How many tasks exactly will be stolen is not specified. That said, this method will try to����\Y steal around half of the tasks in the queue, but also not more than some constant limit.���t��E���<���I��� �v����Ţ  let w1 = Worker::new_fifo();�|� w1.push(1);�|�� w1.push(2);�|�� w1.push(3);�|�� w1.push(4);�����£ let s = w1.stealer();���  let w2 = Worker::new_fifo();������� let _ = s.steal_batch(&w2);����" assert_eq!(w2.pop(), Some(1));��ؤ" assert_eq!(w2.pop(), Some(2));�<���I\��������������������p��8���.`��`
e�$��dest�$�����Q���MJ Steals no more than `limit` of tasks and pushes them into another worker.�ئ���^��çXU steal around half of the tasks in the queue, but also not more than the given limit.����t���E���<è�I�Ϩ �v������ ��|����|��˝|ɩ�|ݩ��|� w1.push(5);�|�� w1.push(6);����̡������ ž����-* let _ = s.steal_batch_with_limit(&w2, 2);����"���ū"͟�� assert_eq!(w2.pop(), None);����|�� w1.push(7);�|�� w1.push(8);����_\ // Setting a large limit does not guarantee that all elements will be popped. In this case,����a^ // half of the elements are currently popped, but the number of popped elements is considered����B? // an implementation detail that may be changed in the future.��Ѯ;8 let _ = s.steal_batch_with_limit(&w2, std::usize::MAX);�䑯 assert_eq!(w2.len(), 3);�<���I�ů�������"��`ܯ`
f�$ݯ��$�limit�,�����?���_\ Steals a batch of tasks, pushes them into another worker, and pops a task from that worker.�������^����\ۛ���t���E���<���I���)�l������ ��|����|��˝|���|�������̬������ ž������>; assert_eq!(s.steal_batch_and_pop(&w2), Steal::Success(1));����"͟<���I����������`��`
g�$����$�����X���_\ Steals no more than `limit` of tasks, pushes them into another worker, and pops a task from����
 that worker.�������^����X�����t���E���<���I���)�l������ ��|����|��˝|���|����|����|��������������� ž������LI assert_eq!(s.steal_batch_with_limit_and_pop(&w2, 2), Steal::Success(1));����"͟���ۥ���|����|�������_�����a�����B�����ZW assert_eq!(s.steal_batch_with_limit_and_pop(&w2, std::usize::MAX), Steal::Success(3));����" assert_eq!(w2.pop(), Some(4));����" assert_eq!(w2.pop(), Some(5));����ۥ<���I����������"�`��`
h�$����$����,������jj�_���k�k좲,������i��i
k�$�����!�mm�_���n�_n�׳8ڳ�������^�^��^��[�^���[����e�S����l޳l
n�$߳�����,���"���$���"�Ķ<ʶ�"������"�ӷLٷ�"���,���"��D���"t��$���ww�_��vv�x�y����M�Oɂ����M�OɂxyPR�ʹ $ʹvv�-�-�X�-��*��]����b���,��vv����b���g�XU�t~�-�|���{{�_��̻|
��T����̻�.z��z
|�$��|��,���~~�_���,4I��a�d� ���$��}}�Y�Y\�Yp��X=nۼk�p�,���,��}}̻�.�"�������_���,�������4�����0���������X������lf���]v�,�s��
�����$L�����,�,����
��$�����4<�����"�.��
��this�$���,�����D������_���������sؚ�A%
�sؚ�A%
��VX���,���������,������������ An injector queue.�������b_ This is a FIFO queue that can be shared among multiple threads. Task schedulers typically have����DA a single injector queue, which is the entry point for new tasks.����t���E���<���I���+( use crossbeam_deque::{Injector, Steal};������ let q = Injector::new();�t�� q.push(1);�t�� q.push(2);�������-* assert_eq!(q.steal(), Steal::Success(1));����-* assert_eq!(q.steal(), Steal::Success(2));����(% assert_eq!(q.steal(), Steal::Empty);�<���ID������_���!�GƧ�����$&���$�������\�����u��� �����$���������<��������YRҹ��^=x����)����_���u$������)����_���u$����������_���������<�����
���������_������������#%܈����! Creates a new injector queue.����t���E���<���I���" use crossbeam_deque::Injector;�������#  let q = Injector::<i32>::new();�<���I�����
��ܠ����!�����t���E���<���I���"�������� let w = Injector::new();�t���mt���m<���I$�������.����
��$���$��������!����t���E���<���I���+����������t����t����������-�����-�����(��<���I,����������
��$�����8���:7 Steals a batch of tasks and pushes them into a worker.�ۉ���^��Ɗ\ۛ���t���E‹�<ʋ�I�֋,) use crossbeam_deque::{Injector, Worker};����䏌��t����tÌ��t֌ q.push(3);�t� q.push(4);��������l��� let _ = q.steal_batch(&w);��ˍ!����!�n<���I\��������������
��$����$�����Q���?< Steals no more than of tasks and pushes them into a worker.�����^��͐\ۛ���t���Eɑ�<ё�I�ݑ,�����䖒��t����tʒ��tݒ��t���t�� q.push(5);�t�� q.push(6);��������l�Փ,) let _ = q.steal_batch_with_limit(&w, 2);����!�����!�n�Ҕ����t�� q.push(7);�t�� q.push(8);����_�����a����B�����:7 let _ = q.steal_batch_with_limit(&w, std::usize::MAX);��� assert_eq!(w.len(), 3);�<���I����������"������
��$����$Ę��,֘���?���YV Steals a batch of tasks, pushes them into a worker, and pops a task from that worker.�������^����\ۛ���t���E���<���I���30 use crossbeam_deque::{Injector, Steal, Worker};���������t����t����t����t�����������l���=: assert_eq!(q.steal_batch_and_pop(&w), Steal::Success(1));����!�n<���I��������������
��$����$�����X���fc Steals no more than `limit` of tasks, pushes them into a worker, and pops a task from that worker.�������^����X�����t���E���<���I���3����������t����t����t����t����t����t�����������l���KH assert_eq!(q.steal_batch_with_limit_and_pop(&w, 2), Steal::Success(1));����!�n�������t�������_�����a�����B�����YV assert_eq!(q.steal_batch_with_limit_and_pop(&w, std::usize::MAX), Steal::Success(3));����! assert_eq!(w.pop(), Some(4));����! assert_eq!(w.pop(), Some(5));�����<���I����������"�����
��$����$����,�������)����t���E���<���I���"������������ԫ� assert!(q.is_empty());�t������� assert!(!q.is_empty());�<���ID���������
��$��ԝ��Ҁ-* Returns the number of tasks in the queue.����t���E���<���I���"��ځ��������܋� assert_eq!(q.len(), 0);�t����ܾ� assert_eq!(q.len(), 1);�tނ���� assert_eq!(q.len(), 2);�<���I������"����
��$��䓎����_���������$������.����
��$Î���"����_�����_��З8ӗ�������^�^��^��[�^���[����e�S�����ח�
��$ؗ�ޗ�ȟ����_͟����������ߟB? Returns `true` if the queue was empty at the time of stealing.����t���E���<ɠ�I�ՠ85 use crossbeam_deque::Steal::{Empty, Retry, Success};�������$! assert!(!Success(7).is_empty());��á&# assert!(!Retry::<i32>.is_empty());������%" assert!(Empty::<i32>.is_empty());�<���ID���������
��$����� ���30 Returns `true` if at least one task was stolen.���t��E���<���I���8��դ��ݤ(% assert!(!Empty::<i32>.is_success());����(% assert!(!Retry::<i32>.is_success());�������%" assert!(Success(7).is_success());�<��IT���������
��$���ʩ���>; Returns `true` if the steal operation needs to be retried.�ħ�ţ�Eߧ�<��I��8��������&# assert!(!Empty::<i32>.is_retry());���$! assert!(!Success(7).is_retry());�������%" assert!(Retry::<i32>.is_retry());�<���IDѩ����ک�
��$۩���!�Ϫ74 Returns the result of the operation, if successful.����t���E���<���I���8��������-* assert_eq!(Empty::<i32>.success(), None);����-* assert_eq!(Retry::<i32>.success(), None);�����.+ assert_eq!(Success(7).success(), Some(7));�<���I<�������
��$�����T���<9 If no task was stolen, attempts another steal operation.�������]Z Returns this steal result if it is `Success`. Otherwise, closure `f` is invoked and then:�����@= * If the second steal resulted in `Success`, it is returned.����]Z * If both steals were unsuccessful but any resulted in `Retry`, then `Retry` is returned.����:7 * If both resulted in `None`, then `None` is returned.�ֱ�tޱ�E��<���I���8��²��ʲ>; assert_eq!(Success(1).or_else(|| Success(2)), Success(1));����96 assert_eq!(Retry.or_else(|| Success(2)), Success(2));�˳��ӳ63 assert_eq!(Retry.or_else(|| Empty), Retry::<i32>);����63 assert_eq!(Empty.or_else(|| Retry), Retry::<i32>);�ɴ��Ѵ63 assert_eq!(Empty.or_else(|| Empty), Empty::<i32>);�<���I<������������ʆ���ʆ�.�׵ʆ�.��D�
��ʆ$�����LN�������_�����_��ܸ8߸�������^�^��^��[�^���[����e�S�������
��$����κ+����_Ӻ���H��ϼX���=: Consumes items until a `Success` is found and returns it.�»��ʻXU If no `Success` was found, but there was at least one `Retry`, then returns `Retry`.����#  Otherwise, `Empty` is returned.�LҼ�����������ܼ�H��쉽���H�|��
�����	$߼>@��0������\�&4�&���(���������$�'������$�'������(�&����!#������&�
�,�& �&
�(�&���_�!#�������^�^��^��[�^���[����e�S������&�
�,�&���&����!�(*-/8�9=?����.��&�
��&H�&�����46��������&�
�L�&�������+( Possible outcomes of a steal operation.�ߘ�t��E�����IF There are lots of ways to chain results of steal operations together:����<ę�I�̙>; use crossbeam_deque::Steal::{self, Empty, Retry, Success};�������MJ let collect = |v: Vec<Steal<i32>>| v.into_iter().collect::<Steal<i32>>();�ݚ���:7 assert_eq!(collect(vec![Empty, Empty, Empty]), Empty);����:7 assert_eq!(collect(vec![Empty, Retry, Empty]), Retry);��כDA assert_eq!(collect(vec![Retry, Success(1), Empty]), Success(1));�������EB assert_eq!(collect(vec![Empty, Empty]).or_else(|| Retry), Retry);���OL assert_eq!(collect(vec![Retry, Empty]).or_else(|| Success(1)), Success(1));�<���I-\��	,������_���p��8��������������EG,�����0- The queue was empty at the time of stealing.�	A���TV���_�ɞ.+ At least one task was successfully stolen.�	_��
��__�����������,�����,) The steal operation needs to be retried.�	=���PR���H&ӝ����_�;?����_E���n����fi���������&ӝ�
��Lӝ��'ޝ����_��4����"%S�Z\_a8�koq����.�'ޝ�
��ޝ (�����_���4���()�����_��4����,/SU�����)��
��,�~1�1B2	�2�4!>v>u?"�@'�A,�B1�D6DF;��B��IGN�ES�DX�@]��d�<i�p^:u��|�6����C6�]5������,3�51�n)�P(�P&�Î�l#�ʘ�<!�����������J����������E���&��.4F
:L
@F�	L=	RC	X/^5dsj�p+H`z���3Stealer::steal_batch�steal_batch_and_pop()�
new_fifo()�Worker::new_fifo�Stealer::steal_batch_and_pop�Steal::Retry�
new_lifo()�Worker::new_lifo�	stealer()����Worker::stealer�steal()�Stealer::steal��
�
steal_batch()���˥�������ʦ����ߦ������
�@������˥����������ʦߦ����
X���������H����������������������I�I�I�H�J������>Block should never be zero-sized, as it has an AtomicPtr field>���A\�7R�|�*8p��4���^����w�+oxb>cX��=81���RC��XD���)�
��WLf���{9Q�Y��A�TN����K]@&��_��$�@�V�j��F(��]������X��nq^�����8�xu���Pr��
��r�h���rP�7$:~k�h�ê���f��ĊS�zS�0�i{6vٔo\w�v<�L� @�K�:��j^�7i��8Н�!��R�+&��t�o�� D$���E�p
�9%x._�v.=����!?
�ȚR�>��6��A���4�q�$&D� q�s;�e��kj��)�^�LJ��Ŋ��zO7�0�]Rt)E��o{�)��R#�������Dx�ЃV�m76	�����/�XF�B"?���Γ�e������žP�h��,8���y�ͨq��Jlᜡ����	�r��/��ۤ��"B�����}m��P[����@L#��J�ƚD;~/��Z��V�����������t����Ψ��#ߎ��D��[
b��I��O�RZ��7�����pڱ�1��J��<1k��k�`�ӊR��lG��ܵ�ҋ�
7E��;�
9���˿!�����I٦B/?%�枂B\7��+�\Gl�*H�R�_�4T��𢒍�oz�j4+mo�,�L��
��8EU�k[���|�B���Bj�>�!���Ta�#h9.|�x�a0* � T&Ǎ�%����R`R��	#��.�����}�5S�����Q_e�j����D�#�������D��"T]t����_�u���;��>L�}ڴ�JR���r�
��W�sJ��CH(IL?�+J����U����]J����^PEȷ�Rh��;
��|���j���Ԏ[s����W�8O��x+�J%��l.�T3�I�]p)�%��9�A$�>��eTs@��
����R�:C���u������I�g�Gy���g�ڪ����OTn�n��	�O?�@���(!y�	�86J�ti� */�;���ʊ�./<.��5/�=�"c��*��t���e8�p�2b켦^���ڀ3���h�_�&:U��oX*-��\<1�3����Uw�K���:��Z|�ӽB�y1	�k3@|p�7����g�ņMD15k�K�����PB���s��v9<B���k�6��,8aa�ƙdTsJ�%�2���;��c��`�����w�@�/_�a3uW�܎j�%��J��s�1��,�Rj����PH4мV���)�)va3��+��Z����J�Q�ڌ�g	��˂yǦiL��]���G"`�\��A��Ħ��mT!
�[�P��W�	�V�����(*V纔����eRI�X�8A<�f!D�+�~C�0
]XR�$�6m�T�ַ$�n�����ߐQ�N^�+�C��YR{�$y	������r��
��,[8���M\��ۑs6�e��i��mC�x&
�ͼLR�N���Šۃ��S���;f*_�!yފ,�ݠ�CH�C��η��銾2���8��=!��������2	�5�D�[!���5�<��u_�'���{��$t, ��8aэ
9
�f"�E�	�}հ�u�\�����a�Dn_�}���)V�e�L#�Z�D�+�	��',f�W����a!Iv�gU_��Ȁ.bx'r�;�4d�X^/gs���}D�9M$���oϒ����:n^O��ݎ�J+L{NI�݇k��Zc��.�1(U����Xa�S����ⵌ���M|�l־�^3��^b��F�`�k��;���s<±�W]QS�KZ���/Ϙ�`��~.�������a,7(�c�;�>�MGK/���N���C�����)�b|����e�+�-R�Ɔ9��%P"�/C?>�0�����煀l�PN$���&
�{�җ|܅	
�Tɒ&��/�hv!ݱ�ƀ���*����C%�6=�9�����W���Mȃ���:]�	(6Ԭ��O����)9�[rUo]��p��YqhJ���J�����j��w������l�����A�P$�F�"'B�`�'�G1e�ӇT������.c�l���V_��u�)��*njQ�Q�J���X�Y�_r�pdP۱�ć7�Yɽ�w �ϖg�Ϻ�Iv�6?%��p5�!@�!8
�Q���v��_��)NZ��/Y!��~4�_ƒ�~�LY�S�m��]��l�l^W��Vf����:�<��MN���1����'>��;��&Cs.��pZM~J��}�sn���=XAdz*�HP�.��Ok��*X�@)�;9x<f��U����������������n+,T�+�.�.�./Z/t/�/�/�/<01D1�12d2�2�2"3s3�3�3O4�4�(4�8�9�9�9:^:�:�;=<>�>;?�?�
@B
C�DE>EjF�H�H�HIBI�I�J�KM�"PMUo$W[B[�[�[�\�\�\�\�\�\]%]�]�]8^o^�^_`_�_�_�_i`�`a�a�a�a�d�deEe�e�ef>f�	f�g�h�i� k�n� pH
tou�v4w�w�w�x�x�z|�}:]���X���7�s������d�z���E�c������f���r������������H�����m+�+W���G/�/�/�23]3o4�8L:~	:!EH�H/IcI&[�[�]Z^_�_�a�dpe�e�ea	fw�w�x��{�g�o��t���U�����������������z���









((('(l+�+�.�.�.	/^/x/01Y1�12�2(3w3�3�3�4z8�8�9�9�9�;�<�=Q>P?�@�A�B!DTEJH�H�H\J�K�LP�TW�ZX[�[�\�\�\�\�\�\],]�]�]�^�^_e_�_``�`"a�a�aId�d�defqgLhqidkRn�p�s.u�vJw�wQz�{i}
Â����=�w�����߆'��������7�]���ݍ�R�x�,����+�+�+�+.#.)./.5.;.>.D.J.P.W.^.b.i.o.v.{.�.�.�.�.�.�.�.�.�.�.�.�.�.�.�.�.I/V/p/�/�/�/�/�/801?1�12`2�2�2�233b3o3�3�3K4y4�4�4�8�8|9�9�9:M:Z:�:�:�;�<7>�>6?�?�@B	C�D�D+E8EeF�H�H�H�H�HI0I=IrII�J�KM�PGUiW[0[=[�[�[�[�\�\�\�\�\�\
] ]�]�]�]3^]^j^�^__[_|_�_�_�_�_c`�`a�a�a�a�a�d�d�d�d?eqe~e�e�e�e�e9f}f�f�g�h�i�k�n�pCtju�v"w/w�w�w�w�x�x�x�z|�}4J�W�����R�����	���!�'�-�3�o�����ʆ��_�u���@�a�ʈ����a���H�o�ƍ���c�����Ŏ����ďӏB�{���ΐݐ0�4�9�>�C�H�M�R�W�\�a�f�k�p�w�~�����������������������‘ǑΑՑڑߑ���������
����#�(�-�4�<�B�H�N�T�\�d�j�p�v�|��������������+�+�+&.,.2.8.A.G.M.T.[.e.l.s.~.�.�.�.�.�.�.�.�.�.�.�.�.�./K/Z/t/�/�/�/1D1�12�2�23$3d3s3�3�3{4�4v8�8�8�9�9�9O:�:�;�<�=<>;?s@�A�BD-E>EEH�H�H�H�H2ItIFJ�K�L�O�T�V�Z2[B[�[�[�\�\�\�\�\�\]']�]�]�]_^o^�^__`_�_�_�_i`�`a�a�a�aDd�d�d�dese�e�eff[g6h[iNk<n{p�su�v$w4w�w�w�x;z�{S}�~��L�������|���$�*�0�9�u�����̆��������5�J���ɍ�P�e�����Ǐ�~�ѐߐ3�7�<�A�F�K�P�U�Z�_�d�i�n�u�|�������������������������ő̑ӑؑݑ�������������!�&�+�2�9�?�E�K�Q�Y�a�g�m�s�y���������������.�.�./S/h/�/�/�/�/�/%0�0-1�1�1F2y2�2�233>3l3�3�3�3d4�4�4�8�8�8�9�9�91:W:s:�:�;�<%>z>�>y?�@B�B�D�DE5EIF_H�H�H�H�H�HI:IWI|I�J�K�L�PULW�Z[:[[�[�[j\�\�\�\�\�\]]B]�]�]^M^g^�^�^_'_o_�_�_�_�_V`�`�`:a�a�a�a`d�d�d�de\e{e�e�e�e�e,fUf�f�gvh�i�k�n�ptUu�v
w,wrw�w�wdx�x�xxz|�}�T�t���4�o������E�����Æ��N�p���)�Q���ۈ�J����A�h�����\�����Ž��e���Џ-�c�����ڐ��.�.�./M/`/z/�/�/�/�/0M0%1v1�1:2f2�2�2�23+3f3y3�3�3Q4}4�4|8�8�8�9�9�9:Q:`:�:�;�<>n>�>m?�@�A�BD�DE/E<FLH�H�H�H�H�HI4IDIvIuJ�K�L�PU?W�Z[4[r[�[�[]\�\�\�\�\�\]]/]�]�]�]:^a^�^�^
__g__�_�_�_M`�`�`%a�a�a�aKd�d�d�d
eGeue�e�e�e�e#f@f�fzghh�i�k�n�ptGu�v�v&wdw�w�wVx�x�xjz�{�}ԂN�_���&�Z�����
�?�y��������@�j����K���Ո�<����8�_�����S�z�����͎�V���ʏ�N�����Ԑ��.�.�.1/l/�/�/�/)0�011�1�1J2�2�23G3�3�3�3m4�4�8�8�9�9�9J:|:�;�<)>~>�>}?�@B�B�D�DEMFiH�H�H�H-IaI�J�K�L�P UPW�Z$[�[�[n\�\�\�\�\�\]]L]�]^W^�^�^+_s_�_�_�_[`�`�`Da�a�ajd�d�dene�e�e1f_f�g{h�i�k�n�ptZu�vwww�wix�x}z|�}$-�~�9�y��G�����Ȇ��S�r���.�S���݈��O���F�m������a�������j���2�x��� �/01[1�12�2*3�4{8�;�<>S>R?�@�A�B"DUEKH]J�K�LP�TW�ZY[�[.]�^�^`�`�`$aJdfrgMhriekSn�p�s/u�vKw�wRz�{j}������?�����(��������^���y�-����01\1�1 2�2�4�;�<>T>S?�@�A�B#DVE^J�K�LP�TW�ZZ[�[�^`�`�`fsgNhsifkTn�p�s0u�vLw�wSz�{k}Ƃ����(������֌ߍ.����0<01H1�12�2�4�;�<�=@>�>??w@�A�BD�DCEKJ�K�L�O�TW�ZG[�[t^�_n`�`	f`g;h`iSkAn�p�su�v9w�w@z�{X}�~��������Ά������L�̍g����
O
Y
c
nx����!+5?���
�
�
�
I����U/�/�/�23n3�4�8Y:�:7E�H�H<I~I<[�[�]i^_�_�a�d}e�e�e�f.w�w�xV�������Ď�ҏ��ܐ�$zS�[�|�,�]#yR�Z�{�+�����qK��S�t�$z�uO��W�x�(~�0081�1�1Q2�2�4�;�<0>�>�?�@
B�B�DTF�J�KM�P'UWW�Z�[u\�^c`�`a9f�g�h�i�k�n�p'tbu�vwqx�z|�},9�A��X�3���T�r�:�(�`3�dj+�+/�/�/d2�2"3O4t8:^:ECH�HIBI[�[%]8^�^�_aBdEe�e�e>f�v�w�x]�X�7�s�����h�~�I�ӈ��3���N���ˎ��L���?/U3�8wH�]�^�axdU���3/I3�8kH�]�^}aldI���36=AHTX\`dhlptx|���������������������'+26=DHOXdosz���������������	"&-<KYfjx������������������)F`������������� '+2COV]inrz�����������					&	*	2	9	=	E	M	U	]	e	m	u	}	�	�	�	�	�	�	�	�	�	�	�	�	�	�		



&
*
2
:
C
G
K
O
S
W
d
p
u
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�

"*26>FJRV^flrx~��������������������� '.5<CJQX_fmt{������������������

B/X3�8zH�]�^�a{d_�g�Č̌ߌ�/�/�/�/�/�2p4�:�:�:�:�:�:�:�:�:"EjIkIlImInIoIpI'[�[[^�_�_�_�_�esftfufvfwfxfyfzf{fw�w�x�x�x�x�x��}����W������Đ�����_�/�/�23u4L:�:'E�H/IqI,[�[\^�_pe�e�e|fw�w�x����
�t���\�߈�������z�ɐ
F3|J�Jt	�J}�J�core_intrinsics�derive_clone_copy����A\�7R�t�V�������&,���Z���A\�7RϚ7�Qp^@�'T}���fmt_helpers_for_derive��_�_�A\�7R�ϵG�s��������Z�panic_internals��generic_assert_internals����A\�7RF�w	o�9$crate::panic::panic_2021����]����S�R�A\�7Rnb�;A,M��ʝ%5���A\�7R�Iə:)T�	RMe�f\�	derive_eq������A\�7R$v0�;Iq�txV�������A\�7R��!��D��L�L��A\�7R�X��W���iU���������A\�7R�ؒڀ,lG$crate::const_format_args�� �"]���Z
fmt_internals�const_fmt_arguments_new����A\�7R�)g��\|���M�����A\�7R.�~^am�~	$�u���������A\�7R�*�R���~$�&9������A\�7Rٶx�k0��$V��O\�����A\�7RP���3
�	<P6�����A\�7R3�,�#�/\!�߄���xۈۘ�|�����t��ۀیۨ��ߜ۬��%���Y���@�V�(�t�
�bު߈���������F���x���dߓ�Rޚ�I����߽�0���ް4ODHT #��%��9�A$�vT�ַ$�n�RI�X�8A�|�B���BW�!��R�Q�ڌפ7i��8Н��4%��*��t������	�r�8�:�<s@��
��x8O��x+rTɒ&���%����R\!��~4<1k��kG�;��&Cs��h�_���������$t, ���M|�l���~.����o�� D$��ti� */�q�$&D�&���C%�6=��	��',f����F(��]���)�e�+�-R���~C�0
]X��.�1(U��־�^3�����PH4мV��i{6vٔ��ć7�Y�h��,8�5�	�86J���e8�p�����)9�[r�5�<��u���s<±�����=XAd�枂B\7�O����Dx��.���D��"c�^PEȷ�m]���G"`��<�f!D�+��z*�HP�.�J%�s�Uw�K���
��WLf��ݎ�J+��l�PN$�������OTn}�,�Rj�ٟ�_�4T���RC��YR{˵U�k[���V�+�\GlP�I�]p)�u�Q�N^�+�����Xa�S���;f*_����Vf����e��i��m�Ħ��mT!
�����oz�jS��E�p
� ���pڱ�Eh���rP�7J��s�1���_r�pdP�
.��pZM~k3@|p���A\�7R��.���^����8����D��[
B�`�ӊR�H�lG��ܵI�}m��P[�;�ۃ��S��K�:��j^�!yފ,�ݿJ�ƚD=;~/��Z��>�����M��|���j�oUo]��p���"B����:�J�����j���l�l^W
�ȚR�>#�3����(6Ԭ��O��.=����!?"/gs���}�2b켦^Ӈ�&:U��oX���N���C����
��r�0�����������)�*-��\<1����#�A�@���(!y�$�@�V�j
��Z����J�Γ�e���3��4���^��*H�R�Q2	�5�D���oϒ������ҋ�
7EJ���žP�4;���ʊ�g	��˂yǥ���/Ϙ�`�o\w�v<����8��=!���w������ƀ���*�����W�qL#�Z�D�+������.c��
��8EU��y�ͨ6�l���V_�1��J��Fη��銾2��c��`��K]@&��_���R#���-R�$�6m���_ƒ�~�L�b|�����4+mo�,�LTLR�N���¼V�������?�����(*V�$y	���膶��R�:C�y$:~k�h����}�5_>�MGK/��)NZ��/Yoxb>cX�B"?���2��u����z�n��	�O?~�W�	�V�C�x&
�ͼ���_��Dn_�}��l.�T3t)va3��+��Ϻ�Iv�
�9��%P"�I٦B/?%N>��eTw�v9<�/�=�"c�xu���Pr�,8aa��A�TN
���˿!LD�9M$����P$�F� � T&Ǎ[����'>�*X�@)�;9!9%x._�v!./<.��5��MD15k��/_�a3uW���|�*8p��=81�L� @�\��A����RC���/C?>��XF�1^b��F�`�L{NI�݇��YqhJ������@L#��<���zO7�0*�ƙdTsJ�����)V�e�����X�Y	:��Z|�k��Zc�����:]�	�:n^O����_�uev�gU_���"'B�`�'��;�4d�X^�����f����I�g�Gy{���g�ڪ|B���k�6��q��Jlᜡ7�V�m76	/X��nq^�Y�S�m��]��Ok�� � q�s;�e'�]Rt)E+����t���@T]t���d����w�@��Ȁ.bx'r�ӽB�y1	ڏĊS�zS�0��o{�),�/�hv!ݱ�J��}�sn��ڀ3����kj��)�(�|܅	
��W]QS�KZ�^�LJ���)�/��ۤ�9���;��>Lf��Ta�#h9Y纔����e�
�f"�E�	���Ԏ[s�p�����߳�u�)����w �ϖgW����a!I���MN���1�����/�0`R��	#]�RZ��7��DXD���)�.|�x�a0*Z8
�Q���v����������!@�!܎j�%�ݝW�sJ��CHi����a,7�6?%��p5x<f��U��"���w�+�}ڴ�JRg���r�
��hRh��;
n�����a�����Mȃ��9�����W�(IL?�+J�j��;�
9K�[�P���}հ�u�\����U���k��8aэ
9�B���s��&
�{���G1e�ӇT���6��A�$j�>�!�X,[8�����k��;���{9Q�Y�	M\��ۑs6�*njQ�Q�J����ⵌ��_e�j����a����(�c�;��b��I��OC_�'���{�K�����P�%�2���;���+&��t���r��
���[!�����l�����A�iL���]J���lD�#����b��CH�C���7����g�őS�����Q`F7 !	kNC_��q�����
)�59�u6G|a��x�G.w���c��,W�+�Jd}9:j2���l�hM_I@qb^7��l�x����e�s6E}��)����Xc�6����5{rXm?������H���)�������e�``_in"nUYnT5+Wn���>����i,x��dB��	��������o<5%�Jkso"�L����yc���0������K�����o�|�|1"T\�f`NnB&��o&a�\���+C���|a�Y,bq��G+^��	>�M��*�19s'����VLF`�����;�Z�`����rt������y�AU�
0�C�{������K�O�,�r]�{	
e��/�v<U��JPS.D��2tlM9mX7��	���s{-bW&�2~oi3$������gQ;�A�n$�����{�����)aL����A+����W��M.S��������rijc]Dtc���%���Y}f`'�?(���Q���J`�
 q�Zo���pbF7 !	kNC_��q��d/home/palash/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/crossbeam-deque-0.8.6/src/deque.rs� ��)�������@0�/���<##N5-^a$.1c!)7%<(8!5(
 :/
@20a@92ac_;AK1bb_:<D#@7Tb^'<;:,9&'TY6'86
'-'
&
_V* .""* ."">'3!B4+%8%+%-6(';
'""
%7%+%-6(';
'""
*E%+*'!
F.99:(S*B#
#4"U)Nc#D
_,+==2%-E)D+4"&*
.%$ %992%$   !99*&%$"99:,.%(0-(
'5
*%a7E$%$&&#%*9:.%
0EI//B!-4=_P5/-+=1)BL-XQ34DD"= ##/#323&P)HU_S%==
#?(*L* ..)>'!,,.%$ %:)92%$   !:)9*&.$22&!:*]\ -
# 9$!
;G6?LF]
5!
#6Eca%%%$''?5Rc]%%%2''$dfG@!X3!%+
!>*]\ -
# 9%!
2B"26-BG>M$&1%SQ&1%SbHTN+8./"):A^[G62Y_;90I/4,#3BKXR ##/#323&Y(J9d+5S%)T11!JA;;77
*;a7: dca.%%C'F=dc].%%Q'$dfG_''$_3-;
!>*]\ -
# 9%!
2F"26-BG':>M$&1%WQ&1%WbGTN+<./"=):AGa=):'C^[G62[75,E+0(3AKXR ##/#323&Y(UQd+5T11!JA;;77
*;a7: 6$'!
$? (?;8+2"21&5&@
>+!, M ,9%-
)JYT&L<--+&:!
V;_+$7K>Nc
G# & cE,..)$$M--"6..,..,"
&'("&'!"&@A#A0Y%"@AdEA60/9"#"T1MLNNL5ECCE$
&0!22-&&<=A,Y%"
0&-@K0%S@&
.X
!
L)1VE,@F==bH)P/!
?ca1!$#&&?5Dca1!$1&&#dfG? X&<=A,Y%"
!&-@K0%c.@&E;266A7
&+.X
!
2."6->L)1VE,@FI "-*M+;@R"-*M+;@e.?`@UbH)/.@T7
^ca8!$B&FfhAkc]8!$P&#dfG^&&#_&<=A,Y%"
!&-@K0%S@&E;266A7
&+.X
!
22"6->L)1VE,@F=/ "Q-*Q+;@R"Q-*Q+;@e.?`@UbH)/.@T7/
.'! %;;'2'!   !>CC[@)--@<:<:K1@@*  [1
334!%%c!4(2E;F90"64(
%?,J?N;;EFP&531G=)+*%"
8=--*''
C=+)*%"
<=223(.
AbEb?=C>;;;.
!!'3(!
"?,7,
.B]()
*#/.

h��VYqo���Jb/home/palash/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/crossbeam-deque-0.8.6/src/lib.rs� 	͒�c���Jh[���z�j%`cd`d\
^G%``[c`,&Wd"c8c79EI66!:!@#H2MNZ%9'%%# ,<

*?	#��I(��MS��5mw��x86_64-unknown-linux-gnu��8�r���G$7�ݠcrossbeam_deque�-39548485313d4b56��A\�7R��� ���������������������������������������������������������������������������H�4�4hh�Irust-end-file