






"""simple docstring"""


import torch

from transformers import AutoTokenizer






class 		snake_case    (    UpperCAmelCase			):





    def __init__(				self      :   List[Any]							,						A      :   str     ):


      '''simple docstring'''




      a	:     Optional[Any]							=  AutoTokenizer.from_pretrained(A     )





    def 							lowerCamelCase__ (				self      :   Tuple							,						A      :   Tuple     ):


      '''simple docstring'''




      if isinstance(A							,						A     ) and all(isinstance(_x							,						A     ) for _x in x     ):
        a	:     str							=  None
        for l in x:
          a	:     Dict							=  self.tokenizer(
              A							,						padding='max_length'							,						max_length=3_8_4							,						truncation=A							,						return_tensors='pt'							,						)
          a	:     List[Any]							=  torch.tensor([len(A     )]     )
          if d is not None:
            for k in d.keys():
              a	:     List[Any]							=  torch.cat((d[k], t[k])							,						0     )
          else:
            a	:     Dict							=  t

        a	:     Any							=  torch.tensor(self.tokenizer.convert_tokens_to_ids('[E]'     )     )
        a	:     Optional[Any]							=  torch.tensor(self.tokenizer.convert_tokens_to_ids('[/E]'     )     )

      elif isinstance(A							,						A     ) and all(isinstance(_x							,						A     ) for _x in x     ):
        a	:     Dict							=  self.tokenizer(
            A							,						padding='max_length'							,						max_length=3_8_4							,						truncation=A							,						return_tensors='pt'							,						)

      else:
        raise Exception(
            'Type of parameter x was not recognized! Only `list of strings` for query or `list of lists of'
            ' strings` for supports are supported.'     )

      return d





    def 							lowerCamelCase__ (				self      :   Union[str, Any]							,						A      :   List[Any]							,						A      :   int							,						A      :   Optional[Any]							,						A      :   Union[str, Any]							,						A      :   Dict=0.70     ):


      '''simple docstring'''




      a	:     Union[str, Any]							=  []
      for idx in range(len(W_query['input_ids']     )     ):
        a	:     Dict							=  range(p_start.shape[1]     )

        a	:     Optional[int]							=  []
        for start_id in start_indexes:
          for end_id in end_indexes:
            if start_id < end_id:
              output.append(
                  (
                      start_id,
                      end_id,
                      p_start[idx][start_id].item(),
                      p_end[idx][end_id].item(),
                  )     )

        output.sort(key=lambda A     : (tup[2] * tup[3])							,						reverse=A     )
        a	:     Optional[int]							=  []
        for k in range(len(A     )     ):
          if output[k][2] * output[k][3] >= thresh:
            a,	a	:     Tuple							=  output[k][0], output[k][1]
            a	:     int							=  self.tokenizer.decode(W_query['input_ids'][idx][c_start_pos:c_end_pos]     )
            temp.append((decoded, output[k][2] * output[k][3])     )

        final_outputs.append(A     )

      return final_outputs












"""simple docstring"""


_UpperCamelCase							:       str       					=		10**8




def      snake_case    (A_ :int ):







  '''simple docstring'''

  if n % 1_0 == 0:
    return False
  a	:     Optional[int]							=  str(A_ )
  return s == s[::-1]




def      snake_case    ():







  '''simple docstring'''

  a	:     Tuple							=  set()
  a	:     Optional[Any]							=  1
  a	:     List[str]							=  5
  while sum_squares < LIMIT:
    a	:     int							=  first_square + 1
    while sum_squares < LIMIT:
      if is_palindrome(A_ ):
        answer.add(A_ )
      last_square += 1
      sum_squares += last_square**2
    first_square += 1
    a	:     List[str]							=  first_square**2 + (first_square + 1) ** 2

  return sum(A_ )


if __name__ == "__main__":
   print(solution())




