



"""simple docstring"""






import json
import os
from functools import lru_cache
from typing import List, Optional, Tuple

import regex as re

from ...tokenization_utils import AddedToken, PreTrainedTokenizer
from ...utils import logging


__UpperCAmelCase      :      Optional[Any]   					=					logging.get_logger(__name__)

__UpperCAmelCase      :      List[str]   					=					{
    'vocab_file': 'vocab.json',
    'merges_file': 'merges.txt',
}

__UpperCAmelCase      :      Optional[int]   					=					{
    'vocab_file': {
        'roberta-base': 'https://huggingface.co/roberta-base/resolve/main/vocab.json',
        'roberta-large': 'https://huggingface.co/roberta-large/resolve/main/vocab.json',
        'roberta-large-mnli': 'https://huggingface.co/roberta-large-mnli/resolve/main/vocab.json',
        'distilroberta-base': 'https://huggingface.co/distilroberta-base/resolve/main/vocab.json',
        'roberta-base-openai-detector': 'https://huggingface.co/roberta-base-openai-detector/resolve/main/vocab.json',
        'roberta-large-openai-detector': (
            'https://huggingface.co/roberta-large-openai-detector/resolve/main/vocab.json'
        ),
    },
    'merges_file': {
        'roberta-base': 'https://huggingface.co/roberta-base/resolve/main/merges.txt',
        'roberta-large': 'https://huggingface.co/roberta-large/resolve/main/merges.txt',
        'roberta-large-mnli': 'https://huggingface.co/roberta-large-mnli/resolve/main/merges.txt',
        'distilroberta-base': 'https://huggingface.co/distilroberta-base/resolve/main/merges.txt',
        'roberta-base-openai-detector': 'https://huggingface.co/roberta-base-openai-detector/resolve/main/merges.txt',
        'roberta-large-openai-detector': (
            'https://huggingface.co/roberta-large-openai-detector/resolve/main/merges.txt'
        ),
    },
}

__UpperCAmelCase      :      Optional[int]   					=					{
    'roberta-base': 5_12,
    'roberta-large': 5_12,
    'roberta-large-mnli': 5_12,
    'distilroberta-base': 5_12,
    'roberta-base-openai-detector': 5_12,
    'roberta-large-openai-detector': 5_12,
}
@lru_cache()
def      A      (			):




					"""simple docstring"""
					snake_case_						:List[Any]								=						(
					    list(range(ord("!"							),     ord("~"							) + 1							)							) + list(range(ord("¡"							),     ord("¬"							) + 1							)							) + list(range(ord("®"							),     ord("ÿ"							) + 1							)							)
					)
					snake_case_						:Union[str, Any]								=						bs[:]
					snake_case_						:Any								=						0
					for b in range(2**8							):
										if b not in bs:
															bs.append(_A							)
															cs.append(2**8 + n							)
															n += 1
					snake_case_						:Tuple								=						[chr(_A							) for n in cs]
					return dict(zip(_A,     _A							)							)
def      A      (			_A							):




					"""simple docstring"""
					snake_case_						:List[str]								=						set()
					snake_case_						:Optional[Any]								=						word[0]
					for char in word[1:]:
										pairs.add((prev_char, char)							)
										snake_case_						:Optional[int]								=						char
					return pairs

