import itertools
import json
import os
import unittest

from transformers import AddedToken, LongformerTokenizer, LongformerTokenizerFast
from transformers.models.longformer.tokenization_longformer import VOCAB_FILES_NAMES
from transformers.testing_utils import require_tokenizers, slow

from ...test_tokenization_common import TokenizerTesterMixin

@require_tokenizers
class       snake_case					(      UpperCamelCase_   ,						unittest.TestCase						):
  lowercase_			=     LongformerTokenizer
  lowercase_			=     True
  lowercase_			=     LongformerTokenizerFast
  lowercase_			=     True




  def 	__lowercase(      self     :	str				)->       List[Any]:




       """simple docstring"""
       super().setUp()

       # Adapted from Sennrich et al. 2015 and https://github.com/rsennrich/subword-nmt
       SCREAMING_SNAKE_CASE__				:				int			=		[
           '''l''',
           '''o''',
           '''w''',
           '''e''',
           '''r''',
           '''s''',
           '''t''',
           '''i''',
           '''d''',
           '''n''',
           '''\u0120''',
           '''\u0120l''',
           '''\u0120n''',
           '''\u0120lo''',
           '''\u0120low''',
           '''er''',
           '''\u0120lowest''',
           '''\u0120newer''',
           '''\u0120wider''',
           '''<unk>''',
       ]
       SCREAMING_SNAKE_CASE__				:				str			=		dict(zip(UpperCAmelCase__     , range(len(UpperCAmelCase__				)				)				)				)
       SCREAMING_SNAKE_CASE__				:				Optional[Any]			=		['''#version: 0.2''', '''\u0120 l''', '''\u0120l o''', '''\u0120lo w''', '''e r''', '''''']
       SCREAMING_SNAKE_CASE__				:				List[Any]			=		{'''unk_token''': '''<unk>'''}

       SCREAMING_SNAKE_CASE__				:				List[str]			=		os.path.join(self.tmpdirname     , VOCAB_FILES_NAMES['vocab_file']				)
       SCREAMING_SNAKE_CASE__				:				Any			=		os.path.join(self.tmpdirname     , VOCAB_FILES_NAMES['merges_file']				)
       with open(self.vocab_file     , 'w'     , encoding='utf-8'				) as fp:
            fp.write(json.dumps(UpperCAmelCase__				) + '\n'				)
       with open(self.merges_file     , 'w'     , encoding='utf-8'				) as fp:
            fp.write('\n'.join(UpperCAmelCase__				)				)




  def 	__lowercase(      self     :	Dict     , **a_     :	Optional[int]				)->       Tuple:




       """simple docstring"""
       kwargs.update(self.special_tokens_map				)
       return self.tokenizer_class.from_pretrained(self.tmpdirname     , **UpperCAmelCase__				)




  def 	__lowercase(      self     :	Any     , **a_     :	Tuple				)->       Any:




       """simple docstring"""
       kwargs.update(self.special_tokens_map				)
       return self.rust_tokenizer_class.from_pretrained(self.tmpdirname     , **UpperCAmelCase__				)




  def 	__lowercase(      self     :	Any     , a_     :	Any				)->       List[Any]:




       """simple docstring"""
       SCREAMING_SNAKE_CASE__				:				List[str]			=		'''lower newer'''
       SCREAMING_SNAKE_CASE__				:				Optional[int]			=		'''lower newer'''
       return input_text, output_text




  def 	__lowercase(      self     :	List[str]				)->       Optional[Any]:




       """simple docstring"""
       SCREAMING_SNAKE_CASE__				:				Optional[int]			=		self.tokenizer_class(self.vocab_file     , self.merges_file     , **self.special_tokens_map				)
       SCREAMING_SNAKE_CASE__				:				Tuple			=		'''lower newer'''
       SCREAMING_SNAKE_CASE__				:				List[Any]			=		['''l''', '''o''', '''w''', '''er''', '''\u0120''', '''n''', '''e''', '''w''', '''er''']
       SCREAMING_SNAKE_CASE__				:				List[Any]			=		tokenizer.tokenize(UpperCAmelCase__				)  # , add_prefix_space=True)
       self.assertListEqual(UpperCAmelCase__     , UpperCAmelCase__				)

       SCREAMING_SNAKE_CASE__				:				Optional[int]			=		tokens + [tokenizer.unk_token]
       SCREAMING_SNAKE_CASE__				:				Union[str, Any]			=		[0, 1, 2, 15, 10, 9, 3, 2, 15, 19]
       self.assertListEqual(tokenizer.convert_tokens_to_ids(UpperCAmelCase__				)     , UpperCAmelCase__				)




  def 	__lowercase(      self     :	List[Any]				)->       Optional[int]:




       """simple docstring"""
       SCREAMING_SNAKE_CASE__				:				Tuple			=		self.get_tokenizer()

       self.assertListEqual(tokenizer.encode('Hello world!'     , add_special_tokens=UpperCAmelCase__				)     , [0, 3_1414, 232, 328, 2]				)
       self.assertListEqual(
           tokenizer.encode('Hello world! cécé herlolip 418'     , add_special_tokens=UpperCAmelCase__				)     , [0, 3_1414, 232, 328, 740, 1140, 1_2695, 69, 4_6078, 1588, 2]     , )




  @slow
  def 	__lowercase(      self     :	List[Any]				)->       Tuple:




       """simple docstring"""
       SCREAMING_SNAKE_CASE__				:				Any			=		self.tokenizer_class.from_pretrained('allenai/longformer-base-4096'				)

       SCREAMING_SNAKE_CASE__				:				Union[str, Any]			=		tokenizer.encode('sequence builders'     , add_special_tokens=UpperCAmelCase__				)
       SCREAMING_SNAKE_CASE__				:				str			=		tokenizer.encode('multi-sequence build'     , add_special_tokens=UpperCAmelCase__				)

       SCREAMING_SNAKE_CASE__				:				str			=		tokenizer.encode(
           'sequence builders'     , add_special_tokens=UpperCAmelCase__     , add_prefix_space=UpperCAmelCase__				)
       SCREAMING_SNAKE_CASE__				:				Union[str, Any]			=		tokenizer.encode(
           'sequence builders'     , 'multi-sequence build'     , add_special_tokens=UpperCAmelCase__     , add_prefix_space=UpperCAmelCase__				)

       SCREAMING_SNAKE_CASE__				:				int			=		tokenizer.build_inputs_with_special_tokens(UpperCAmelCase__				)
       SCREAMING_SNAKE_CASE__				:				List[Any]			=		tokenizer.build_inputs_with_special_tokens(UpperCAmelCase__     , UpperCAmelCase__				)

       assert encoded_sentence == encoded_text_from_decode
       assert encoded_pair == encoded_pair_from_decode




  def 	__lowercase(      self     :	str				)->       str:




       """simple docstring"""
       SCREAMING_SNAKE_CASE__				:				List[str]			=		self.get_tokenizer()

       SCREAMING_SNAKE_CASE__				:				Optional[int]			=		'''Encode this sequence.'''
       SCREAMING_SNAKE_CASE__				:				int			=		tokenizer.byte_encoder[''' '''.encode('utf-8'				)[0]]

       # Testing encoder arguments
       SCREAMING_SNAKE_CASE__				:				Dict			=		tokenizer.encode(UpperCAmelCase__     , add_special_tokens=UpperCAmelCase__     , add_prefix_space=UpperCAmelCase__				)
       SCREAMING_SNAKE_CASE__				:				int			=		tokenizer.convert_ids_to_tokens(encoded[0]				)[0]
       self.assertNotEqual(UpperCAmelCase__     , UpperCAmelCase__				)

       SCREAMING_SNAKE_CASE__				:				Any			=		tokenizer.encode(UpperCAmelCase__     , add_special_tokens=UpperCAmelCase__     , add_prefix_space=UpperCAmelCase__				)
       SCREAMING_SNAKE_CASE__				:				Optional[int]			=		tokenizer.convert_ids_to_tokens(encoded[0]				)[0]
       self.assertEqual(UpperCAmelCase__     , UpperCAmelCase__				)

       tokenizer.add_special_tokens({'bos_token': '<s>'}				)
       SCREAMING_SNAKE_CASE__				:				Optional[Any]			=		tokenizer.encode(UpperCAmelCase__     , add_special_tokens=UpperCAmelCase__				)
       SCREAMING_SNAKE_CASE__				:				List[Any]			=		tokenizer.convert_ids_to_tokens(encoded[1]				)[0]
       self.assertNotEqual(UpperCAmelCase__     , UpperCAmelCase__				)

       # Testing spaces after special tokens
       SCREAMING_SNAKE_CASE__				:				Any			=		'''<mask>'''
       tokenizer.add_special_tokens(
           {'mask_token': AddedToken(UpperCAmelCase__     , lstrip=UpperCAmelCase__     , rstrip=UpperCAmelCase__				)}				)  # mask token has a left space
       SCREAMING_SNAKE_CASE__				:				Any			=		tokenizer.convert_tokens_to_ids(UpperCAmelCase__				)

       SCREAMING_SNAKE_CASE__				:				Dict			=		'''Encode <mask> sequence'''
       SCREAMING_SNAKE_CASE__				:				str			=		'''Encode <mask>sequence'''

       SCREAMING_SNAKE_CASE__				:				int			=		tokenizer.encode(UpperCAmelCase__				)
       SCREAMING_SNAKE_CASE__				:				List[Any]			=		encoded.index(UpperCAmelCase__				)
       SCREAMING_SNAKE_CASE__				:				int			=		tokenizer.convert_ids_to_tokens(encoded[mask_loc + 1]				)[0]
       self.assertEqual(UpperCAmelCase__     , UpperCAmelCase__				)

       SCREAMING_SNAKE_CASE__				:				str			=		tokenizer.encode(UpperCAmelCase__				)
       SCREAMING_SNAKE_CASE__				:				Dict			=		encoded.index(UpperCAmelCase__				)
       SCREAMING_SNAKE_CASE__				:				int			=		tokenizer.convert_ids_to_tokens(encoded[mask_loc + 1]				)[0]
       self.assertNotEqual(UpperCAmelCase__     , UpperCAmelCase__				)




  def 	__lowercase(      self     :	Optional[Any]				)->       int:




       """simple docstring"""
       pass




  def 	__lowercase(      self     :	Optional[Any]				)->       Tuple:




       """simple docstring"""
       for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
            with self.subTest(F'''{tokenizer.__class__.__name__} ({pretrained_name})'''				):
                 SCREAMING_SNAKE_CASE__				:				Any			=		self.rust_tokenizer_class.from_pretrained(UpperCAmelCase__     , **UpperCAmelCase__				)
                 SCREAMING_SNAKE_CASE__				:				Union[str, Any]			=		self.tokenizer_class.from_pretrained(UpperCAmelCase__     , **UpperCAmelCase__				)
                 SCREAMING_SNAKE_CASE__				:				List[Any]			=		'''A, <mask> AllenNLP sentence.'''
                 SCREAMING_SNAKE_CASE__				:				Any			=		tokenizer_r.encode_plus(UpperCAmelCase__     , add_special_tokens=UpperCAmelCase__     , return_token_type_ids=UpperCAmelCase__				)
                 SCREAMING_SNAKE_CASE__				:				Dict			=		tokenizer_p.encode_plus(UpperCAmelCase__     , add_special_tokens=UpperCAmelCase__     , return_token_type_ids=UpperCAmelCase__				)

                 # token_type_ids should put 0 everywhere
                 self.assertEqual(sum(tokens_r['token_type_ids']				)     , sum(tokens_p['token_type_ids']				)				)

                 # attention_mask should put 1 everywhere, so sum over length should be 1
                 self.assertEqual(
                     sum(tokens_r['attention_mask']				) / len(tokens_r['attention_mask']				)     , sum(tokens_p['attention_mask']				) / len(tokens_p['attention_mask']				)     , )

                 SCREAMING_SNAKE_CASE__				:				List[str]			=		tokenizer_r.convert_ids_to_tokens(tokens_r['input_ids']				)
                 SCREAMING_SNAKE_CASE__				:				Union[str, Any]			=		tokenizer_p.convert_ids_to_tokens(tokens_p['input_ids']				)

                 # Rust correctly handles the space before the mask while python doesnt
                 self.assertSequenceEqual(tokens_p['input_ids']     , [0, 250, 6, 5_0264, 3823, 487, 2_1992, 3645, 4, 2]				)
                 self.assertSequenceEqual(tokens_r['input_ids']     , [0, 250, 6, 5_0264, 3823, 487, 2_1992, 3645, 4, 2]				)

                 self.assertSequenceEqual(
                     UpperCAmelCase__     , ['<s>', 'A', ',', '<mask>', 'ĠAllen', 'N', 'LP', 'Ġsentence', '.', '</s>']				)
                 self.assertSequenceEqual(
                     UpperCAmelCase__     , ['<s>', 'A', ',', '<mask>', 'ĠAllen', 'N', 'LP', 'Ġsentence', '.', '</s>']				)




  def 	__lowercase(      self     :	int				)->       Optional[int]:




       """simple docstring"""
       for trim_offsets, add_prefix_space in itertools.product([True, False]     , repeat=2				):
            SCREAMING_SNAKE_CASE__				:				List[str]			=		self.rust_tokenizer_class.from_pretrained(
                self.tmpdirname     , use_fast=UpperCAmelCase__     , add_prefix_space=UpperCAmelCase__     , trim_offsets=UpperCAmelCase__				)

            SCREAMING_SNAKE_CASE__				:				Optional[Any]			=		json.loads(tokenizer_r.backend_tokenizer.pre_tokenizer.__getstate__()				)
            SCREAMING_SNAKE_CASE__				:				str			=		json.loads(tokenizer_r.backend_tokenizer.post_processor.__getstate__()				)

            self.assertEqual(pre_tokenizer_state['add_prefix_space']     , UpperCAmelCase__				)

            self.assertEqual(post_processor_state['add_prefix_space']     , UpperCAmelCase__				)
            self.assertEqual(post_processor_state['trim_offsets']     , UpperCAmelCase__				)




  def 	__lowercase(      self     :	Optional[int]				)->       Dict:




       """simple docstring"""
       # Test which aims to verify that the offsets are well adapted to the argument `add_prefix_space` and
       # `trim_offsets`
       for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
            with self.subTest(F'''{tokenizer.__class__.__name__} ({pretrained_name})'''				):
                 SCREAMING_SNAKE_CASE__				:				Dict			=		'''hello'''  # `hello` is a token in the vocabulary of `pretrained_name`
                 SCREAMING_SNAKE_CASE__				:				Optional[Any]			=		F'''{text_of_1_token} {text_of_1_token}'''

                 SCREAMING_SNAKE_CASE__				:				Any			=		self.rust_tokenizer_class.from_pretrained(
                     UpperCAmelCase__     , use_fast=UpperCAmelCase__     , add_prefix_space=UpperCAmelCase__     , trim_offsets=UpperCAmelCase__				)
                 SCREAMING_SNAKE_CASE__				:				Dict			=		tokenizer_r(UpperCAmelCase__     , return_offsets_mapping=UpperCAmelCase__     , add_special_tokens=UpperCAmelCase__				)
                 self.assertEqual(encoding.offset_mapping[0]     , (0, len(UpperCAmelCase__				))				)
                 self.assertEqual(
                     encoding.offset_mapping[1]     , (len(UpperCAmelCase__				) + 1, len(UpperCAmelCase__				) + 1 + len(UpperCAmelCase__				))     , )

                 SCREAMING_SNAKE_CASE__				:				Tuple			=		self.rust_tokenizer_class.from_pretrained(
                     UpperCAmelCase__     , use_fast=UpperCAmelCase__     , add_prefix_space=UpperCAmelCase__     , trim_offsets=UpperCAmelCase__				)
                 SCREAMING_SNAKE_CASE__				:				str			=		tokenizer_r(UpperCAmelCase__     , return_offsets_mapping=UpperCAmelCase__     , add_special_tokens=UpperCAmelCase__				)
                 self.assertEqual(encoding.offset_mapping[0]     , (0, len(UpperCAmelCase__				))				)
                 self.assertEqual(
                     encoding.offset_mapping[1]     , (len(UpperCAmelCase__				) + 1, len(UpperCAmelCase__				) + 1 + len(UpperCAmelCase__				))     , )

                 SCREAMING_SNAKE_CASE__				:				List[str]			=		self.rust_tokenizer_class.from_pretrained(
                     UpperCAmelCase__     , use_fast=UpperCAmelCase__     , add_prefix_space=UpperCAmelCase__     , trim_offsets=UpperCAmelCase__				)
                 SCREAMING_SNAKE_CASE__				:				str			=		tokenizer_r(UpperCAmelCase__     , return_offsets_mapping=UpperCAmelCase__     , add_special_tokens=UpperCAmelCase__				)
                 self.assertEqual(encoding.offset_mapping[0]     , (0, len(UpperCAmelCase__				))				)
                 self.assertEqual(
                     encoding.offset_mapping[1]     , (len(UpperCAmelCase__				), len(UpperCAmelCase__				) + 1 + len(UpperCAmelCase__				))     , )

                 SCREAMING_SNAKE_CASE__				:				int			=		self.rust_tokenizer_class.from_pretrained(
                     UpperCAmelCase__     , use_fast=UpperCAmelCase__     , add_prefix_space=UpperCAmelCase__     , trim_offsets=UpperCAmelCase__				)
                 SCREAMING_SNAKE_CASE__				:				Tuple			=		tokenizer_r(UpperCAmelCase__     , return_offsets_mapping=UpperCAmelCase__     , add_special_tokens=UpperCAmelCase__				)
                 self.assertEqual(encoding.offset_mapping[0]     , (0, len(UpperCAmelCase__				))				)
                 self.assertEqual(
                     encoding.offset_mapping[1]     , (len(UpperCAmelCase__				), len(UpperCAmelCase__				) + 1 + len(UpperCAmelCase__				))     , )

                 SCREAMING_SNAKE_CASE__				:				Any			=		F''' {text}'''

                 # tokenizer_r = self.rust_tokenizer_class.from_pretrained(
                 #     pretrained_name, use_fast=True, add_prefix_space=True, trim_offsets=True
                 # )
                 # encoding = tokenizer_r(text, return_offsets_mapping=True, add_special_tokens=False)
                 # self.assertEqual(encoding.offset_mapping[0], (1, 1 + len(text_of_1_token)))
                 # self.assertEqual(
                 #     encoding.offset_mapping[1],
                 #     (1 + len(text_of_1_token) + 1, 1 + len(text_of_1_token) + 1 + len(text_of_1_token)),
                 # )

                 SCREAMING_SNAKE_CASE__				:				Union[str, Any]			=		self.rust_tokenizer_class.from_pretrained(
                     UpperCAmelCase__     , use_fast=UpperCAmelCase__     , add_prefix_space=UpperCAmelCase__     , trim_offsets=UpperCAmelCase__				)
                 SCREAMING_SNAKE_CASE__				:				int			=		tokenizer_r(UpperCAmelCase__     , return_offsets_mapping=UpperCAmelCase__     , add_special_tokens=UpperCAmelCase__				)
                 self.assertEqual(encoding.offset_mapping[0]     , (1, 1 + len(UpperCAmelCase__				))				)
                 self.assertEqual(
                     encoding.offset_mapping[1]     , (1 + len(UpperCAmelCase__				) + 1, 1 + len(UpperCAmelCase__				) + 1 + len(UpperCAmelCase__				))     , )

                 SCREAMING_SNAKE_CASE__				:				List[Any]			=		self.rust_tokenizer_class.from_pretrained(
                     UpperCAmelCase__     , use_fast=UpperCAmelCase__     , add_prefix_space=UpperCAmelCase__     , trim_offsets=UpperCAmelCase__				)
                 SCREAMING_SNAKE_CASE__				:				Dict			=		tokenizer_r(UpperCAmelCase__     , return_offsets_mapping=UpperCAmelCase__     , add_special_tokens=UpperCAmelCase__				)
                 self.assertEqual(encoding.offset_mapping[0]     , (0, 1 + len(UpperCAmelCase__				))				)
                 self.assertEqual(
                     encoding.offset_mapping[1]     , (1 + len(UpperCAmelCase__				), 1 + len(UpperCAmelCase__				) + 1 + len(UpperCAmelCase__				))     , )

                 SCREAMING_SNAKE_CASE__				:				int			=		self.rust_tokenizer_class.from_pretrained(
                     UpperCAmelCase__     , use_fast=UpperCAmelCase__     , add_prefix_space=UpperCAmelCase__     , trim_offsets=UpperCAmelCase__				)
                 SCREAMING_SNAKE_CASE__				:				Dict			=		tokenizer_r(UpperCAmelCase__     , return_offsets_mapping=UpperCAmelCase__     , add_special_tokens=UpperCAmelCase__				)
                 self.assertEqual(encoding.offset_mapping[0]     , (0, 1 + len(UpperCAmelCase__				))				)
                 self.assertEqual(
                     encoding.offset_mapping[1]     , (1 + len(UpperCAmelCase__				), 1 + len(UpperCAmelCase__				) + 1 + len(UpperCAmelCase__				))     , )




