






import json
import os
from typing import TYPE_CHECKING, List, Optional, Tuple

import regex as re

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


if TYPE_CHECKING:
		from transformers.pipelines.conversational import Conversation

_a       =    logging.get_logger(__name__)

_a       =    {'''vocab_file''': '''vocab.json''', '''merges_file''': '''merges.txt'''}

_a       =    {
    '''vocab_file''': {
        '''microsoft/deberta-base''': '''https://huggingface.co/microsoft/deberta-base/resolve/main/vocab.json''',
        '''microsoft/deberta-large''': '''https://huggingface.co/microsoft/deberta-large/resolve/main/vocab.json''',
        '''microsoft/deberta-xlarge''': '''https://huggingface.co/microsoft/deberta-xlarge/resolve/main/vocab.json''',
        '''microsoft/deberta-base-mnli''': '''https://huggingface.co/microsoft/deberta-base-mnli/resolve/main/vocab.json''',
        '''microsoft/deberta-large-mnli''': '''https://huggingface.co/microsoft/deberta-large-mnli/resolve/main/vocab.json''',
        '''microsoft/deberta-xlarge-mnli''': (
            '''https://huggingface.co/microsoft/deberta-xlarge-mnli/resolve/main/vocab.json'''
        ),
    },
    '''merges_file''': {
        '''microsoft/deberta-base''': '''https://huggingface.co/microsoft/deberta-base/resolve/main/merges.txt''',
        '''microsoft/deberta-large''': '''https://huggingface.co/microsoft/deberta-large/resolve/main/merges.txt''',
        '''microsoft/deberta-xlarge''': '''https://huggingface.co/microsoft/deberta-xlarge/resolve/main/merges.txt''',
        '''microsoft/deberta-base-mnli''': '''https://huggingface.co/microsoft/deberta-base-mnli/resolve/main/merges.txt''',
        '''microsoft/deberta-large-mnli''': '''https://huggingface.co/microsoft/deberta-large-mnli/resolve/main/merges.txt''',
        '''microsoft/deberta-xlarge-mnli''': (
            '''https://huggingface.co/microsoft/deberta-xlarge-mnli/resolve/main/merges.txt'''
        ),
    },
}

_a       =    {
    '''microsoft/deberta-base''': 512,
    '''microsoft/deberta-large''': 512,
    '''microsoft/deberta-xlarge''': 512,
    '''microsoft/deberta-base-mnli''': 512,
    '''microsoft/deberta-large-mnli''': 512,
    '''microsoft/deberta-xlarge-mnli''': 512,
}

_a       =    {
    '''microsoft/deberta-base''': {'''do_lower_case''': False},
    '''microsoft/deberta-large''': {'''do_lower_case''': False},
}


def __A       ( )->    List[Any]:





						"""simple docstring"""



						_UpperCAmelCase							   =     (
						    list(range(ord('!'      )					,						ord('~'      ) + 1      )      ) + list(range(ord('¡'      )					,						ord('¬'      ) + 1      )      ) + list(range(ord('®'      )					,						ord('ÿ'      ) + 1      )      )
						)
						_UpperCAmelCase							   =     bs[:]
						_UpperCAmelCase							   =     0
						for b in range(2**8      ):
												if b not in bs:
																		bs.append(__snake_case      )
																		cs.append(2**8 + n      )
																		n += 1
						_UpperCAmelCase							   =     [chr(__snake_case      ) for n in cs]
						return dict(zip(__snake_case					,						__snake_case      )      )


def __A       ( __lowerCAmelCase      )->    Any:





						"""simple docstring"""



						_UpperCAmelCase							   =     set()
						_UpperCAmelCase							   =     word[0]
						for char in word[1:]:
												pairs.add((prev_char, char)      )
												_UpperCAmelCase							   =     char
						return pairs





