'''simple docstring'''




import collections

from .utils import ExplicitEnum, is_torch_available, logging


if is_torch_available():
  import torch


__UpperCAmelCase  							=logging.get_logger(__name__)





class 					a__   :






     def __init__(				self	:	Optional[Any]						,       a	:	Optional[int]						,       a	:	List[Any]=21						,       a	:	Dict=[]						,       a	:	Optional[int]=None					):





         """simple docstring"""



         __lowerCamelCase						=						model
         __lowerCamelCase						=						trace_batch_nums
         __lowerCamelCase						=						abort_after_batch_num

         # keep a LIFO buffer of frames to dump as soon as inf/nan is encountered to give context to the problem emergence
         __lowerCamelCase						=						collections.deque([]						,       a					)
         __lowerCamelCase						=						[]
         __lowerCamelCase						=						0
         __lowerCamelCase						=						0
         __lowerCamelCase						=						False
         __lowerCamelCase						=						'''                 '''

         self.analyse_model()

         self.register_forward_hook()






     def      SCREAMING_SNAKE_CASE__     (				self	:	Union[str, Any]						,       a	:	int=None					):





         """simple docstring"""



         if frame is not None:
             self.expand_frame(a					)
         self.frames.append('''\n'''.join(self.frame					)					)
         __lowerCamelCase						=						[]  # start a new frame






     def      SCREAMING_SNAKE_CASE__     (				self	:	int						,       a	:	List[str]					):





         """simple docstring"""



         self.frame.append(a					)






     def      SCREAMING_SNAKE_CASE__     (				self	:	List[str]					):





         """simple docstring"""



         print('''\n'''.join(self.frames					)					)
         __lowerCamelCase						=						[]






     def      SCREAMING_SNAKE_CASE__     (				self	:	int					):





         """simple docstring"""



         __lowerCamelCase						=						[]






     def      SCREAMING_SNAKE_CASE__     (				self	:	int					):





         """simple docstring"""



         print(f"""\nDetected inf/nan during batch_number={self.batch_number}"""					)
         print(f"""Last {len(self.frames					)} forward frames:"""					)
         print(f"""{'abs min':8} {'abs max':8} metadata"""					)
         print('''\n'''.join(self.frames					)					)
         print('''\n\n'''					)
         __lowerCamelCase						=						[]






     def      SCREAMING_SNAKE_CASE__     (				self	:	Tuple					):





         """simple docstring"""



         __lowerCamelCase						=						{m: name for name, m in self.model.named_modules()}
         # self.longest_module_name = max(len(v) for v in self.module_names.values())






     def      SCREAMING_SNAKE_CASE__     (				self	:	Union[str, Any]						,       a	:	Dict						,       a	:	List[str]					):





         """simple docstring"""



         if torch.is_tensor(a					):
             self.expand_frame(get_abs_min_max(a						,       a					)					)
             if detect_overflow(a						,       a					):
                 __lowerCamelCase						=						True
         elif var is None:
             self.expand_frame(f"""{'None':>17} {ctx}"""					)
         else:
             self.expand_frame(f"""{'not a tensor':>17} {ctx}"""					)






     def      SCREAMING_SNAKE_CASE__     (				self	:	int					):





         """simple docstring"""



         self.expand_frame(f"""\n\n{self.prefix} *** Starting batch number={self.batch_number} ***"""					)
         self.expand_frame(f"""{'abs min':8} {'abs max':8} metadata"""					)






     def      SCREAMING_SNAKE_CASE__     (				self	:	List[str]					):





         """simple docstring"""



         self.expand_frame(f"""{self.prefix} *** Finished batch number={self.batch_number-1} ***\n\n"""					)






     def      SCREAMING_SNAKE_CASE__     (				self	:	Union[str, Any]						,       a	:	int						,       a	:	List[str]						,       a	:	Optional[Any]					):





         """simple docstring"""



         self.expand_frame(f"""{self.prefix} {self.module_names[module]} {module.__class__.__name__}"""					)

         # params
         for name, p in module.named_parameters(recurse=a					):
             self.analyse_variable(a						,       a					)

         # inputs
         if isinstance(a						,       a					):
             for i, x in enumerate(a					):
                 self.analyse_variable(a						,       f"""input[{i}]"""					)
         else:
             self.analyse_variable(a						,       '''input'''					)

         # outputs
         if isinstance(a						,       a					):
             for i, x in enumerate(a					):
                 # possibly a tuple of tuples
                 if isinstance(a						,       a					):
                     for j, y in enumerate(a					):
                         self.analyse_variable(a						,       f"""output[{i}][{j}]"""					)
                 else:
                     self.analyse_variable(a						,       f"""output[{i}]"""					)
         else:
             self.analyse_variable(a						,       '''output'''					)

         self.save_frame()






     def      SCREAMING_SNAKE_CASE__     (				self	:	List[Any]					):





         """simple docstring"""



         self.model.apply(self._register_forward_hook					)






     def      SCREAMING_SNAKE_CASE__     (				self	:	Tuple						,       a	:	Optional[int]					):





         """simple docstring"""



         module.register_forward_hook(self.forward_hook					)






     def      SCREAMING_SNAKE_CASE__     (				self	:	Optional[Any]						,       a	:	Dict						,       a	:	List[Any]						,       a	:	str					):





         """simple docstring"""



         __lowerCamelCase						=						False

         __lowerCamelCase						=						True if self.batch_number in self.trace_batch_nums else False
         if trace_mode:
             self.reset_saved_frames()

         if self.total_calls == 0:
             self.batch_start_frame()
         self.total_calls += 1

         # count batch numbers - the very first forward hook of the batch will be called when the
         # batch completes - i.e. it gets called very last - we know this batch has finished
         if module == self.model:
             self.batch_number += 1
             __lowerCamelCase						=						True

         self.create_frame(a						,       a						,       a					)

         # if last_frame_of_batch:
         #     self.batch_end_frame()

         if trace_mode:
             self.trace_frames()

         if last_frame_of_batch:
             self.batch_start_frame()

         if self.detected_overflow and not trace_mode:
             self.dump_saved_frames()

             # now we can abort, as it's pointless to continue running
             raise ValueError(
                 '''DebugUnderflowOverflow: inf/nan detected, aborting as there is no point running further. '''
                 '''Please scroll up above this traceback to see the activation values prior to this event.'''					)

         # abort after certain batch if requested to do so
         if self.abort_after_batch_num is not None and self.batch_number > self.abort_after_batch_num:
             raise ValueError(
                 f"""DebugUnderflowOverflow: aborting after {self.batch_number} batches due to"""
                 f""" `abort_after_batch_num={self.abort_after_batch_num}` arg"""					)






