

import os
import sys
import tempfile

import torch

from .state import AcceleratorState
from .utils import PrecisionType, PrepareForLaunch, is_mps_available, patch_environment
def     UpperCAmelCase_       (						_A				,		_A=()				,		_A=None				,		_A="no"				,		_A="29500"    ):





     '''simple docstring'''




     SCREAMING_SNAKE_CASE__   =   False
     SCREAMING_SNAKE_CASE__   =   False
     if any(key.startswith('''KAGGLE'''    ) for key in os.environ.keys()    ):
          SCREAMING_SNAKE_CASE__   =   True
     elif "IPython" in sys.modules:
          SCREAMING_SNAKE_CASE__   =   '''google.colab''' in str(sys.modules['''IPython'''].get_ipython()    )

     try:
          SCREAMING_SNAKE_CASE__   =   PrecisionType(mixed_precision.lower()    )
     except ValueError:
          raise ValueError(
              F'''Unknown mixed_precision mode: {args.mixed_precision.lower()}. Choose between {PrecisionType.list()}.'''    )

     if (in_colab or in_kaggle) and (os.environ.get('''TPU_NAME'''				,		_A    ) is not None):
          # TPU launch
          import torch_xla.distributed.xla_multiprocessing as xmp

          if len(AcceleratorState._shared_state    ) > 0:
               raise ValueError(
                   '''To train on TPU in Colab or Kaggle Kernel, the `Accelerator` should only be initialized inside '''
                   '''your training function. Restart your notebook and make sure no cells initializes an '''
                   '''`Accelerator`.'''    )
          if num_processes is None:
               SCREAMING_SNAKE_CASE__   =   8

          SCREAMING_SNAKE_CASE__   =   PrepareForLaunch(_A				,		distributed_type='''TPU'''    )
          print(F'''Launching a training on {num_processes} TPU cores.'''    )
          xmp.spawn(_A				,		args=_A				,		nprocs=_A				,		start_method='''fork'''    )
     elif in_colab:
          # No need for a distributed launch otherwise as it's either CPU or one GPU.
          if torch.cuda.is_available():
               print('''Launching training on one GPU.'''    )
          else:
               print('''Launching training on one CPU.'''    )
          function(*_A    )
     else:
          if num_processes is None:
               raise ValueError(
                   '''You have to specify the number of GPUs you would like to use, add `num_processes=...` to your call.'''    )

          if num_processes > 1:
               # Multi-GPU launch
               from torch.multiprocessing import start_processes
               from torch.multiprocessing.spawn import ProcessRaisedException

               if len(AcceleratorState._shared_state    ) > 0:
                    raise ValueError(
                        '''To launch a multi-GPU training from your notebook, the `Accelerator` should only be initialized '''
                        '''inside your training function. Restart your notebook and make sure no cells initializes an '''
                        '''`Accelerator`.'''    )

               if torch.cuda.is_initialized():
                    raise ValueError(
                        '''To launch a multi-GPU training from your notebook, you need to avoid running any instruction '''
                        '''using `torch.cuda` in any cell. Restart your notebook and make sure no cells use any CUDA '''
                        '''function.'''    )

               # torch.distributed will expect a few environment variable to be here. We set the ones common to each
               # process here (the other ones will be set be the launcher).
               with patch_environment(
                   world_size=_A				,		master_addr='''127.0.01'''				,		master_port=_A				,		mixed_precision=_A    ):
                    SCREAMING_SNAKE_CASE__   =   PrepareForLaunch(_A				,		distributed_type='''MULTI_GPU'''    )
                    print(F'''Launching training on {num_processes} GPUs.'''    )
                    try:
                         start_processes(_A				,		args=_A				,		nprocs=_A				,		start_method='''fork'''    )
                    except ProcessRaisedException as e:
                         if "Cannot re-initialize CUDA in forked subprocess" in e.args[0]:
                              raise RuntimeError(
                                  '''CUDA has been initialized before the `notebook_launcher` could create a forked subprocess. '''
                                  '''This likely stems from an outside import causing issues once the `notebook_launcher()` is called. '''
                                  '''Please review your imports and test them when running the `notebook_launcher()` to identify '''
                                  '''which one is problematic.'''    ) from e

          else:
               # No need for a distributed launch otherwise as it's either CPU, GPU or MPS.
               if is_mps_available():
                    SCREAMING_SNAKE_CASE__   =   '''1'''
                    print('''Launching training on MPS.'''    )
               elif torch.cuda.is_available():
                    print('''Launching training on one GPU.'''    )
               else:
                    print('''Launching training on CPU.'''    )
               function(*_A    )







def     UpperCAmelCase_       (						_A				,		_A=()				,		_A=2    ):





     '''simple docstring'''




     from torch.multiprocessing import start_processes

     with tempfile.NamedTemporaryFile() as tmp_file:
          # torch.distributed will expect a few environment variable to be here. We set the ones common to each
          # process here (the other ones will be set be the launcher).
          with patch_environment(
              world_size=_A				,		master_addr='''127.0.01'''				,		master_port='''29500'''				,		accelerate_mixed_precision='''no'''				,		accelerate_debug_rdv_file=tmp_file.name				,		accelerate_use_cpu='''yes'''				,		):
               SCREAMING_SNAKE_CASE__   =   PrepareForLaunch(_A				,		debug=_A    )
               start_processes(_A				,		args=_A				,		nprocs=_A				,		start_method='''fork'''    )





from functools import reduce

_SCREAMING_SNAKE_CASE					:  Any             =      (
    '''73167176531330624919225119674426574742355349194934'''
    '''96983520312774506326239578318016984801869478851843'''
    '''85861560789112949495459501737958331952853208805511'''
    '''12540698747158523863050715693290963295227443043557'''
    '''66896648950445244523161731856403098711121722383113'''
    '''62229893423380308135336276614282806444486645238749'''
    '''30358907296290491560440772390713810515859307960866'''
    '''70172427121883998797908792274921901699720888093776'''
    '''65727333001053367881220235421809751254540594752243'''
    '''52584907711670556013604839586446706324415722155397'''
    '''53697817977846174064955149290862569321978468622482'''
    '''83972241375657056057490261407972968652414535100474'''
    '''82166370484403199890008895243450658541227588666881'''
    '''16427171479924442928230863465674813919123162824586'''
    '''17866458359124566529476545682848912883142607690042'''
    '''24219022671055626321111109370544217506941658960408'''
    '''07198403850962455444362981230987879927244284909188'''
    '''84580156166097919133875499200524063689912560717606'''
    '''05886116467109405077541002256983155200055935729725'''
    '''71636269561882670428252483600823257530420752963450'''
)
def     UpperCAmelCase_       (						_A = N    ):





     '''simple docstring'''




     return max(
         # mypy cannot properly interpret reduce
         int(reduce(lambda _A				,		_A    : str(int(_A    ) * int(_A    )    )				,		n[i : i + 13]    )    )
         for i in range(len(_A    ) - 12    )    )


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


