code: 
  
  
  def       a__						(		):
  
    for a in range(300    ):
      for b in range(a + 1	,      400    ):
        for c in range(b + 1	,      500    ):
          if (a + b + c) == 1000 and (a**2) + (b**2) == (c**2):
            return a * b * c
  
    return -1
  
  
  
  
  def       a__						(		):
  
    for a in range(300    ):
      for b in range(400    ):
        _UpperCAmelCase		:       Union[str, Any]       =    1000 - a - b
        if a < b < c and (a**2) + (b**2) == (c**2):
          return a * b * c
  
    return -1
  
  
  
  
  def       a__						(		):
    import timeit
  
    print(
        timeit.timeit("""solution()"""	,      setup="""from __main__ import solution"""	,      number=1000    )    )
    print(
        timeit.timeit(
            """solution_fast()"""	,      setup="""from __main__ import solution_fast"""	,      number=1000    )    )
  
  
  if __name__ == "__main__":
   print(F'{solution() = }')
  
  
  
  
  
  
style_context: 
  
  
  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_xlm_roberta import XLMRobertaTokenizer
  else:
   SCREAMING_SNAKE_CASE__				:    Optional[Any]         =    None
  
  
  SCREAMING_SNAKE_CASE__				:    Dict         =    logging.get_logger(__name__)
  
  SCREAMING_SNAKE_CASE__				:    List[Any]         =    {'vocab_file': 'sentencepiece.bpe.model', 'tokenizer_file': 'tokenizer.json'}
  
  SCREAMING_SNAKE_CASE__				:    Any         =    {
      'vocab_file': {
          'xlm-roberta-base': 'https://huggingface.co/xlm-roberta-base/resolve/main/sentencepiece.bpe.model',
          'xlm-roberta-large': 'https://huggingface.co/xlm-roberta-large/resolve/main/sentencepiece.bpe.model',
          'xlm-roberta-large-finetuned-conll02-dutch': (
              'https://huggingface.co/xlm-roberta-large-finetuned-conll02-dutch/resolve/main/sentencepiece.bpe.model'
          ),
          'xlm-roberta-large-finetuned-conll02-spanish': (
              'https://huggingface.co/xlm-roberta-large-finetuned-conll02-spanish/resolve/main/sentencepiece.bpe.model'
          ),
          'xlm-roberta-large-finetuned-conll03-english': (
              'https://huggingface.co/xlm-roberta-large-finetuned-conll03-english/resolve/main/sentencepiece.bpe.model'
          ),
          'xlm-roberta-large-finetuned-conll03-german': (
              'https://huggingface.co/xlm-roberta-large-finetuned-conll03-german/resolve/main/sentencepiece.bpe.model'
          ),
      },
      'tokenizer_file': {
          'xlm-roberta-base': 'https://huggingface.co/xlm-roberta-base/resolve/main/tokenizer.json',
          'xlm-roberta-large': 'https://huggingface.co/xlm-roberta-large/resolve/main/tokenizer.json',
          'xlm-roberta-large-finetuned-conll02-dutch': (
              'https://huggingface.co/xlm-roberta-large-finetuned-conll02-dutch/resolve/main/tokenizer.json'
          ),
          'xlm-roberta-large-finetuned-conll02-spanish': (
              'https://huggingface.co/xlm-roberta-large-finetuned-conll02-spanish/resolve/main/tokenizer.json'
          ),
          'xlm-roberta-large-finetuned-conll03-english': (
              'https://huggingface.co/xlm-roberta-large-finetuned-conll03-english/resolve/main/tokenizer.json'
          ),
          'xlm-roberta-large-finetuned-conll03-german': (
              'https://huggingface.co/xlm-roberta-large-finetuned-conll03-german/resolve/main/tokenizer.json'
          ),
      },
  }
  
  SCREAMING_SNAKE_CASE__				:    Optional[int]         =    {
      'xlm-roberta-base': 512,
      'xlm-roberta-large': 512,
      'xlm-roberta-large-finetuned-conll02-dutch': 512,
      'xlm-roberta-large-finetuned-conll02-spanish': 512,
      'xlm-roberta-large-finetuned-conll03-english': 512,
      'xlm-roberta-large-finetuned-conll03-german': 512,
  }
  
  
  class 		_SCREAMING_SNAKE_CASE    (	A    ):
       __SCREAMING_SNAKE_CASE    				=						VOCAB_FILES_NAMES
       __SCREAMING_SNAKE_CASE    				=						PRETRAINED_VOCAB_FILES_MAP
       __SCREAMING_SNAKE_CASE    				=						PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
       __SCREAMING_SNAKE_CASE    				=						['''input_ids''', '''attention_mask''']
       __SCREAMING_SNAKE_CASE    				=						XLMRobertaTokenizer
  
  
       def __init__(     self       ,				A_=None       ,				A_=None       ,				A_="<s>"       ,				A_="</s>"       ,				A_="</s>"       ,				A_="<s>"       ,				A_="<unk>"       ,				A_="<pad>"       ,				A_="<mask>"       ,				**A_       ,				):
         # Mask token behave like a normal word, i.e. include the space before it
         _UpperCAmelCase		:       int       =    AddedToken(A_       ,				lstrip=A_       ,				rstrip=A_						) if isinstance(A_       ,				A_						) else mask_token
  
         super().__init__(
             A_       ,				tokenizer_file=A_       ,				bos_token=A_       ,				eos_token=A_       ,				sep_token=A_       ,				cls_token=A_       ,				unk_token=A_       ,				pad_token=A_       ,				mask_token=A_       ,				**A_       ,				)
  
         _UpperCAmelCase		:       Union[str, Any]       =    vocab_file
         _UpperCAmelCase		:       List[str]       =    False if not self.vocab_file else True
  
  
       def 					__snake_case(     self       ,				A_       ,				A_ = None						):
  
         if token_ids_a is None:
           return [self.cls_token_id] + token_ids_a + [self.sep_token_id]
         _UpperCAmelCase		:       Optional[Any]       =    [self.cls_token_id]
         _UpperCAmelCase		:       Union[str, Any]       =    [self.sep_token_id]
         return cls + token_ids_a + sep + sep + token_ids_a + sep
  
  
       def 					__snake_case(     self       ,				A_       ,				A_ = None						):
         _UpperCAmelCase		:       Tuple       =    [self.sep_token_id]
         _UpperCAmelCase		:       Optional[int]       =    [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 + sep + token_ids_a + sep						) * [0]
  
  
  
  
       def 					__snake_case(     self       ,				A_       ,				A_ = None						):
         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(A_						):
           logger.error(F'''Vocabulary path ({save_directory}) should be a directory.'''						)
           return
         _UpperCAmelCase		:       List[str]       =    os.path.join(
             A_       ,				(filename_prefix + """-""" if filename_prefix else """""") + VOCAB_FILES_NAMES["""vocab_file"""]						)
  
         if os.path.abspath(self.vocab_file						) != os.path.abspath(A_						):
           copyfile(self.vocab_file       ,				A_						)
  
         return (out_vocab_file,)
  
  
  
  
  
  