



import torch

from transformers import AutoTokenizer







class      __lowerCAmelCase       (     A		):



			def __init__(		self  :    Union[str, Any]					,						A  :    List[Any])  ->       Dict:



						"""simple docstring"""






						_UpperCAmelCase									=  AutoTokenizer.from_pretrained(A)



			def        _lowerCamelCase			(		self  :    Optional[int]					,						A  :    Tuple)  ->       Tuple:



						"""simple docstring"""






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

									_UpperCAmelCase									=  torch.tensor(self.tokenizer.convert_tokens_to_ids('[E]'))
									_UpperCAmelCase									=  torch.tensor(self.tokenizer.convert_tokens_to_ids('[/E]'))

						elif isinstance(A					,						A) and all(isinstance(_x					,						A) for _x in x):
									_UpperCAmelCase									=  self.tokenizer(
									    A					,						padding='max_length'					,						max_length=3_84					,						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  :    str					,						A  :    Union[str, Any]					,						A  :    Union[str, Any]					,						A  :    Union[str, Any]					,						A  :    Union[str, Any]=0.7_0)  ->       List[str]:



						"""simple docstring"""






						_UpperCAmelCase									=  []
						for idx in range(len(W_query['input_ids'])):
									_UpperCAmelCase									=  _UpperCAmelCase									=  range(p_start.shape[1])

									_UpperCAmelCase									=  []
									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)
									_UpperCAmelCase									=  []
									for k in range(len(A)):
												if output[k][2] * output[k][3] >= thresh:
															_UpperCAmelCase			,	_UpperCAmelCase									=  output[k][0], output[k][1]
															_UpperCAmelCase									=  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





UpperCAmelCase__  =			10**8





def 				A      (	_UpperCAmelCase							:  int       )							->					bool:







			'''simple docstring'''
			if n % 10 == 0:
						return False
			_UpperCAmelCase									=  str(_UpperCAmelCase       )
			return s == s[::-1]





def 				A      (	)							->					int:







			'''simple docstring'''
			_UpperCAmelCase									=  set()
			_UpperCAmelCase									=  1
			_UpperCAmelCase									=  5
			while sum_squares < LIMIT:
						_UpperCAmelCase									=  first_square + 1
						while sum_squares < LIMIT:
									if is_palindrome(_UpperCAmelCase       ):
												answer.add(_UpperCAmelCase       )
									last_square += 1
									sum_squares += last_square**2
						first_square += 1
						_UpperCAmelCase									=  first_square**2 + (first_square + 1) ** 2

			return sum(_UpperCAmelCase       )


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