class       snake_case					(      UpperCamelCase_						):
  pass




class       snake_case					(      UpperCamelCase_						):
  pass




class       snake_case					:




  def __init__(      self     :	Union[str, Any]				)->       Tuple:




       """simple docstring"""
       SCREAMING_SNAKE_CASE__				:				int			=		[
           [],
           [],
           [],
       ]




  def 	__lowercase(      self     :	int     , a_     :	int     , a_     :	int				)->       None:




       """simple docstring"""
       try:
            if len(self.queues[priority]				) >= 100:
                 raise OverflowError('Maximum queue size is 100'				)
            self.queues[priority].append(a_				)
       except IndexError:
            raise ValueError('Valid priorities are 0, 1, and 2'				)




  def 	__lowercase(      self     :	int				)->       int:




       """simple docstring"""
       for queue in self.queues:
            if queue:
                 return queue.pop(0				)
       raise UnderFlowError('All queues are empty'				)




  def __str__(      self     :	Any				)->       str:




       """simple docstring"""
       return "\n".join(F'''Priority {i}: {q}''' for i, q in enumerate(self.queues				)				)




class       snake_case					:




  def __init__(      self     :	Union[str, Any]				)->       Dict:




       """simple docstring"""
       SCREAMING_SNAKE_CASE__				:				List[Any]			=		[]




  def 	__lowercase(      self     :	List[str]     , a_     :	int				)->       None:




       """simple docstring"""
       if len(self.queue				) == 100:
            raise OverFlowError('Maximum queue size is 100'				)
       self.queue.append(a_				)




  def 	__lowercase(      self     :	int				)->       int:




       """simple docstring"""
       if not self.queue:
            raise UnderFlowError('The queue is empty'				)
       else:
            SCREAMING_SNAKE_CASE__				:				Optional[int]			=		min(self.queue				)
            self.queue.remove(a_				)
            return data




  def __str__(      self     :	List[str]				)->       str:




       """simple docstring"""
       return str(self.queue				)







