





'''simple docstring'''

def 		UpperCamelCase       (							):

    for a in range(3_00 ):
        for b in range(a + 1		, 4_00 ):
            for c in range(b + 1		, 5_00 ):
                if (a + b + c) == 10_00 and (a**2) + (b**2) == (c**2):
                    return a * b * c

    return -1





def 		UpperCamelCase       (							):

    for a in range(3_00 ):
        for b in range(4_00 ):
            A__       =    10_00 - a - b
            if a < b < c and (a**2) + (b**2) == (c**2):
                return a * b * c

    return -1





def 		UpperCamelCase       (							):
    import timeit

    print(
        timeit.timeit("solution()"		, setup="from __main__ import solution"		, number=10_00 ) )
    print(
        timeit.timeit(
            "solution_fast()"		, setup="from __main__ import solution_fast"		, number=10_00 ) )


if __name__ == "__main__":
 print(f"""{solution() = }""")










'''simple docstring'''

import collections

from .utils import ExplicitEnum, is_torch_available, logging


if is_torch_available():
  import torch


__lowerCAmelCase							:			Optional[int]				=logging.get_logger(__name__)






class      UpperCAmelCase			:
 def __init__(       self   :Optional[int]		, lowercase_   :Any		, lowercase_   :Any=21		, lowercase_   :Any=[]		, lowercase_   :Dict=None							)->							Tuple:
     A__       =    model
     A__       =    trace_batch_nums
     A__       =    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
     A__       =    collections.deque([]		, lowercase_							)
     A__       =    []
     A__       =    0
     A__       =    0
     A__       =    False
     A__       =    "                 "

     self.analyse_model()

     self.register_forward_hook()
 def   UpperCAmelCase_							(       self   :Any		, lowercase_   :Any=None							)->							Optional[Any]:
     if frame is not None:
         self.expand_frame(lowercase_							)
     self.frames.append("\n".join(self.frame							)							)
     A__       =    []  # start a new frame
 def   UpperCAmelCase_							(       self   :Union[str, Any]		, lowercase_   :Dict							)->							List[str]:
     self.frame.append(lowercase_							)
 def   UpperCAmelCase_							(       self   :int							)->							Dict:
     print("\n".join(self.frames							)							)
     A__       =    []
 def   UpperCAmelCase_							(       self   :str							)->							Union[str, Any]:
     A__       =    []
 def   UpperCAmelCase_							(       self   :List[str]							)->							Optional[Any]:
     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"							)
     A__       =    []
 def   UpperCAmelCase_							(       self   :Any							)->							Optional[Any]:
     # extract the fully qualified module names, to be able to report at run time. e.g.:
     # encoder.block.2.layer.0.SelfAttention.o
     #
     # for shared weights only the first shared module name will be registered
     A__       =    {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   UpperCAmelCase_							(       self   :Tuple		, lowercase_   :Dict		, lowercase_   :Any							)->							str:
     if torch.is_tensor(lowercase_							):
         self.expand_frame(get_abs_min_max(lowercase_		, lowercase_							)							)
         if detect_overflow(lowercase_		, lowercase_							):
             A__       =    True
     elif var is None:
         self.expand_frame(F"{'None':>17} {ctx}"							)
     else:
         self.expand_frame(F"{'not a tensor':>17} {ctx}"							)
 def   UpperCAmelCase_							(       self   :Union[str, Any]							)->							str:
     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   UpperCAmelCase_							(       self   :int							)->							int:
     self.expand_frame(F"{self.prefix} *** Finished batch number={self.batch_number-1} ***\n\n"							)
 def   UpperCAmelCase_							(       self   :Optional[int]		, lowercase_   :Dict		, lowercase_   :Dict		, lowercase_   :str							)->							int:
     self.expand_frame(F"{self.prefix} {self.module_names[module]} {module.__class__.__name__}"							)

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

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

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

     self.save_frame()
 def   UpperCAmelCase_							(       self   :Any							)->							int:
     self.model.apply(self._register_forward_hook							)
 def   UpperCAmelCase_							(       self   :Tuple		, lowercase_   :Optional[int]							)->							Tuple:
     module.register_forward_hook(self.forward_hook							)



 def   UpperCAmelCase_							(       self   :List[str]		, lowercase_   :int		, lowercase_   :Optional[Any]		, lowercase_   :Dict							)->							Union[str, Any]:
     # - input is a tuple of packed inputs (could be non-Tensors)
     # - output could be a Tensor or a tuple of Tensors and non-Tensors

     A__       =    False

     A__       =    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
         A__       =    True

     self.create_frame(lowercase_		, lowercase_		, lowercase_							)

     # 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 		UpperCamelCase       (							_lowerCamelCase      :      Dict		, _lowerCamelCase      :      int ):
    A__       =    var.abs()
    return F"{abs_var.min():8.2e} {abs_var.max():8.2e} {ctx}"





def 		UpperCamelCase       (							_lowerCamelCase      :      Tuple		, _lowerCamelCase      :      Optional[int] ):
    A__       =    False
    if torch.isnan(_lowerCamelCase ).any().item():
        A__       =    True
        print(F"{ctx} has nans" )
    if torch.isinf(_lowerCamelCase ).any().item():
        A__       =    True
        print(F"{ctx} has infs" )

    # if needed to monitor large elements can enable the following
    if 0:  # and detected:
        A__       =    var[torch.ge(var.abs()		, 1_00 )]
        if naaa.numel() > 0:
            print(F"{ctx}:  n100={naaa.numel()}" )
        A__       =    var[torch.ge(var.abs()		, 10_00 )]
        if naaaa.numel() > 0:
            print(F"{ctx}: n1000={naaaa.numel()}" )
        A__       =    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      UpperCAmelCase			( UpperCamelCase__       ):
 __lowercase     	=       """underflow_overflow"""
 __lowercase     	=       """tpu_metrics_debug"""



