


import os
import unittest
from tempfile import TemporaryDirectory

import torch
import torch.nn as nn

from accelerate.utils import (
    OffloadedWeightsLoader,
    extract_submodules_state_dict,
    load_offloaded_weight,
    offload_state_dict,
    offload_weight,
)

class     A__   (       nn.Module      ):







    """simple docstring"""

    def __init__(			self       ):
         super().__init__()
         snake_case											=							nn.Linear(3     ,   4       )
         snake_case											=							nn.BatchNormad(4       )
         snake_case											=							nn.Linear(4     ,   5       )




    def 						a_     (			self     ,   __snake_case       ):
         return self.lineara(self.batchnorm(self.lineara(_SCREAMING_SNAKE_CASE       )       )       )






class     A__   (       unittest.TestCase      ):







    """simple docstring"""

    def 						a_     (			self       ):
         snake_case											=							ModelForTest()
         with TemporaryDirectory() as tmp_dir:
              offload_state_dict(_SCREAMING_SNAKE_CASE     ,   model.state_dict()       )
              snake_case											=							os.path.join(_SCREAMING_SNAKE_CASE     ,   '''index.json'''       )
              self.assertTrue(os.path.isfile(_SCREAMING_SNAKE_CASE       )       )
              # TODO: add tests on what is inside the index

              for key in ["linear1.weight", "linear1.bias", "linear2.weight", "linear2.bias"]:
                   snake_case											=							os.path.join(_SCREAMING_SNAKE_CASE     ,   F'''{key}.dat'''       )
                   self.assertTrue(os.path.isfile(_SCREAMING_SNAKE_CASE       )       )
                   # TODO: add tests on the fact weights are properly loaded
    def 						a_     (			self       ):
         snake_case											=							[torch.floataa, torch.floataa, torch.bfloataa]

         for dtype in dtypes:
              snake_case											=							torch.randn(2     ,   3     ,   dtype=_SCREAMING_SNAKE_CASE       )
              with TemporaryDirectory() as tmp_dir:
                   snake_case											=							offload_weight(_SCREAMING_SNAKE_CASE     ,   '''weight'''     ,   _SCREAMING_SNAKE_CASE     ,   {}       )
                   snake_case											=							os.path.join(_SCREAMING_SNAKE_CASE     ,   '''weight.dat'''       )
                   self.assertTrue(os.path.isfile(_SCREAMING_SNAKE_CASE       )       )
                   self.assertDictEqual(_SCREAMING_SNAKE_CASE     ,   {'''weight''': {'''shape''': [2, 3], '''dtype''': str(_SCREAMING_SNAKE_CASE       ).split('''.'''       )[1]}}       )

                   snake_case											=							load_offloaded_weight(_SCREAMING_SNAKE_CASE     ,   index['''weight''']       )
                   self.assertTrue(torch.equal(_SCREAMING_SNAKE_CASE     ,   _SCREAMING_SNAKE_CASE       )       )
    def 						a_     (			self       ):
         snake_case											=							ModelForTest()
         snake_case											=							model.state_dict()
         snake_case											=							{k: v for k, v in state_dict.items() if '''linear2''' not in k}
         snake_case											=							{k: v for k, v in state_dict.items() if '''linear2''' in k}

         with TemporaryDirectory() as tmp_dir:
              offload_state_dict(_SCREAMING_SNAKE_CASE     ,   _SCREAMING_SNAKE_CASE       )
              snake_case											=							OffloadedWeightsLoader(state_dict=_SCREAMING_SNAKE_CASE     ,   save_folder=_SCREAMING_SNAKE_CASE       )

              # Every key is there with the right value
              self.assertEqual(sorted(_SCREAMING_SNAKE_CASE       )     ,   sorted(state_dict.keys()       )       )
              for key, param in state_dict.items():
                   self.assertTrue(torch.allclose(_SCREAMING_SNAKE_CASE     ,   weight_map[key]       )       )

         snake_case											=							{k: v for k, v in state_dict.items() if '''weight''' in k}
         snake_case											=							{k: v for k, v in state_dict.items() if '''weight''' not in k}

         with TemporaryDirectory() as tmp_dir:
              offload_state_dict(_SCREAMING_SNAKE_CASE     ,   _SCREAMING_SNAKE_CASE       )
              snake_case											=							OffloadedWeightsLoader(state_dict=_SCREAMING_SNAKE_CASE     ,   save_folder=_SCREAMING_SNAKE_CASE       )

              # Every key is there with the right value
              self.assertEqual(sorted(_SCREAMING_SNAKE_CASE       )     ,   sorted(state_dict.keys()       )       )
              for key, param in state_dict.items():
                   self.assertTrue(torch.allclose(_SCREAMING_SNAKE_CASE     ,   weight_map[key]       )       )

         with TemporaryDirectory() as tmp_dir:
              offload_state_dict(_SCREAMING_SNAKE_CASE     ,   _SCREAMING_SNAKE_CASE       )
              # Duplicates are removed
              snake_case											=							OffloadedWeightsLoader(state_dict=_SCREAMING_SNAKE_CASE     ,   save_folder=_SCREAMING_SNAKE_CASE       )

              # Every key is there with the right value
              self.assertEqual(sorted(_SCREAMING_SNAKE_CASE       )     ,   sorted(state_dict.keys()       )       )
              for key, param in state_dict.items():
                   self.assertTrue(torch.allclose(_SCREAMING_SNAKE_CASE     ,   weight_map[key]       )       )




    def 						a_     (			self       ):
         snake_case											=							{'''a.1''': 0, '''a.10''': 1, '''a.2''': 2}
         snake_case											=							extract_submodules_state_dict(_SCREAMING_SNAKE_CASE     ,   ['''a.1''', '''a.2''']       )
         self.assertDictEqual(_SCREAMING_SNAKE_CASE     ,   {'''a.1''': 0, '''a.2''': 2}       )

         snake_case											=							{'''a.1.a''': 0, '''a.10.a''': 1, '''a.2.a''': 2}
         snake_case											=							extract_submodules_state_dict(_SCREAMING_SNAKE_CASE     ,   ['''a.1''', '''a.2''']       )
         self.assertDictEqual(_SCREAMING_SNAKE_CASE     ,   {'''a.1.a''': 0, '''a.2.a''': 2}       )










from functools import reduce

__a							     =					(
    '73167176531330624919225119674426574742355349194934'
    '96983520312774506326239578318016984801869478851843'
    '85861560789112949495459501737958331952853208805511'
    '12540698747158523863050715693290963295227443043557'
    '66896648950445244523161731856403098711121722383113'
    '62229893423380308135336276614282806444486645238749'
    '30358907296290491560440772390713810515859307960866'
    '70172427121883998797908792274921901699720888093776'
    '65727333001053367881220235421809751254540594752243'
    '52584907711670556013604839586446706324415722155397'
    '53697817977846174064955149290862569321978468622482'
    '83972241375657056057490261407972968652414535100474'
    '82166370484403199890008895243450658541227588666881'
    '16427171479924442928230863465674813919123162824586'
    '17866458359124566529476545682848912883142607690042'
    '24219022671055626321111109370544217506941658960408'
    '07198403850962455444362981230987879927244284909188'
    '84580156166097919133875499200524063689912560717606'
    '05886116467109405077541002256983155200055935729725'
    '71636269561882670428252483600823257530420752963450'
)







def lowerCamelCase__  (     _lowercase = N ):

     '''simple docstring'''


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


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