



import json
from typing import List, Optional, Tuple

from tokenizers import normalizers

from ...tokenization_utils_fast import PreTrainedTokenizerFast
from .tokenization_electra import ElectraTokenizer


lowercase_								=     {"""vocab_file""": """vocab.txt""", """tokenizer_file""": """tokenizer.json"""}

lowercase_								=     {
    """vocab_file""": {
        """google/electra-small-generator""": (
            """https://huggingface.co/google/electra-small-generator/resolve/main/vocab.txt"""
        ),
        """google/electra-base-generator""": """https://huggingface.co/google/electra-base-generator/resolve/main/vocab.txt""",
        """google/electra-large-generator""": (
            """https://huggingface.co/google/electra-large-generator/resolve/main/vocab.txt"""
        ),
        """google/electra-small-discriminator""": (
            """https://huggingface.co/google/electra-small-discriminator/resolve/main/vocab.txt"""
        ),
        """google/electra-base-discriminator""": (
            """https://huggingface.co/google/electra-base-discriminator/resolve/main/vocab.txt"""
        ),
        """google/electra-large-discriminator""": (
            """https://huggingface.co/google/electra-large-discriminator/resolve/main/vocab.txt"""
        ),
    },
    """tokenizer_file""": {
        """google/electra-small-generator""": (
            """https://huggingface.co/google/electra-small-generator/resolve/main/tokenizer.json"""
        ),
        """google/electra-base-generator""": (
            """https://huggingface.co/google/electra-base-generator/resolve/main/tokenizer.json"""
        ),
        """google/electra-large-generator""": (
            """https://huggingface.co/google/electra-large-generator/resolve/main/tokenizer.json"""
        ),
        """google/electra-small-discriminator""": (
            """https://huggingface.co/google/electra-small-discriminator/resolve/main/tokenizer.json"""
        ),
        """google/electra-base-discriminator""": (
            """https://huggingface.co/google/electra-base-discriminator/resolve/main/tokenizer.json"""
        ),
        """google/electra-large-discriminator""": (
            """https://huggingface.co/google/electra-large-discriminator/resolve/main/tokenizer.json"""
        ),
    },
}

lowercase_								=     {
    """google/electra-small-generator""": 512,
    """google/electra-base-generator""": 512,
    """google/electra-large-generator""": 512,
    """google/electra-small-discriminator""": 512,
    """google/electra-base-discriminator""": 512,
    """google/electra-large-discriminator""": 512,
}

lowercase_								=     {
    """google/electra-small-generator""": {"""do_lower_case""": True},
    """google/electra-base-generator""": {"""do_lower_case""": True},
    """google/electra-large-generator""": {"""do_lower_case""": True},
    """google/electra-small-discriminator""": {"""do_lower_case""": True},
    """google/electra-base-discriminator""": {"""do_lower_case""": True},
    """google/electra-large-discriminator""": {"""do_lower_case""": True},
}
class 				_snake_case			(					lowercase__):
				UpperCamelCase__				:					Optional[Any]  		=VOCAB_FILES_NAMES
				UpperCamelCase__				:					Dict  		=PRETRAINED_VOCAB_FILES_MAP
				UpperCamelCase__				:					Union[str, Any]  		=PRETRAINED_INIT_CONFIGURATION
				UpperCamelCase__				:					Tuple  		=PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
				UpperCamelCase__				:					Union[str, Any]  		=ElectraTokenizer




				def __init__(						self					:						int,					__lowercase					:						Union[str, Any]=None,					__lowercase					:						Any=None,					__lowercase					:						int=True,					__lowercase					:						Tuple="[UNK]",					__lowercase					:						List[str]="[SEP]",					__lowercase					:						Union[str, Any]="[PAD]",					__lowercase					:						List[str]="[CLS]",					__lowercase					:						Union[str, Any]="[MASK]",					__lowercase					:						Optional[Any]=True,					__lowercase					:						Tuple=None,					**__lowercase					:						Dict,					):
							super().__init__(
							    __lowercase,					tokenizer_file=__lowercase,					do_lower_case=__lowercase,					unk_token=__lowercase,					sep_token=__lowercase,					pad_token=__lowercase,					cls_token=__lowercase,					mask_token=__lowercase,					tokenize_chinese_chars=__lowercase,					strip_accents=__lowercase,					**__lowercase,					)

							lowercase__					  =				json.loads(self.backend_tokenizer.normalizer.__getstate__()						)
							if (
							    normalizer_state.get("lowercase",					__lowercase						) != do_lower_case
							    or normalizer_state.get("strip_accents",					__lowercase						) != strip_accents
							    or normalizer_state.get("handle_chinese_chars",					__lowercase						) != tokenize_chinese_chars
							):
										lowercase__					  =				getattr(__lowercase,					normalizer_state.pop("type"						)						)
										lowercase__					  =				do_lower_case
										lowercase__					  =				strip_accents
										lowercase__					  =				tokenize_chinese_chars
										lowercase__					  =				normalizer_class(**__lowercase						)

							lowercase__					  =				do_lower_case




				def 							A__      (						self					:						Optional[Any],					__lowercase					:						Optional[int],					__lowercase					:						Any=None						):
							lowercase__					  =				[self.cls_token_id] + token_ids_a + [self.sep_token_id]

							if token_ids_a:
										output += token_ids_a + [self.sep_token_id]

							return output




				def 							A__      (						self					:						int,					__lowercase					:						List[int],					__lowercase					:						Optional[List[int]] = None						):
							lowercase__					  =				[self.sep_token_id]
							lowercase__					  =				[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 							A__      (						self					:						Any,					__lowercase					:						str,					__lowercase					:						Optional[str] = None						):
							lowercase__					  =				self._tokenizer.model.save(__lowercase,					name=__lowercase						)
							return tuple(__lowercase						)









import math



def __lowerCAmelCase (     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.
							lowercase_								=     """Enter the base and the power separated by a comma: """
							lowercase_				,    lowercase_								=     map(int, input(prompt).split(""","""))
							lowercase_				,    lowercase_								=     map(int, input(prompt).split(""","""))

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