class 	__lowerCAmelCase							(__UpperCamelCase  ):


					'''simple docstring'''


					a__        =     VOCAB_FILES_NAMES
					a__        =     PRETRAINED_VOCAB_FILES_MAP
					a__        =     PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
					a__        =     ['input_ids', 'attention_mask']







					def __init__(      self    ,       a    ,       a    ,       a="replace"    ,       a="<s>"    ,       a="</s>"    ,       a="</s>"    ,       a="<s>"    ,       a="<unk>"    ,       a="<pad>"    ,       a="<mask>"    ,       a=False    ,       **a    ,       ):




										"""simple docstring"""





										snake_case_						:Tuple								=						AddedToken(a    ,       lstrip=a    ,       rstrip=a   ) if isinstance(a    ,       a   ) else bos_token
										snake_case_						:Optional[Any]								=						AddedToken(a    ,       lstrip=a    ,       rstrip=a   ) if isinstance(a    ,       a   ) else eos_token
										snake_case_						:int								=						AddedToken(a    ,       lstrip=a    ,       rstrip=a   ) if isinstance(a    ,       a   ) else sep_token
										snake_case_						:Dict								=						AddedToken(a    ,       lstrip=a    ,       rstrip=a   ) if isinstance(a    ,       a   ) else cls_token
										snake_case_						:Tuple								=						AddedToken(a    ,       lstrip=a    ,       rstrip=a   ) if isinstance(a    ,       a   ) else unk_token
										snake_case_						:List[Any]								=						AddedToken(a    ,       lstrip=a    ,       rstrip=a   ) if isinstance(a    ,       a   ) else pad_token

										# Mask token behave like a normal word, i.e. include the space before it
										snake_case_						:Optional[Any]								=						AddedToken(a    ,       lstrip=a    ,       rstrip=a   ) if isinstance(a    ,       a   ) else mask_token

										super().__init__(
										    errors=a    ,       bos_token=a    ,       eos_token=a    ,       unk_token=a    ,       sep_token=a    ,       cls_token=a    ,       pad_token=a    ,       mask_token=a    ,       add_prefix_space=a    ,       **a    ,       )

										with open(a    ,       encoding="utf-8"   ) as vocab_handle:
															snake_case_						:int								=						json.load(a   )
										snake_case_						:str								=						{v: k for k, v in self.encoder.items()}
										snake_case_						:List[str]								=						errors  # how to handle errors in decoding
										snake_case_						:Tuple								=						bytes_to_unicode()
										snake_case_						:int								=						{v: k for k, v in self.byte_encoder.items()}
										with open(a    ,       encoding="utf-8"   ) as merges_handle:
															snake_case_						:int								=						merges_handle.read().split("\n"   )[1:-1]
										snake_case_						:Dict								=						[tuple(merge.split()   ) for merge in bpe_merges]
										snake_case_						:int								=						dict(zip(a    ,       range(len(a   )   )   )   )
										snake_case_						:Optional[int]								=						{}
										snake_case_						:Optional[Any]								=						add_prefix_space

										# Should have added re.IGNORECASE so BPE merges can happen for capitalized versions of contractions
										snake_case_						:int								=						re.compile(r"'s|'t|'re|'ve|'m|'ll|'d| ?\p{L}+| ?\p{N}+| ?[^\s\p{L}\p{N}]+|\s+(?!\S)|\s+"   )







					@property
					def 		_a (      self   ):




										"""simple docstring"""





										return len(self.encoder   )







					def 		_a (      self   ):




										"""simple docstring"""





										return dict(self.encoder    ,       **self.added_tokens_encoder   )







					def 		_a (      self    ,       a   ):




										"""simple docstring"""





										if token in self.cache:
															return self.cache[token]
										snake_case_						:List[str]								=						tuple(a   )
										snake_case_						:int								=						get_pairs(a   )

										if not pairs:
															return token

										while True:
															snake_case_						:List[Any]								=						min(a    ,       key=lambda a   : self.bpe_ranks.get(a    ,       float("inf"   )   )   )
															if bigram not in self.bpe_ranks:
																				break
															snake_case_	,  snake_case_						:Dict								=						bigram
															snake_case_						:Optional[Any]								=						[]
															snake_case_						:Dict								=						0
															while i < len(a   ):
																				try:
																									snake_case_						:Optional[Any]								=						word.index(a    ,       a   )
																				except ValueError:
																									new_word.extend(word[i:]   )
																									break
																				else:
																									new_word.extend(word[i:j]   )
																									snake_case_						:Tuple								=						j

																				if word[i] == first and i < len(a   ) - 1 and word[i + 1] == second:
																									new_word.append(first + second   )
																									i += 2
																				else:
																									new_word.append(word[i]   )
																									i += 1
															snake_case_						:int								=						tuple(a   )
															snake_case_						:List[str]								=						new_word
															if len(a   ) == 1:
																				break
															else:
																				snake_case_						:List[str]								=						get_pairs(a   )
										snake_case_						:Union[str, Any]								=						" ".join(a   )
										snake_case_						:List[str]								=						word
										return word







					def 		_a (      self    ,       a   ):




										"""simple docstring"""





										snake_case_						:int								=						[]
										for token in re.findall(self.pat    ,       a   ):
															snake_case_						:Any								=						"".join(
															    self.byte_encoder[b] for b in token.encode("utf-8"   )   )  # Maps all our bytes to unicode strings, avoiding control tokens of the BPE (spaces in our case)
															bpe_tokens.extend(bpe_token for bpe_token in self.bpe(a   ).split(" "   )   )
										return bpe_tokens







					def 		_a (      self    ,       a   ):




										"""simple docstring"""





										return self.encoder.get(a    ,       self.encoder.get(self.unk_token   )   )







					def 		_a (      self    ,       a   ):




										"""simple docstring"""





										return self.decoder.get(a   )







					def 		_a (      self    ,       a   ):




										"""simple docstring"""





										snake_case_						:Union[str, Any]								=						"".join(a   )
										snake_case_						:int								=						bytearray([self.byte_decoder[c] for c in text]   ).decode("utf-8"    ,       errors=self.errors   )
										return text







					def 		_a (      self    ,       a    ,       a = None   ):




										"""simple docstring"""





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

										with open(a    ,       "w"    ,       encoding="utf-8"   ) as f:
															f.write(json.dumps(self.encoder    ,       indent=2    ,       sort_keys=a    ,       ensure_ascii=a   ) + "\n"   )

										snake_case_						:Dict								=						0
										with open(a    ,       "w"    ,       encoding="utf-8"   ) as writer:
															writer.write("#version: 0.2\n"   )
															for bpe_tokens, token_index in sorted(self.bpe_ranks.items()    ,       key=lambda a   : kv[1]   ):
																				if index != token_index:
																									logger.warning(
																									    F'''Saving vocabulary to {merge_file}: BPE merge indices are not consecutive.'''
																									    " Please check that the tokenizer is not corrupted!"   )
																									snake_case_						:Optional[Any]								=						token_index
																				writer.write(" ".join(a   ) + "\n"   )
																				index += 1

										return vocab_file, merge_file







					def 		_a (      self    ,       a    ,       a = None   ):




										"""simple docstring"""





										if token_ids_a is None:
															return [self.cls_token_id] + token_ids_a + [self.sep_token_id]
										snake_case_						:int								=						[self.cls_token_id]
										snake_case_						:Optional[Any]								=						[self.sep_token_id]
										return cls + token_ids_a + sep + sep + token_ids_a + sep







					def 		_a (      self    ,       a    ,       a = None    ,       a = False   ):




										"""simple docstring"""





										if already_has_special_tokens:
															return super().get_special_tokens_mask(
															    token_ids_a=a    ,       token_ids_a=a    ,       already_has_special_tokens=a   )

										if token_ids_a is None:
															return [1] + ([0] * len(a   )) + [1]
										return [1] + ([0] * len(a   )) + [1, 1] + ([0] * len(a   )) + [1]







					def 		_a (      self    ,       a    ,       a = None   ):




										"""simple docstring"""





										snake_case_						:List[str]								=						[self.sep_token_id]
										snake_case_						:Any								=						[self.cls_token_id]

										if token_ids_a is None:
															return len(cls + token_ids_a + sep   ) * [0]
										return len(cls + token_ids_a + sep + sep + token_ids_a + sep   ) * [0]







					def 		_a (      self    ,       a    ,       a=False    ,       **a   ):




										"""simple docstring"""





										snake_case_						:Tuple								=						kwargs.pop("add_prefix_space"    ,       self.add_prefix_space   )
										if (is_split_into_words or add_prefix_space) and (len(a   ) > 0 and not text[0].isspace()):
															snake_case_						:Optional[int]								=						" " + text
										return (text, kwargs)






"""simple docstring"""






def      A      (			_A,     _A							):




					"""simple docstring"""
					if n == 0:
										return 1

					elif n % 2 == 1:
										return binary_exponentiation(_A,     n - 1							) * a

					else:
										snake_case_						:Optional[int]								=						binary_exponentiation(_A,     n / 2							)
										return b * b


if __name__ == "__main__":
				try:
								__UpperCAmelCase      :      str   					=					int(input('Enter Base : ').strip())
								__UpperCAmelCase      :      Any   					=					int(input('Enter Power : ').strip())
				except ValueError:
								print('Invalid literal for integer')

				__UpperCAmelCase      :      Optional[int]   					=					binary_exponentiation(BASE, POWER)
				print(F'''{BASE}^({POWER}) : {RESULT}''')

