"""simple docstring"""


import os
from shutil import copyfile
from typing import List, Optional, Tuple

from ...tokenization_utils_fast import PreTrainedTokenizerFast
from ...utils import is_sentencepiece_available, logging


if is_sentencepiece_available():
	from .tokenization_pegasus import PegasusTokenizer
else:
	a				=None


a				=logging.get_logger(__name__)


a				='▁'

a				={'vocab_file': 'spiece.model', 'tokenizer_file': 'tokenizer.json'}

a				={
    'vocab_file': {'google/pegasus-xsum': 'https://huggingface.co/google/pegasus-xsum/resolve/main/spiece.model'},
    'tokenizer_file': {
        'google/pegasus-xsum': 'https://huggingface.co/google/pegasus-xsum/resolve/main/tokenizer.json'
    },
}

a				={
    'google/pegasus-xsum': 512,
}






class   __UpperCAmelCase		(      __lowerCAmelCase      ):
				A__ :  Dict    				=			VOCAB_FILES_NAMES
				A__ :  int    				=			PRETRAINED_VOCAB_FILES_MAP
				A__ :  List[str]    				=			PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
				A__ :  Dict    				=			PegasusTokenizer
				A__ :  Any    				=			['''input_ids''', '''attention_mask''']

				def __init__( self      ,					_lowerCamelCase=None      ,					_lowerCamelCase=None      ,					_lowerCamelCase="<pad>"      ,					_lowerCamelCase="</s>"      ,					_lowerCamelCase="<unk>"      ,					_lowerCamelCase="<mask_2>"      ,					_lowerCamelCase="<mask_1>"      ,					_lowerCamelCase=None      ,					_lowerCamelCase=103      ,					**_lowerCamelCase      ,					):
										lowerCamelCase__   =offset

										if additional_special_tokens is not None:
																if not isinstance(_lowerCamelCase      ,					_lowerCamelCase ):
																						raise TypeError(
																						    F'''additional_special_tokens should be of type {type(_lowerCamelCase )}, but is'''
																						    F''' {type(_lowerCamelCase )}''' )

																lowerCamelCase__   =(
																    ([mask_token_sent] + additional_special_tokens)
																    if mask_token_sent not in additional_special_tokens and mask_token_sent is not None
																    else additional_special_tokens
																)
																# fill additional tokens with ..., <unk_token_102> in case not all additional tokens are already taken
																additional_special_tokens_extended += [
																    F'''<unk_{i}>''' for i in range(len(_lowerCamelCase )      ,					self.offset - 1 )
																]

																if len(set(_lowerCamelCase ) ) != len(_lowerCamelCase ):
																						raise ValueError(
																						    "Please make sure that the provided additional_special_tokens do not contain an incorrectly"
																						    F''' shifted list of <unk_x> tokens. Found {additional_special_tokens_extended}.''' )
																lowerCamelCase__   =additional_special_tokens_extended
										else:
																lowerCamelCase__   =[mask_token_sent] if mask_token_sent is not None else []
																additional_special_tokens += [F'''<unk_{i}>''' for i in range(2      ,					self.offset )]

										super().__init__(
										    _lowerCamelCase      ,					tokenizer_file=_lowerCamelCase      ,					pad_token=_lowerCamelCase      ,					eos_token=_lowerCamelCase      ,					unk_token=_lowerCamelCase      ,					mask_token=_lowerCamelCase      ,					mask_token_sent=_lowerCamelCase      ,					offset=_lowerCamelCase      ,					additional_special_tokens=_lowerCamelCase      ,					**_lowerCamelCase      ,					)
										lowerCamelCase__   =vocab_file
										lowerCamelCase__   =False if not self.vocab_file else True

				def 						_a      ( self      ,					_lowerCamelCase ):
										lowerCamelCase__   =set(self.all_special_ids )  # call it once instead of inside list comp
										all_special_ids.remove(self.unk_token_id )  # <unk> is only sometimes special

										if all_special_ids != set(range(len(self.additional_special_tokens ) + 3 ) ):
																raise ValueError(
																    "There should be 3 special tokens: mask_token, pad_token, and eos_token +"
																    F''' {len(self.additional_special_tokens )} additional_special_tokens, but got {all_special_ids}''' )

										return [1 if x in all_special_ids else 0 for x in seq]

				def 						_a      ( self      ,					_lowerCamelCase      ,					_lowerCamelCase = None      ,					_lowerCamelCase = False ):
										if already_has_special_tokens:
																return self._special_token_mask(_lowerCamelCase )
										elif token_ids_a is None:
																return self._special_token_mask(_lowerCamelCase ) + [1]
										else:
																return self._special_token_mask(token_ids_a + token_ids_a ) + [1]

				def 						_a      ( self      ,					_lowerCamelCase      ,					_lowerCamelCase=None ):
										if token_ids_a is None:
																return token_ids_a + [self.eos_token_id]
										# We don't expect to process pairs, but leave the pair logic for API consistency
										return token_ids_a + token_ids_a + [self.eos_token_id]






				def 						_a      ( self      ,					_lowerCamelCase      ,					_lowerCamelCase = None ):
										if not self.can_save_slow_tokenizer:
																raise ValueError(
																    "Your fast tokenizer does not have the necessary information to save the vocabulary for a slow "
																    "tokenizer." )

										if not os.path.isdir(_lowerCamelCase ):
																logger.error(F'''Vocabulary path ({save_directory}) should be a directory''' )
																return
										lowerCamelCase__   =os.path.join(
										    _lowerCamelCase      ,					(filename_prefix + "-" if filename_prefix else "") + VOCAB_FILES_NAMES["vocab_file"] )

										if os.path.abspath(self.vocab_file ) != os.path.abspath(_lowerCamelCase ):
																copyfile(self.vocab_file      ,					_lowerCamelCase )

										return (out_vocab_file,)



"""simple docstring"""


def      lowerCamelCase_					(   __lowerCAmelCase							)				->   list:




						'''simple docstring'''



						if len(__lowerCAmelCase							) <= 1:
												return [tuple(__lowerCAmelCase							)]

						lowerCamelCase__   =[]

						def generate(__lowerCAmelCase  ,       __lowerCAmelCase							):
												lowerCamelCase__   =[0] * n
												res.append(tuple(__lowerCAmelCase							)							)

												lowerCamelCase__   =0
												while i < n:
																		if c[i] < i:
																								if i % 2 == 0:
																														lowerCamelCase__   , lowerCamelCase__   =arr[i], arr[0]
																								else:
																														lowerCamelCase__   , lowerCamelCase__   =arr[i], arr[c[i]]
																								res.append(tuple(__lowerCAmelCase							)							)
																								c[i] += 1
																								lowerCamelCase__   =0
																		else:
																								lowerCamelCase__   =0
																								i += 1

						generate(len(__lowerCAmelCase							)  ,       __lowerCAmelCase							)
						return res


if __name__ == "__main__":
	a				=input('Enter numbers separated by a comma:\n').strip()
	a				=[int(item) for item in user_input.split(',')]
	print(heaps(arr))


