






"""simple docstring"""


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

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


if is_sentencepiece_available():
		from .tokenization_big_bird import BigBirdTokenizer
else:
		__SCREAMING_SNAKE_CASE   =   None

__SCREAMING_SNAKE_CASE   =   logging.get_logger(__name__)
__SCREAMING_SNAKE_CASE   =   {'vocab_file': 'spiece.model', 'tokenizer_file': 'tokenizer.json'}

__SCREAMING_SNAKE_CASE   =   {
    'vocab_file': {
        'google/bigbird-roberta-base': 'https://huggingface.co/google/bigbird-roberta-base/resolve/main/spiece.model',
        'google/bigbird-roberta-large': (
            'https://huggingface.co/google/bigbird-roberta-large/resolve/main/spiece.model'
        ),
        'google/bigbird-base-trivia-itc': (
            'https://huggingface.co/google/bigbird-base-trivia-itc/resolve/main/spiece.model'
        ),
    },
    'tokenizer_file': {
        'google/bigbird-roberta-base': (
            'https://huggingface.co/google/bigbird-roberta-base/resolve/main/tokenizer.json'
        ),
        'google/bigbird-roberta-large': (
            'https://huggingface.co/google/bigbird-roberta-large/resolve/main/tokenizer.json'
        ),
        'google/bigbird-base-trivia-itc': (
            'https://huggingface.co/google/bigbird-base-trivia-itc/resolve/main/tokenizer.json'
        ),
    },
}

__SCREAMING_SNAKE_CASE   =   {
    'google/bigbird-roberta-base': 40_96,
    'google/bigbird-roberta-large': 40_96,
    'google/bigbird-base-trivia-itc': 40_96,
}


__SCREAMING_SNAKE_CASE   =   '▁'