def     _a				(      ):







     '''simple docstring'''


     SCREAMING_SNAKE_CASE__				:				int			=		FixedPriorityQueue()
     fpq.enqueue(0     ,  10 )
     fpq.enqueue(1     ,  70 )
     fpq.enqueue(0     ,  1_00 )
     fpq.enqueue(2     ,  1 )
     fpq.enqueue(2     ,  5 )
     fpq.enqueue(1     ,  7 )
     fpq.enqueue(2     ,  4 )
     fpq.enqueue(1     ,  64 )
     fpq.enqueue(0     ,  1_28 )
     print(lowercase__ )
     print(fpq.dequeue() )
     print(fpq.dequeue() )
     print(fpq.dequeue() )
     print(fpq.dequeue() )
     print(fpq.dequeue() )
     print(lowercase__ )
     print(fpq.dequeue() )
     print(fpq.dequeue() )
     print(fpq.dequeue() )
     print(fpq.dequeue() )
     print(fpq.dequeue() )







def     _a				(      ):







     '''simple docstring'''


     SCREAMING_SNAKE_CASE__				:				Dict			=		ElementPriorityQueue()
     epq.enqueue(10 )
     epq.enqueue(70 )
     epq.enqueue(1_00 )
     epq.enqueue(1 )
     epq.enqueue(5 )
     epq.enqueue(7 )
     epq.enqueue(4 )
     epq.enqueue(64 )
     epq.enqueue(1_28 )
     print(lowercase__ )
     print(epq.dequeue() )
     print(epq.dequeue() )
     print(epq.dequeue() )
     print(epq.dequeue() )
     print(epq.dequeue() )
     print(lowercase__ )
     print(epq.dequeue() )
     print(epq.dequeue() )
     print(epq.dequeue() )
     print(epq.dequeue() )
     print(epq.dequeue() )


if __name__ == "__main__":
      fixed_priority_queue()
      element_priority_queue()



