import warnings
from typing import Dict, List, Optional, Tuple

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


__UpperCamelCase		:       List[Any]									=     logging.get_logger(__name__)





class 					lowercase__						(   __A):
						UpperCamelCase_     =		["input_ids", "attention_mask"]


						def __init__(       self	:				List[Any]    ,		UpperCamelCase__	:				str="</s>"    ,		UpperCamelCase__	:				List[Any]="<unk>"    ,		UpperCamelCase__	:				Optional[int]="<pad>"    ,		UpperCamelCase__	:				Optional[int]=125    ,		UpperCamelCase__	:				Dict=None    ,		**UpperCamelCase__	:				Tuple    ,		):





												'''simple docstring'''





												if extra_ids > 0 and additional_special_tokens is None:
																		SCREAMING_SNAKE_CASE							:    Any							=							[f"""<extra_id_{i}>""" for i in range(_UpperCamelCase						)]
												elif extra_ids > 0 and additional_special_tokens is not None:
																		# Check that we have the right number of extra_id special tokens
																		SCREAMING_SNAKE_CASE							:    str							=							len(set(filter(lambda UpperCamelCase__						: bool('''extra_id''' in str(_UpperCamelCase						)						)    ,		_UpperCamelCase						)						)						)
																		if extra_tokens != extra_ids:
																								raise ValueError(
																								    f"""Both extra_ids ({extra_ids}) and additional_special_tokens ({additional_special_tokens}) are"""
																								    ''' provided to ByT5Tokenizer. In this case the additional_special_tokens must include the'''
																								    ''' extra_ids tokens'''						)

												SCREAMING_SNAKE_CASE							:    int							=							AddedToken(_UpperCamelCase    ,		lstrip=_UpperCamelCase    ,		rstrip=_UpperCamelCase						) if isinstance(_UpperCamelCase    ,		_UpperCamelCase						) else pad_token
												SCREAMING_SNAKE_CASE							:    Optional[int]							=							AddedToken(_UpperCamelCase    ,		lstrip=_UpperCamelCase    ,		rstrip=_UpperCamelCase						) if isinstance(_UpperCamelCase    ,		_UpperCamelCase						) else eos_token
												SCREAMING_SNAKE_CASE							:    Tuple							=							AddedToken(_UpperCamelCase    ,		lstrip=_UpperCamelCase    ,		rstrip=_UpperCamelCase						) if isinstance(_UpperCamelCase    ,		_UpperCamelCase						) else unk_token

												super().__init__(
												    eos_token=_UpperCamelCase    ,		unk_token=_UpperCamelCase    ,		pad_token=_UpperCamelCase    ,		extra_ids=_UpperCamelCase    ,		additional_special_tokens=_UpperCamelCase    ,		**_UpperCamelCase    ,		)

												SCREAMING_SNAKE_CASE							:    List[str]							=							extra_ids

												SCREAMING_SNAKE_CASE							:    Tuple							=							2**8  # utf is 8 bits

												# define special tokens dict
												SCREAMING_SNAKE_CASE							:    Dict							=							{
												    self.pad_token: 0,
												    self.eos_token: 1,
												    self.unk_token: 2,
												}
												SCREAMING_SNAKE_CASE							:    str							=							len(self.special_tokens_encoder						)
												SCREAMING_SNAKE_CASE							:    Optional[int]							=							len(_UpperCamelCase						)
												for i, token in enumerate(_UpperCamelCase						):
																		SCREAMING_SNAKE_CASE							:    List[str]							=							self.vocab_size + i - n
												SCREAMING_SNAKE_CASE							:    Union[str, Any]							=							{v: k for k, v in self.special_tokens_encoder.items()}


						@property
						def        __A       (       self	:				Optional[int]						):





												'''simple docstring'''





												return self._utf_vocab_size + self._num_special_tokens + self._extra_ids


						def        __A       (       self	:				Tuple    ,		UpperCamelCase__	:				List[int]    ,		UpperCamelCase__	:				Optional[List[int]] = None    ,		UpperCamelCase__	:				bool = 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						)

												# normal case: some special tokens
												if token_ids_a is None:
																		return ([0] * len(_UpperCamelCase						)) + [1]
												return ([0] * len(_UpperCamelCase						)) + [1] + ([0] * len(_UpperCamelCase						)) + [1]


						def        __A       (       self	:				Union[str, Any]    ,		UpperCamelCase__	:				List[int]						):





												'''simple docstring'''





												if len(_UpperCamelCase						) > 0 and token_ids[-1] == self.eos_token_id:
																		warnings.warn(
																		    f"""This sequence already has {self.eos_token}. In future versions this behavior may lead to duplicated"""
																		    ''' eos tokens being added.'''						)
																		return token_ids
												else:
																		return token_ids + [self.eos_token_id]


						def        __A       (       self	:				Optional[Any]    ,		UpperCamelCase__	:				List[int]    ,		UpperCamelCase__	:				Optional[List[int]] = None						):





												'''simple docstring'''





												SCREAMING_SNAKE_CASE							:    List[str]							=							[self.eos_token_id]

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


						def        __A       (       self	:				Optional[Any]    ,		UpperCamelCase__	:				List[int]    ,		UpperCamelCase__	:				Optional[List[int]] = None						):





												'''simple docstring'''





												SCREAMING_SNAKE_CASE							:    Optional[Any]							=							self._add_eos_if_not_present(_UpperCamelCase						)
												if token_ids_a is None:
																		return token_ids_a
												else:
																		SCREAMING_SNAKE_CASE							:    Any							=							self._add_eos_if_not_present(_UpperCamelCase						)
																		return token_ids_a + token_ids_a


						def        __A       (       self	:				Optional[int]    ,		UpperCamelCase__	:				str						):





												'''simple docstring'''





												SCREAMING_SNAKE_CASE							:    List[Any]							=							[chr(_UpperCamelCase						) for i in text.encode('''utf-8'''						)]
												return tokens


						def        __A       (       self	:				List[str]    ,		UpperCamelCase__	:				Union[str, Any]						):





												'''simple docstring'''





												if token in self.special_tokens_encoder:
																		SCREAMING_SNAKE_CASE							:    Tuple							=							self.special_tokens_encoder[token]
												elif token in self.added_tokens_encoder:
																		SCREAMING_SNAKE_CASE							:    Any							=							self.added_tokens_encoder[token]
												elif len(_UpperCamelCase						) != 1:
																		SCREAMING_SNAKE_CASE							:    List[str]							=							self.unk_token_id
												else:
																		SCREAMING_SNAKE_CASE							:    List[str]							=							ord(_UpperCamelCase						) + self._num_special_tokens
												return token_id


						def        __A       (       self	:				int    ,		UpperCamelCase__	:				Tuple						):





												'''simple docstring'''





												if index in self.special_tokens_decoder:
																		SCREAMING_SNAKE_CASE							:    Any							=							self.special_tokens_decoder[index]
												else:
																		SCREAMING_SNAKE_CASE							:    str							=							chr(index - self._num_special_tokens						)
												return token


						def        __A       (       self	:				int    ,		UpperCamelCase__	:				List[Any]						):





												'''simple docstring'''





												SCREAMING_SNAKE_CASE							:    List[Any]							=							B''''''
												for token in tokens:
																		if token in self.special_tokens_decoder:
																								SCREAMING_SNAKE_CASE							:    Any							=							self.special_tokens_decoder[token].encode('''utf-8'''						)
																		elif token in self.added_tokens_decoder:
																								SCREAMING_SNAKE_CASE							:    List[Any]							=							self.special_tokens_decoder[token].encode('''utf-8'''						)
																		elif token in self.special_tokens_encoder:
																								SCREAMING_SNAKE_CASE							:    int							=							token.encode('''utf-8'''						)
																		elif token in self.added_tokens_encoder:
																								SCREAMING_SNAKE_CASE							:    List[str]							=							token.encode('''utf-8'''						)
																		else:
																								SCREAMING_SNAKE_CASE							:    Optional[Any]							=							bytes([ord(_UpperCamelCase						)]						)
																		bstring += tok_string
												SCREAMING_SNAKE_CASE							:    List[Any]							=							bstring.decode('''utf-8'''    ,		errors='''ignore'''						)
												return string



						def        __A       (       self	:				Dict    ,		UpperCamelCase__	:				str    ,		UpperCamelCase__	:				Optional[str] = None						):





												'''simple docstring'''





												return ()








import math


def   __SCREAMING_SNAKE_CASE					(SCREAMING_SNAKE_CASE__  ,		SCREAMING_SNAKE_CASE__       ):
						if 0 not in (x, y):
												# We use the relation x^y = y*log10(x), where 10 is the base.
												return y * math.logaa(SCREAMING_SNAKE_CASE__       )
						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.
					lowerCAmelCase_       	=	'''Enter the base and the power separated by a comma: '''
					lowerCAmelCase_	,      lowerCAmelCase_       	=	map(int, input(prompt).split(''','''))
					lowerCAmelCase_	,      lowerCAmelCase_       	=	map(int, input(prompt).split(''','''))

					# We find the log of each number, using the function res(), which takes two
					# arguments.
					lowerCAmelCase_       	=	res(xa, ya)
					lowerCAmelCase_       	=	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''')