class 						__UpperCamelCase     (     UpperCamelCase						):
					lowercase_    :				List[str]      =  VOCAB_FILES_NAMES
					lowercase_    :				Optional[Any]      =  PRETRAINED_VOCAB_FILES_MAP
					lowercase_    :				Any      =  PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
					lowercase_    :				Tuple      =  BigBirdTokenizer
					lowercase_    :				str      =  ["""input_ids""", """attention_mask"""]
					lowercase_    :				List[int]      =  []
					def __init__(							self							:	int     , UpperCAmelCase							:	Optional[int]=None     , UpperCAmelCase							:	List[str]=None     , UpperCAmelCase							:	str="<unk>"     , UpperCAmelCase							:	Dict="<s>"     , UpperCAmelCase							:	List[str]="</s>"     , UpperCAmelCase							:	Dict="<pad>"     , UpperCAmelCase							:	Optional[int]="[SEP]"     , UpperCAmelCase							:	str="[MASK]"     , UpperCAmelCase							:	Dict="[CLS]"     , **UpperCAmelCase							:	Union[str, Any]     , )	->       int:
											lowerCAmelCase   :Union[str, Any]						=			AddedToken(UpperCAmelCase     , lstrip=UpperCAmelCase     , rstrip=UpperCAmelCase   ) if isinstance(UpperCAmelCase     , UpperCAmelCase   ) else bos_token
											lowerCAmelCase   :Optional[Any]						=			AddedToken(UpperCAmelCase     , lstrip=UpperCAmelCase     , rstrip=UpperCAmelCase   ) if isinstance(UpperCAmelCase     , UpperCAmelCase   ) else eos_token
											lowerCAmelCase   :Optional[Any]						=			AddedToken(UpperCAmelCase     , lstrip=UpperCAmelCase     , rstrip=UpperCAmelCase   ) if isinstance(UpperCAmelCase     , UpperCAmelCase   ) else unk_token
											lowerCAmelCase   :str						=			AddedToken(UpperCAmelCase     , lstrip=UpperCAmelCase     , rstrip=UpperCAmelCase   ) if isinstance(UpperCAmelCase     , UpperCAmelCase   ) else pad_token
											lowerCAmelCase   :int						=			AddedToken(UpperCAmelCase     , lstrip=UpperCAmelCase     , rstrip=UpperCAmelCase   ) if isinstance(UpperCAmelCase     , UpperCAmelCase   ) else cls_token
											lowerCAmelCase   :int						=			AddedToken(UpperCAmelCase     , lstrip=UpperCAmelCase     , rstrip=UpperCAmelCase   ) if isinstance(UpperCAmelCase     , UpperCAmelCase   ) else sep_token

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

											super().__init__(
											    UpperCAmelCase     , tokenizer_file=UpperCAmelCase     , bos_token=UpperCAmelCase     , eos_token=UpperCAmelCase     , unk_token=UpperCAmelCase     , sep_token=UpperCAmelCase     , pad_token=UpperCAmelCase     , cls_token=UpperCAmelCase     , mask_token=UpperCAmelCase     , **UpperCAmelCase     , )

											lowerCAmelCase   :str						=			vocab_file
											lowerCAmelCase   :Any						=			False if not self.vocab_file else True
					def        UpperCAmelCase__ (							self							:	int     , UpperCAmelCase							:	List[int]     , UpperCAmelCase							:	Optional[List[int]] = None   )	->       List[int]:
											lowerCAmelCase   :Optional[Any]						=			[self.sep_token_id]
											lowerCAmelCase   :Optional[Any]						=			[self.cls_token_id]
											if token_ids_a is None:
																	return cls + token_ids_a + sep
											return cls + token_ids_a + sep + token_ids_a + sep
					def        UpperCAmelCase__ (							self							:	List[str]     , UpperCAmelCase							:	List[int]     , UpperCAmelCase							:	Optional[List[int]] = None     , UpperCAmelCase							:	bool = False   )	->       List[int]:

											if already_has_special_tokens:
																	if token_ids_a is not None:
																							raise ValueError(
																							    'You should not supply a second sequence if the provided sequence of '
																							    'ids is already formatted with special tokens for the model.'   )
																	return [1 if x in [self.sep_token_id, self.cls_token_id] else 0 for x in token_ids_a]

											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							:	Any     , UpperCAmelCase							:	List[int]     , UpperCAmelCase							:	Optional[List[int]] = None   )	->       List[int]:
											lowerCAmelCase   :List[Any]						=			[self.sep_token_id]
											lowerCAmelCase   :List[str]						=			[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							:	Optional[Any]     , UpperCAmelCase							:	str     , UpperCAmelCase							:	Optional[str] = None   )	->       Tuple[str]:
											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(UpperCAmelCase   ):
																	logger.error(f"""Vocabulary path ({save_directory}) should be a directory"""   )
																	return
											lowerCAmelCase   :int						=			os.path.join(
											    UpperCAmelCase     , (filename_prefix + '-' if filename_prefix else '') + VOCAB_FILES_NAMES['vocab_file']   )

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

											return (out_vocab_file,)







"""simple docstring"""


import math


def        UpperCAmelCase      (					a__     ,      a__ ):





						'''simple docstring'''






						if 0 not in (x, y):
												# We use the relation x^y = y*log10(x), where 10 is the base.
												return y * math.logaa(a__ )
						else:
												if x == 0:  # 0 raised to any number is 0
																		return 0
												elif y == 0:
																		return 1  # any number raised to 0 is 1
						raise AssertionError('This should never happen' )


if __name__ == "__main__":  # Main function
		# Read two numbers from input and typecast them to int using map function.
		# Here x is the base and y is the power.
		__SCREAMING_SNAKE_CASE   =   'Enter the base and the power separated by a comma: '
		__SCREAMING_SNAKE_CASE,						__SCREAMING_SNAKE_CASE   =   map(int, input(prompt).split(','))
		__SCREAMING_SNAKE_CASE,						__SCREAMING_SNAKE_CASE   =   map(int, input(prompt).split(','))

		# We find the log of each number, using the function res(), which takes two
		# arguments.
		__SCREAMING_SNAKE_CASE   =   res(xa, ya)
		__SCREAMING_SNAKE_CASE   =   res(xa, ya)

		# We check for the largest number
		if resa > resa:
				print('Largest number is', xa, '^', ya)
		elif resa > resa:
				print('Largest number is', xa, '^', ya)
		else:
				print('Both are equal')