def __lowerCAmelCase				(							UpperCamelCase__       ,						UpperCamelCase__       )			->					List[Any]:
    __lowerCamelCase						=						var.abs()
    return f"""{abs_var.min():8.2e} {abs_var.max():8.2e} {ctx}"""






def __lowerCAmelCase				(							UpperCamelCase__       ,						UpperCamelCase__       )			->					Optional[int]:
    __lowerCamelCase						=						False
    if torch.isnan(UpperCamelCase__       ).any().item():
        __lowerCamelCase						=						True
        print(f"""{ctx} has nans"""       )
    if torch.isinf(UpperCamelCase__       ).any().item():
        __lowerCamelCase						=						True
        print(f"""{ctx} has infs"""       )

    # if needed to monitor large elements can enable the following
    if 0:  # and detected:
        __lowerCamelCase						=						var[torch.ge(var.abs()       ,						1_00       )]
        if naaa.numel() > 0:
            print(f"""{ctx}:  n100={naaa.numel()}"""       )
        __lowerCamelCase						=						var[torch.ge(var.abs()       ,						10_00       )]
        if naaaa.numel() > 0:
            print(f"""{ctx}: n1000={naaaa.numel()}"""       )
        __lowerCamelCase						=						var[torch.ge(var.abs()       ,						1_00_00       )]
        if naaaaa.numel() > 0:
            print(f"""{ctx}: n10000={naaaaa.numel()}"""       )

    if 0:
        print(f"""min={var.min():9.2e} max={var.max():9.2e}"""       )

    if 0:
        print(f"""min={var.min():9.2e} max={var.max():9.2e} var={var.var():9.2e} mean={var.mean():9.2e} ({ctx})"""       )

    return detected





class 					a__   (     UpperCAmelCase__				):
     lowerCamelCase						:  Optional[int]							="underflow_overflow"
     lowerCamelCase						:  Optional[Any]							="tpu_metrics_debug"

'''simple docstring'''




__UpperCAmelCase  							=1_0**8






def __lowerCAmelCase				(							UpperCamelCase__       )			->					bool:
    if n % 10 == 0:
        return False
    __lowerCamelCase						=						str(UpperCamelCase__       )
    return s == s[::-1]






def __lowerCAmelCase				(							)			->					int:
    __lowerCamelCase						=						set()
    __lowerCamelCase						=						1
    __lowerCamelCase						=						5
    while sum_squares < LIMIT:
        __lowerCamelCase						=						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
        __lowerCamelCase						=						first_square**2 + (first_square + 1) ** 2

    return sum(UpperCamelCase__       )


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