code: 
  
  
  
  
  '''simple docstring'''
  
  
  
  
  
  import math
  
  
  def 				UpperCamelCase	(  snake_case   ):
  
  
  
  
     '''simple docstring'''
  
     if 1 < number < 4:
        # 2 and 3 are primes
        return True
     elif number < 2 or number % 2 == 0 or number % 3 == 0:
        # Negatives, 0, 1, all even numbers, all multiples of 3 are not primes
        return False
  
     # All primes number are in format of 6k +/- 1
     for i in range(5	,     int(math.sqrt(snake_case   ) + 1   )	,     6   ):
        if number % i == 0 or number % (i + 2) == 0:
           return False
     return True
  
  
  def 				UpperCamelCase	(  snake_case = 10_00	,     snake_case = 10_00   ):
  
  
  
  
     '''simple docstring'''
  
     SCREAMING_SNAKE_CASE__			:				Optional[int]       						= [0, 0, 0]  # length, a, b
     for a in range((a_limit * -1) + 1	,     snake_case   ):
        for b in range(2	,     snake_case   ):
           if is_prime(snake_case   ):
              SCREAMING_SNAKE_CASE__			:				Optional[int]       						= 0
              SCREAMING_SNAKE_CASE__			:				Optional[int]       						= 0
              while is_prime((n**2) + (a * n) + b   ):
                 count += 1
                 n += 1
              if count > longest[0]:
                 SCREAMING_SNAKE_CASE__			:				Any       						= [count, a, b]
     SCREAMING_SNAKE_CASE__			:				List[str]       						= longest[1] * longest[2]
     return ans
  
  
  if __name__ == "__main__":
         print(solution(1_0_0_0, 1_0_0_0))
  
  
style_context: 
  
  
  
  
  '''simple docstring'''
  
  
  
  
  
  import json
  from typing import List, Optional, Tuple
  
  from tokenizers import normalizers
  
  from ...tokenization_utils_fast import PreTrainedTokenizerFast
  from ...utils import logging
  from .tokenization_splinter import SplinterTokenizer
  
  
  lowercase__			=	logging.get_logger(__name__)
  
  lowercase__			=	{'''vocab_file''': '''vocab.txt'''}
  
  lowercase__			=	{
      '''vocab_file''': {
          '''tau/splinter-base''': '''https://huggingface.co/tau/splinter-base/resolve/main/vocab.txt''',
          '''tau/splinter-base-qass''': '''https://huggingface.co/tau/splinter-base-qass/resolve/main/vocab.txt''',
          '''tau/splinter-large''': '''https://huggingface.co/tau/splinter-large/resolve/main/vocab.txt''',
          '''tau/splinter-large-qass''': '''https://huggingface.co/tau/splinter-large-qass/resolve/main/vocab.txt''',
      }
  }
  
  lowercase__			=	{
      '''tau/splinter-base''': 5_1_2,
      '''tau/splinter-base-qass''': 5_1_2,
      '''tau/splinter-large''': 5_1_2,
      '''tau/splinter-large-qass''': 5_1_2,
  }
  
  lowercase__			=	{
      '''tau/splinter-base''': {'''do_lower_case''': False},
      '''tau/splinter-base-qass''': {'''do_lower_case''': False},
      '''tau/splinter-large''': {'''do_lower_case''': False},
      '''tau/splinter-large-qass''': {'''do_lower_case''': False},
  }
  
  
  
  
  
  
  class 						lowercase     (   UpperCAmelCase_):
        __lowercase 		=  VOCAB_FILES_NAMES
        __lowercase 		=  PRETRAINED_VOCAB_FILES_MAP
        __lowercase 		=  PRETRAINED_INIT_CONFIGURATION
        __lowercase 		=  PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
        __lowercase 		=  SplinterTokenizer
  
  
  
  
  
  
        def __init__(self ,  a__=None ,  a__=None ,  a__=True ,  a__="[UNK]" ,  a__="[SEP]" ,  a__="[PAD]" ,  a__="[CLS]" ,  a__="[MASK]" ,  a__="[QUESTION]" ,  a__=True ,  a__=None ,  **a__ ,  )       ->   Any:
           super().__init__(
               a__ ,  tokenizer_file=a__ ,  do_lower_case=a__ ,  unk_token=a__ ,  sep_token=a__ ,  pad_token=a__ ,  cls_token=a__ ,  mask_token=a__ ,  tokenize_chinese_chars=a__ ,  strip_accents=a__ ,  additional_special_tokens=(question_token,) ,  **a__ ,  )
  
           SCREAMING_SNAKE_CASE__			:				Tuple       						= json.loads(self.backend_tokenizer.normalizer.__getstate__()					)
           if (
               pre_tok_state.get('''lowercase''' ,  a__					) != do_lower_case
               or pre_tok_state.get('''strip_accents''' ,  a__					) != strip_accents
           ):
              SCREAMING_SNAKE_CASE__			:				List[Any]       						= getattr(a__ ,  pre_tok_state.pop('''type'''					)					)
              SCREAMING_SNAKE_CASE__			:				Optional[int]       						= do_lower_case
              SCREAMING_SNAKE_CASE__			:				Optional[int]       						= strip_accents
              SCREAMING_SNAKE_CASE__			:				Optional[Any]       						= pre_tok_class(**a__					)
  
           SCREAMING_SNAKE_CASE__			:				Optional[int]       						= do_lower_case
  
  
  
  
  
  
        @property
        def    A__(self					)       ->   List[str]:
           return self.convert_tokens_to_ids(self.question_token					)
  
  
  
  
  
  
        def    A__(self ,  a__ ,  a__ = None					)       ->   List[int]:
           if token_ids_a is None:
              return [self.cls_token_id] + token_ids_a + [self.sep_token_id]
  
           SCREAMING_SNAKE_CASE__			:				Dict       						= [self.cls_token_id]
           SCREAMING_SNAKE_CASE__			:				Tuple       						= [self.sep_token_id]
           SCREAMING_SNAKE_CASE__			:				List[Any]       						= [self.question_token_id] + [self.convert_tokens_to_ids('''.'''					)]
           if self.padding_side == "right":
              # Input is question-then-context
              return cls + token_ids_a + question_suffix + sep + token_ids_a + sep
           else:
              # Input is context-then-question
              return cls + token_ids_a + sep + token_ids_a + question_suffix + sep
  
  
  
  
  
  
        def    A__(self ,  a__ ,  a__ = None					)       ->   List[int]:
           SCREAMING_SNAKE_CASE__			:				Optional[Any]       						= [self.sep_token_id]
           SCREAMING_SNAKE_CASE__			:				Any       						= [self.cls_token_id]
           SCREAMING_SNAKE_CASE__			:				Optional[Any]       						= [self.question_token_id] + [self.convert_tokens_to_ids('''.'''					)]
           if token_ids_a is None:
              return len(cls + token_ids_a + sep					) * [0]
  
           if self.padding_side == "right":
              # Input is question-then-context
              return len(cls + token_ids_a + question_suffix + sep					) * [0] + len(token_ids_a + sep					) * [1]
           else:
              # Input is context-then-question
              return len(cls + token_ids_a + sep					) * [0] + len(token_ids_a + question_suffix + sep					) * [1]
  
  
  
  
  
  
        def    A__(self ,  a__ ,  a__ = None					)       ->   Tuple[str]:
           SCREAMING_SNAKE_CASE__			:				int       						= self._tokenizer.model.save(a__ ,  name=a__					)
           return tuple(a__					)
  
  