class __lowerCamelCase					( snake_case__):





	"""simple docstring"""






	UpperCamelCase__								= VOCAB_FILES_NAMES
	UpperCamelCase__								= PRETRAINED_VOCAB_FILES_MAP
	UpperCamelCase__								= PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
	UpperCamelCase__								= ["input_ids", "attention_mask", "token_type_ids"]

	def __init__(				self			,       UpperCAmelCase			,       UpperCAmelCase			,       UpperCAmelCase="replace"			,       UpperCAmelCase="[CLS]"			,       UpperCAmelCase="[SEP]"			,       UpperCAmelCase="[SEP]"			,       UpperCAmelCase="[CLS]"			,       UpperCAmelCase="[UNK]"			,       UpperCAmelCase="[PAD]"			,       UpperCAmelCase="[MASK]"			,       UpperCAmelCase=False			,       UpperCAmelCase=False			,       **UpperCAmelCase			,       ):
							"""simple docstring"""







							_UpperCAmelCase							   =     AddedToken(UpperCAmelCase			,       lstrip=UpperCAmelCase			,       rstrip=UpperCAmelCase       ) if isinstance(UpperCAmelCase			,       UpperCAmelCase       ) else bos_token
							_UpperCAmelCase							   =     AddedToken(UpperCAmelCase			,       lstrip=UpperCAmelCase			,       rstrip=UpperCAmelCase       ) if isinstance(UpperCAmelCase			,       UpperCAmelCase       ) else eos_token
							_UpperCAmelCase							   =     AddedToken(UpperCAmelCase			,       lstrip=UpperCAmelCase			,       rstrip=UpperCAmelCase       ) if isinstance(UpperCAmelCase			,       UpperCAmelCase       ) else sep_token
							_UpperCAmelCase							   =     AddedToken(UpperCAmelCase			,       lstrip=UpperCAmelCase			,       rstrip=UpperCAmelCase       ) if isinstance(UpperCAmelCase			,       UpperCAmelCase       ) else cls_token
							_UpperCAmelCase							   =     AddedToken(UpperCAmelCase			,       lstrip=UpperCAmelCase			,       rstrip=UpperCAmelCase       ) if isinstance(UpperCAmelCase			,       UpperCAmelCase       ) else unk_token
							_UpperCAmelCase							   =     AddedToken(UpperCAmelCase			,       lstrip=UpperCAmelCase			,       rstrip=UpperCAmelCase       ) if isinstance(UpperCAmelCase			,       UpperCAmelCase       ) else pad_token

							# Mask token behave like a normal word, i.e. include the space before it
							_UpperCAmelCase							   =     AddedToken(UpperCAmelCase			,       lstrip=UpperCAmelCase			,       rstrip=UpperCAmelCase       ) if isinstance(UpperCAmelCase			,       UpperCAmelCase       ) else mask_token

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

							with open(UpperCAmelCase			,       encoding='utf-8'       ) as vocab_handle:
													_UpperCAmelCase							   =     json.load(UpperCAmelCase       )
							_UpperCAmelCase							   =     {v: k for k, v in self.encoder.items()}
							_UpperCAmelCase							   =     errors  # how to handle errors in decoding
							_UpperCAmelCase							   =     bytes_to_unicode()
							_UpperCAmelCase							   =     {v: k for k, v in self.byte_encoder.items()}
							with open(UpperCAmelCase			,       encoding='utf-8'       ) as merges_handle:
													_UpperCAmelCase							   =     merges_handle.read().split('\n'       )[1:-1]
							_UpperCAmelCase							   =     [tuple(merge.split()       ) for merge in bpe_merges]
							_UpperCAmelCase							   =     dict(zip(UpperCAmelCase			,       range(len(UpperCAmelCase       )       )       )       )
							_UpperCAmelCase							   =     {}
							_UpperCAmelCase							   =     add_prefix_space

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

	@property
	# Copied from transformers.models.gpt2.tokenization_gpt2.GPT2Tokenizer.vocab_size
	def 			UpperCamelCase       (				self       ):
							"""simple docstring"""







							return len(self.encoder       )

	def 			UpperCamelCase       (				self       ):
							"""simple docstring"""







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

	def 			UpperCamelCase       (				self			,       UpperCAmelCase       ):
							"""simple docstring"""







							if token in self.cache:
													return self.cache[token]
							_UpperCAmelCase							   =     tuple(UpperCAmelCase       )
							_UpperCAmelCase							   =     get_pairs(UpperCAmelCase       )

							if not pairs:
													return token

							while True:
													_UpperCAmelCase							   =     min(UpperCAmelCase			,       key=lambda UpperCAmelCase       : self.bpe_ranks.get(UpperCAmelCase			,       float('inf'       )       )       )
													if bigram not in self.bpe_ranks:
																			break
													_UpperCAmelCase   ,					_UpperCAmelCase							   =     bigram
													_UpperCAmelCase							   =     []
													_UpperCAmelCase							   =     0
													while i < len(UpperCAmelCase       ):
																			try:
																									_UpperCAmelCase							   =     word.index(UpperCAmelCase			,       UpperCAmelCase       )
																			except ValueError:
																									new_word.extend(word[i:]       )
																									break
																			else:
																									new_word.extend(word[i:j]       )
																									_UpperCAmelCase							   =     j

																			if word[i] == first and i < len(UpperCAmelCase       ) - 1 and word[i + 1] == second:
																									new_word.append(first + second       )
																									i += 2
																			else:
																									new_word.append(word[i]       )
																									i += 1
													_UpperCAmelCase							   =     tuple(UpperCAmelCase       )
													_UpperCAmelCase							   =     new_word
													if len(UpperCAmelCase       ) == 1:
																			break
													else:
																			_UpperCAmelCase							   =     get_pairs(UpperCAmelCase       )
							_UpperCAmelCase							   =     ' '.join(UpperCAmelCase       )
							_UpperCAmelCase							   =     word
							return word

	def 			UpperCamelCase       (				self			,       UpperCAmelCase			,       UpperCAmelCase = None       ):
							"""simple docstring"""







							if token_ids_a is None:
													return [self.cls_token_id] + token_ids_a + [self.sep_token_id]
							_UpperCAmelCase							   =     [self.cls_token_id]
							_UpperCAmelCase							   =     [self.sep_token_id]
							return cls + token_ids_a + sep + token_ids_a + sep

	def 			UpperCamelCase       (				self			,       UpperCAmelCase			,       UpperCAmelCase = None			,       UpperCAmelCase = False       ):
							"""simple docstring"""







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

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

	def 			UpperCamelCase       (				self			,       UpperCAmelCase			,       UpperCAmelCase = None       ):
							"""simple docstring"""







							_UpperCAmelCase							   =     [self.sep_token_id]
							_UpperCAmelCase							   =     [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       ) * [0] + len(token_ids_a + sep       ) * [1]

	def 			UpperCamelCase       (				self			,       UpperCAmelCase       ):
							"""simple docstring"""







							_UpperCAmelCase							   =     []
							for token in re.findall(self.pat			,       UpperCAmelCase       ):
													_UpperCAmelCase							   =     ''.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(UpperCAmelCase       ).split(' '       )       )
							return bpe_tokens

	def 			UpperCamelCase       (				self			,       UpperCAmelCase       ):
							"""simple docstring"""







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

	def 			UpperCamelCase       (				self			,       UpperCAmelCase       ):
							"""simple docstring"""







							return self.decoder.get(UpperCAmelCase       )

	def 			UpperCamelCase       (				self			,       UpperCAmelCase       ):
							"""simple docstring"""







							_UpperCAmelCase							   =     ''.join(UpperCAmelCase       )
							_UpperCAmelCase							   =     bytearray([self.byte_decoder[c] for c in text]       ).decode('utf-8'			,       errors=self.errors       )
							return text

	def 			UpperCamelCase       (				self			,       UpperCAmelCase			,       UpperCAmelCase = None       ):
							"""simple docstring"""







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

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

							_UpperCAmelCase							   =     0
							with open(UpperCAmelCase			,       '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 UpperCAmelCase       : 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!'       )
																									_UpperCAmelCase							   =     token_index
																			writer.write(' '.join(UpperCAmelCase       ) + '\n'       )
																			index += 1

							return vocab_file, merge_file

	def 			UpperCamelCase       (				self			,       UpperCAmelCase			,       UpperCAmelCase=False			,       **UpperCAmelCase       ):
							"""simple docstring"""







							_UpperCAmelCase							   =     kwargs.pop('add_prefix_space'			,       self.add_prefix_space       )
							if (is_split_into_words or add_prefix_space) and (len(UpperCAmelCase       ) > 0 and not text[0].isspace()):
													_UpperCAmelCase							   =     ' ' + text
							return (text, kwargs)

	def 			UpperCamelCase       (				self			,       UpperCAmelCase       ):
							"""simple docstring"""







							_UpperCAmelCase							   =     []
							for is_user, text in conversation.iter_texts():
													input_ids.extend(self.encode(UpperCAmelCase			,       add_special_tokens=UpperCAmelCase       ) + [self.eos_token_id]       )
							if len(UpperCAmelCase       ) > self.model_max_length:
													_UpperCAmelCase							   =     input_ids[-self.model_max_length :]
							return input_ids




import math
def 							UpperCAmelCase_   (				__snake_case		)	->     int:







 """simple docstring"""


 return sum(int(__snake_case		) for digit in str(__snake_case		)		)
def 							UpperCAmelCase_   (				__snake_case = 30		)	->     int:







 """simple docstring"""


 _lowercase				 =[]
 for digit in range(2	,		100		):
  for power in range(2	,		100		):
   _lowercase				 =int(math.pow(__snake_case	,		__snake_case		)		)
   if digit == digit_sum(__snake_case		):
    digit_to_powers.append(__snake_case		)

 digit_to_powers.sort()
 return digit_to_powers[n - 1]


if __name__ == "__main__":
  print(solution())

