
'''simple docstring'''
import json
from typing import List, Optional, Tuple

from tokenizers import normalizers

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


__lowerCAmelCase												=	{'vocab_file': 'vocab.txt', 'tokenizer_file': 'tokenizer.json'}

__lowerCAmelCase												=	{
    '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'
        ),
    },
}

__lowerCAmelCase												=	{
    '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,
}

__lowerCAmelCase												=	{
    '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       _lowerCAmelCase   (   __snake_case				):







							'''simple docstring'''

							lowerCAmelCase_ 						=						VOCAB_FILES_NAMES
							lowerCAmelCase_ 						=						PRETRAINED_VOCAB_FILES_MAP
							lowerCAmelCase_ 						=						PRETRAINED_INIT_CONFIGURATION
							lowerCAmelCase_ 						=						PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
							lowerCAmelCase_ 						=						ElectraTokenizer

							def __init__(self  ,  UpperCAmelCase=None  ,  UpperCAmelCase=None  ,  UpperCAmelCase=True  ,  UpperCAmelCase="[UNK]"  ,  UpperCAmelCase="[SEP]"  ,  UpperCAmelCase="[PAD]"  ,  UpperCAmelCase="[CLS]"  ,  UpperCAmelCase="[MASK]"  ,  UpperCAmelCase=True  ,  UpperCAmelCase=None  ,  **UpperCAmelCase  ,  )					->       Tuple:
														super().__init__(
														    UpperCAmelCase  ,  tokenizer_file=UpperCAmelCase  ,  do_lower_case=UpperCAmelCase  ,  unk_token=UpperCAmelCase  ,  sep_token=UpperCAmelCase  ,  pad_token=UpperCAmelCase  ,  cls_token=UpperCAmelCase  ,  mask_token=UpperCAmelCase  ,  tokenize_chinese_chars=UpperCAmelCase  ,  strip_accents=UpperCAmelCase  ,  **UpperCAmelCase  ,  )

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

														_snake_case       =  do_lower_case

							def 	lowercase							(self  ,  UpperCAmelCase  ,  UpperCAmelCase=None  )					->       Tuple:
														_snake_case       =  [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 	lowercase							(self  ,  UpperCAmelCase  ,  UpperCAmelCase = None  )					->       List[int]:
														_snake_case       =  [self.sep_token_id]
														_snake_case       =  [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 	lowercase							(self  ,  UpperCAmelCase  ,  UpperCAmelCase = None  )					->       Tuple[str]:
														_snake_case       =  self._tokenizer.model.save(UpperCAmelCase  ,  name=UpperCAmelCase  )
														return tuple(UpperCAmelCase  )

'''simple docstring'''
from __future__ import annotations

import typing
from collections import Counter






def  __SCREAMING_SNAKE_CASE				(  _SCREAMING_SNAKE_CASE				):
							_snake_case       =  Counter()
							for base in range(1							, max_perimeter + 1				):
														for perpendicular in range(_SCREAMING_SNAKE_CASE							, max_perimeter + 1				):
																					_snake_case       =  (base * base + perpendicular * perpendicular) ** 0.5
																					if hypotenuse == int(_SCREAMING_SNAKE_CASE				):
																												_snake_case       =  int(base + perpendicular + hypotenuse				)
																												if perimeter > max_perimeter:
																																			continue
																												triplets[perimeter] += 1
							return triplets






def  __SCREAMING_SNAKE_CASE				(  _SCREAMING_SNAKE_CASE = 1000				):
							_snake_case       =  pythagorean_triple(_SCREAMING_SNAKE_CASE				)
							return triplets.most_common(1				)[0][0]


if __name__ == "__main__":
				print(f'''Perimeter {solution()} has maximum solutions''')