



"""simple docstring"""







from collections import OrderedDict
from dataclasses import fields
from typing import Any, Tuple

import numpy as np

from .import_utils import is_torch_available



def   a_	(			__a      ):
     if is_torch_available():
          import torch

          if isinstance(lowercase_		,							torch.Tensor      ):
               return True

     return isinstance(lowercase_		,							np.ndarray      )

class       UpperCamelCase  (					__UpperCAmelCase				):





     """simple docstring"""






     def 						A__  (					self :							Tuple ):
          A__				=   fields(self )

          # Safety and consistency checks
          if not len(lowercase_ ):
               raise ValueError(F'''{self.__class__.__name__} has no fields.''' )

          A__				=   getattr(self	,      class_fields[0].name )
          A__				=   all(getattr(self	,      field.name ) is None for field in class_fields[1:] )

          if other_fields_are_none and isinstance(lowercase_	,      lowercase_ ):
               for key, value in first_field.items():
                    A__				=   value
          else:
               for field in class_fields:
                    A__				=   getattr(self	,      field.name )
                    if v is not None:
                         A__				=   v





     def __delitem__(					self :							Optional[int]	,      *_lowerCamelCase :							List[Any]	,      **_lowerCamelCase :							List[Any] ):
          raise Exception(F'''You cannot use ``__delitem__`` on a {self.__class__.__name__} instance.''' )





     def 						A__  (					self :							int	,      *_lowerCamelCase :							Optional[int]	,      **_lowerCamelCase :							str ):
          raise Exception(F'''You cannot use ``setdefault`` on a {self.__class__.__name__} instance.''' )





     def 						A__  (					self :							Tuple	,      *_lowerCamelCase :							Tuple	,      **_lowerCamelCase :							Optional[Any] ):
          raise Exception(F'''You cannot use ``pop`` on a {self.__class__.__name__} instance.''' )





     def 						A__  (					self :							str	,      *_lowerCamelCase :							Optional[int]	,      **_lowerCamelCase :							Tuple ):
          raise Exception(F'''You cannot use ``update`` on a {self.__class__.__name__} instance.''' )





     def __getitem__(					self :							int	,      _lowerCamelCase :							Optional[int] ):

          if isinstance(lowercase_	,      lowercase_ ):
               A__				=   dict(self.items() )
               return inner_dict[k]
          else:
               return self.to_tuple()[k]





     def __setattr__(					self :							List[str]	,      _lowerCamelCase :							Union[str, Any]	,      _lowerCamelCase :							Any ):

          if name in self.keys() and value is not None:
               # Don't call self.__setitem__ to avoid recursion errors
               super().__setitem__(lowercase_	,      lowercase_ )
          super().__setattr__(lowercase_	,      lowercase_ )





     def __setitem__(					self :							List[str]	,      _lowerCamelCase :							Optional[int]	,      _lowerCamelCase :							Any ):
          super().__setitem__(lowercase_	,      lowercase_ )
          # Don't call self.__setattr__ to avoid recursion errors
          super().__setattr__(lowercase_	,      lowercase_ )





     def 						A__  (					self :							str ):
          return tuple(self[k] for k in self.keys() )










"""simple docstring"""







from math import factorial



def   a_	(			__a		,							__a      ):
     return factorial(__a      ) / (factorial(__a      ) * factorial(n - r      ))



def   a_	(			):
     A__				=   0

     for i in range(1		,							101      ):
          for j in range(1		,							i + 1      ):
               if combinations(__a		,							__a      ) > 1e6:
                    total += 1
     return total


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



