




import os
import shutil
import tempfile
from unittest import TestCase
from unittest.mock import patch

import numpy as np
from datasets import Dataset

from transformers.models.realm.configuration_realm import RealmConfig
from transformers.models.realm.retrieval_realm import _REALM_BLOCK_RECORDS_FILENAME, RealmRetriever
from transformers.models.realm.tokenization_realm import VOCAB_FILES_NAMES, RealmTokenizer






class  __magic_name__						(  __UpperCAmelCase):
				'''simple docstring'''







				def     _A							(							self:   List[str]		):
											SCREAMING_SNAKE_CASE_   	=    tempfile.mkdtemp()
											SCREAMING_SNAKE_CASE_   	=    5

											# Realm tok
											SCREAMING_SNAKE_CASE_   	=    [
											    '''[UNK]''',
											    '''[CLS]''',
											    '''[SEP]''',
											    '''[PAD]''',
											    '''[MASK]''',
											    '''test''',
											    '''question''',
											    '''this''',
											    '''is''',
											    '''the''',
											    '''first''',
											    '''second''',
											    '''third''',
											    '''fourth''',
											    '''fifth''',
											    '''record''',
											    '''want''',
											    '''##want''',
											    '''##ed''',
											    '''wa''',
											    '''un''',
											    '''runn''',
											    '''##ing''',
											    ''',''',
											    '''low''',
											    '''lowest''',
											]
											SCREAMING_SNAKE_CASE_   	=    os.path.join(self.tmpdirname		,					'''realm_tokenizer'''		)
											os.makedirs(_lowerCamelCase		,					exist_ok=_lowerCamelCase		)
											SCREAMING_SNAKE_CASE_   	=    os.path.join(_lowerCamelCase		,					VOCAB_FILES_NAMES['''vocab_file''']		)
											with open(self.vocab_file		,					'''w'''		,					encoding='''utf-8'''		) as vocab_writer:
																		vocab_writer.write(''''''.join([x + '''\n''' for x in vocab_tokens]		)		)

											SCREAMING_SNAKE_CASE_   	=    os.path.join(self.tmpdirname		,					'''realm_block_records'''		)
											os.makedirs(_lowerCamelCase		,					exist_ok=_lowerCamelCase		)


				def     _A							(							self:   str		):
											return RealmTokenizer.from_pretrained(os.path.join(self.tmpdirname		,					'''realm_tokenizer'''		)		)


				def     _A							(							self:   List[str]		):
											shutil.rmtree(self.tmpdirname		)


				def     _A							(							self:   Tuple		):
											SCREAMING_SNAKE_CASE_   	=    RealmConfig(num_block_records=self.num_block_records		)
											return config


				def     _A							(							self:   Optional[Any]		):
											SCREAMING_SNAKE_CASE_   	=    Dataset.from_dict(
											    {
											        '''id''': ['''0''', '''1'''],
											        '''question''': ['''foo''', '''bar'''],
											        '''answers''': [['''Foo''', '''Bar'''], ['''Bar''']],
											    }		)
											return dataset


				def     _A							(							self:   List[Any]		):
											SCREAMING_SNAKE_CASE_   	=    np.array(
											    [
											        B'''This is the first record''',
											        B'''This is the second record''',
											        B'''This is the third record''',
											        B'''This is the fourth record''',
											        B'''This is the fifth record''',
											        B'''This is a longer longer longer record''',
											    ]		,					dtype=_lowerCamelCase		,					)
											return block_records


				def     _A							(							self:   str		):
											SCREAMING_SNAKE_CASE_   	=    RealmRetriever(
											    block_records=self.get_dummy_block_records()		,					tokenizer=self.get_tokenizer()		,					)
											return retriever


				def     _A							(							self:   Any		):
											SCREAMING_SNAKE_CASE_   	=    self.get_config()
											SCREAMING_SNAKE_CASE_   	=    self.get_dummy_retriever()
											SCREAMING_SNAKE_CASE_   	=    retriever.tokenizer

											SCREAMING_SNAKE_CASE_   	=    np.array([0, 3]		,					dtype='''long'''		)
											SCREAMING_SNAKE_CASE_   	=    tokenizer(['''Test question''']		).input_ids
											SCREAMING_SNAKE_CASE_   	=    tokenizer(
											    ['''the fourth''']		,					add_special_tokens=_lowerCamelCase		,					return_token_type_ids=_lowerCamelCase		,					return_attention_mask=_lowerCamelCase		,					).input_ids
											SCREAMING_SNAKE_CASE_   	=    config.reader_seq_len

											SCREAMING_SNAKE_CASE_	,	SCREAMING_SNAKE_CASE_	,	SCREAMING_SNAKE_CASE_	,	SCREAMING_SNAKE_CASE_   	=    retriever(
											    _lowerCamelCase		,					_lowerCamelCase		,					answer_ids=_lowerCamelCase		,					max_length=_lowerCamelCase		,					return_tensors='''np'''		)

											self.assertEqual(len(_lowerCamelCase		)		,					2		)
											self.assertEqual(len(_lowerCamelCase		)		,					2		)
											self.assertEqual(len(_lowerCamelCase		)		,					2		)
											self.assertEqual(concat_inputs.input_ids.shape		,					(2, 10)		)
											self.assertEqual(concat_inputs.attention_mask.shape		,					(2, 10)		)
											self.assertEqual(concat_inputs.token_type_ids.shape		,					(2, 10)		)
											self.assertEqual(concat_inputs.special_tokens_mask.shape		,					(2, 10)		)
											self.assertEqual(
											    tokenizer.convert_ids_to_tokens(concat_inputs.input_ids[0]		)		,					['''[CLS]''', '''test''', '''question''', '''[SEP]''', '''this''', '''is''', '''the''', '''first''', '''record''', '''[SEP]''']		,					)
											self.assertEqual(
											    tokenizer.convert_ids_to_tokens(concat_inputs.input_ids[1]		)		,					['''[CLS]''', '''test''', '''question''', '''[SEP]''', '''this''', '''is''', '''the''', '''fourth''', '''record''', '''[SEP]''']		,					)


				def     _A							(							self:   List[str]		):
											SCREAMING_SNAKE_CASE_   	=    self.get_config()
											SCREAMING_SNAKE_CASE_   	=    self.get_dummy_retriever()
											SCREAMING_SNAKE_CASE_   	=    retriever.tokenizer

											SCREAMING_SNAKE_CASE_   	=    np.array([0, 3, 5]		,					dtype='''long'''		)
											SCREAMING_SNAKE_CASE_   	=    tokenizer(['''Test question''']		).input_ids
											SCREAMING_SNAKE_CASE_   	=    tokenizer(
											    ['''the fourth''', '''longer longer''']		,					add_special_tokens=_lowerCamelCase		,					return_token_type_ids=_lowerCamelCase		,					return_attention_mask=_lowerCamelCase		,					).input_ids
											SCREAMING_SNAKE_CASE_   	=    config.reader_seq_len

											SCREAMING_SNAKE_CASE_	,	SCREAMING_SNAKE_CASE_	,	SCREAMING_SNAKE_CASE_	,	SCREAMING_SNAKE_CASE_   	=    retriever(
											    _lowerCamelCase		,					_lowerCamelCase		,					answer_ids=_lowerCamelCase		,					max_length=_lowerCamelCase		,					return_tensors='''np'''		)

											self.assertEqual([False, True, True]		,					_lowerCamelCase		)
											self.assertEqual([[-1, -1, -1], [6, -1, -1], [6, 7, 8]]		,					_lowerCamelCase		)
											self.assertEqual([[-1, -1, -1], [7, -1, -1], [7, 8, 9]]		,					_lowerCamelCase		)





				def     _A							(							self:   Union[str, Any]		):
											SCREAMING_SNAKE_CASE_   	=    self.get_dummy_retriever()
											retriever.save_pretrained(os.path.join(self.tmpdirname		,					'''realm_block_records'''		)		)

											# Test local path
											SCREAMING_SNAKE_CASE_   	=    retriever.from_pretrained(os.path.join(self.tmpdirname		,					'''realm_block_records'''		)		)
											self.assertEqual(retriever.block_records[0]		,					B'''This is the first record'''		)

											# Test mocked remote path
											with patch('''transformers.models.realm.retrieval_realm.hf_hub_download'''		) as mock_hf_hub_download:
																		SCREAMING_SNAKE_CASE_   	=    os.path.join(
																		    os.path.join(self.tmpdirname		,					'''realm_block_records'''		)		,					_REALM_BLOCK_RECORDS_FILENAME		)
																		SCREAMING_SNAKE_CASE_   	=    RealmRetriever.from_pretrained('''google/realm-cc-news-pretrained-openqa'''		)

											self.assertEqual(retriever.block_records[0]		,					B'''This is the first record'''		)








def 			a   (_lowerCAmelCase     ):
							SCREAMING_SNAKE_CASE_	,	SCREAMING_SNAKE_CASE_   	=    [], []
							while len(_lowerCAmelCase     ) > 1:
														SCREAMING_SNAKE_CASE_	,	SCREAMING_SNAKE_CASE_   	=    min(_lowerCAmelCase     ), max(_lowerCAmelCase     )
														start.append(_lowerCAmelCase     )
														end.append(_lowerCAmelCase     )
														collection.remove(_lowerCAmelCase     )
														collection.remove(_lowerCAmelCase     )
							end.reverse()
							return start + collection + end


if __name__ == "__main__":
			__SCREAMING_SNAKE_CASE 						=input("""Enter numbers separated by a comma:\n""").strip()
			__SCREAMING_SNAKE_CASE 						=[int(item) for item in user_input.split(""",""")]
			print(*merge_sort(unsorted), sep=""",""")


