


'''simple docstring'''


import inspect
from typing import Callable, List, Optional, Set, Tuple, Union

import torch
from packaging import version
from safetensors.torch import storage_ptr, storage_size
from torch import nn

from .utils import logging


_UpperCamelCase          =     [nn.LayerNorm]

_UpperCamelCase          =     logging.get_logger(__name__)

_UpperCamelCase          =     version.parse(version.parse(torch.__version__).base_version)

_UpperCamelCase          =     parsed_torch_version_base >= version.parse("""2.0""")
_UpperCamelCase          =     parsed_torch_version_base >= version.parse("""1.12""")
_UpperCamelCase          =     parsed_torch_version_base >= version.parse("""1.11""")
_UpperCamelCase          =     parsed_torch_version_base < version.parse("""1.11""")


def 		_lowercase   (SCREAMING_SNAKE_CASE					,				SCREAMING_SNAKE_CASE					,				SCREAMING_SNAKE_CASE					,				SCREAMING_SNAKE_CASE					,				self       ):




     '''simple docstring'''





     from torch import _softmax_backward_data

     if is_torch_less_than_1_11:
          return _softmax_backward_data(SCREAMING_SNAKE_CASE					,				SCREAMING_SNAKE_CASE					,				parent.dim					,				self       )
     else:
          return _softmax_backward_data(SCREAMING_SNAKE_CASE					,				SCREAMING_SNAKE_CASE					,				parent.dim					,				self.dtype       )


def 		_lowercase   (SCREAMING_SNAKE_CASE					,				SCREAMING_SNAKE_CASE					,				SCREAMING_SNAKE_CASE = 0       ):




     '''simple docstring'''





     __A  :					int						     =       index.to(layer.weight.device       )
     __A  :					List[Any]						     =       layer.weight.index_select(SCREAMING_SNAKE_CASE					,				SCREAMING_SNAKE_CASE       ).clone().detach()
     if layer.bias is not None:
          if dim == 1:
               __A  :					Union[str, Any]						     =       layer.bias.clone().detach()
          else:
               __A  :					str						     =       layer.bias[index].clone().detach()
     __A  :					str						     =       list(layer.weight.size()       )
     __A  :					Optional[int]						     =       len(SCREAMING_SNAKE_CASE       )
     __A  :					Optional[int]						     =       nn.Linear(new_size[1]					,				new_size[0]					,				bias=layer.bias is not None       ).to(layer.weight.device       )
     __A  :					Dict						     =       False
     new_layer.weight.copy_(W.contiguous()       )
     __A  :					List[Any]						     =       True
     if layer.bias is not None:
          __A  :					Dict						     =       False
          new_layer.bias.copy_(b.contiguous()       )
          __A  :					int						     =       True
     return new_layer







class        __magic_name__  (					nn.Module   ):

     """simple docstring"""






     def __init__(      self ,    lowerCamelCase ,    lowerCamelCase		):


          '''simple docstring'''





          super().__init__()
          __A  :					Optional[Any]						     =       nf
          __A  :					Tuple						     =       nn.Parameter(torch.empty(lowerCamelCase ,    lowerCamelCase		)		)
          __A  :					List[str]						     =       nn.Parameter(torch.zeros(lowerCamelCase		)		)
          nn.init.normal_(self.weight ,    std=0.02		)


     def lowerCAmelCase__     (      self ,    lowerCamelCase		):


          '''simple docstring'''





          __A  :					Optional[int]						     =       x.size()[:-1] + (self.nf,)
          __A  :					Any						     =       torch.addmm(self.bias ,    x.view(-1 ,    x.size(-1		)		) ,    self.weight		)
          __A  :					Optional[int]						     =       x.view(lowerCamelCase		)
          return x


def 		_lowercase   (SCREAMING_SNAKE_CASE					,				SCREAMING_SNAKE_CASE					,				SCREAMING_SNAKE_CASE = 1       ):




     '''simple docstring'''





     __A  :					Any						     =       index.to(layer.weight.device       )
     __A  :					Optional[Any]						     =       layer.weight.index_select(SCREAMING_SNAKE_CASE					,				SCREAMING_SNAKE_CASE       ).clone().detach()
     if dim == 0:
          __A  :					Optional[int]						     =       layer.bias.clone().detach()
     else:
          __A  :					Union[str, Any]						     =       layer.bias[index].clone().detach()
     __A  :					Union[str, Any]						     =       list(layer.weight.size()       )
     __A  :					Optional[int]						     =       len(SCREAMING_SNAKE_CASE       )
     __A  :					List[str]						     =       ConvaD(new_size[1]					,				new_size[0]       ).to(layer.weight.device       )
     __A  :					List[str]						     =       False
     new_layer.weight.copy_(W.contiguous()       )
     __A  :					int						     =       True
     __A  :					List[Any]						     =       False
     new_layer.bias.copy_(b.contiguous()       )
     __A  :					List[Any]						     =       True
     return new_layer


def 		_lowercase   (SCREAMING_SNAKE_CASE					,				SCREAMING_SNAKE_CASE					,				SCREAMING_SNAKE_CASE = None       ):




     '''simple docstring'''





     if isinstance(SCREAMING_SNAKE_CASE					,				nn.Linear       ):
          return prune_linear_layer(SCREAMING_SNAKE_CASE					,				SCREAMING_SNAKE_CASE					,				dim=0 if dim is None else dim       )
     elif isinstance(SCREAMING_SNAKE_CASE					,				SCREAMING_SNAKE_CASE       ):
          return prune_convad_layer(SCREAMING_SNAKE_CASE					,				SCREAMING_SNAKE_CASE					,				dim=1 if dim is None else dim       )
     else:
          raise ValueError(f"Can't prune layer of class {layer.__class__}"       )


def 		_lowercase   (SCREAMING_SNAKE_CASE					,				SCREAMING_SNAKE_CASE					,				SCREAMING_SNAKE_CASE					,				*SCREAMING_SNAKE_CASE       ):




     '''simple docstring'''





     assert len(SCREAMING_SNAKE_CASE       ) > 0, f"{input_tensors} has to be a tuple/list of tensors"

     # inspect.signature exist since python 3.5 and is a python method -> no problem with backward compatibility
     __A  :					List[Any]						     =       len(inspect.signature(SCREAMING_SNAKE_CASE       ).parameters       )
     if num_args_in_forward_chunk_fn != len(SCREAMING_SNAKE_CASE       ):
          raise ValueError(
              f"forward_chunk_fn expects {num_args_in_forward_chunk_fn} arguments, but only {len(SCREAMING_SNAKE_CASE       )} input "
              "tensors are given"       )

     if chunk_size > 0:
          __A  :					Tuple						     =       input_tensors[0].shape[chunk_dim]
          for input_tensor in input_tensors:
               if input_tensor.shape[chunk_dim] != tensor_shape:
                    raise ValueError(
                        f"All input tenors have to be of the same shape: {tensor_shape}, "
                        f"found shape {input_tensor.shape[chunk_dim]}"       )

          if input_tensors[0].shape[chunk_dim] % chunk_size != 0:
               raise ValueError(
                   f"The dimension to be chunked {input_tensors[0].shape[chunk_dim]} has to be a multiple of the chunk "
                   f"size {chunk_size}"       )

          __A  :					List[str]						     =       input_tensors[0].shape[chunk_dim] // chunk_size

          # chunk input tensor into tuples
          __A  :					Tuple						     =       tuple(input_tensor.chunk(SCREAMING_SNAKE_CASE					,				dim=SCREAMING_SNAKE_CASE       ) for input_tensor in input_tensors       )
          # apply forward fn to every tuple
          __A  :					Dict						     =       tuple(forward_fn(*SCREAMING_SNAKE_CASE       ) for input_tensors_chunk in zip(*SCREAMING_SNAKE_CASE       )       )
          # concatenate output at same dimension
          return torch.cat(SCREAMING_SNAKE_CASE					,				dim=SCREAMING_SNAKE_CASE       )

     return forward_fn(*SCREAMING_SNAKE_CASE       )


def 		_lowercase   (SCREAMING_SNAKE_CASE					,				SCREAMING_SNAKE_CASE					,				SCREAMING_SNAKE_CASE					,				SCREAMING_SNAKE_CASE       ):




     '''simple docstring'''





     __A  :					int						     =       torch.ones(SCREAMING_SNAKE_CASE					,				SCREAMING_SNAKE_CASE       )
     __A  :					str						     =       set(SCREAMING_SNAKE_CASE       ) - already_pruned_heads  # Convert to set and remove already pruned heads
     for head in heads:
          # Compute how many pruned heads are before the head and move the index accordingly
          __A  :					Optional[Any]						     =       head - sum(1 if h < head else 0 for h in already_pruned_heads       )
          __A  :					List[Any]						     =       0
     __A  :					Optional[Any]						     =       mask.view(-1       ).contiguous().eq(1       )
     __A  :					torch.LongTensor						     =       torch.arange(len(SCREAMING_SNAKE_CASE       )       )[mask].long()
     return heads, index


def 		_lowercase   (*SCREAMING_SNAKE_CASE					,				SCREAMING_SNAKE_CASE = None       ):




     '''simple docstring'''





     return torch.meshgrid(*SCREAMING_SNAKE_CASE					,				indexing=SCREAMING_SNAKE_CASE       )






def 		_lowercase   (SCREAMING_SNAKE_CASE       ):




     '''simple docstring'''





     return tensor.device, storage_ptr(SCREAMING_SNAKE_CASE       ), storage_size(SCREAMING_SNAKE_CASE       )





'''simple docstring'''


from collections import defaultdict


def 		_lowercase   (SCREAMING_SNAKE_CASE = 5       ):




     '''simple docstring'''





     __A  :					int						     =       defaultdict(SCREAMING_SNAKE_CASE       )
     __A  :					Optional[Any]						     =       0

     while True:
          __A  :					List[str]						     =       get_digits(SCREAMING_SNAKE_CASE       )
          freqs[digits].append(SCREAMING_SNAKE_CASE       )

          if len(freqs[digits]       ) == max_base:
               __A  :					Optional[int]						     =       freqs[digits][0] ** 3
               return base

          num += 1


def 		_lowercase   (SCREAMING_SNAKE_CASE       ):




     '''simple docstring'''





     return "".join(sorted(str(num**3       )       )       )


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

