




import argparse
import os
import re


# All paths are set with the intent you should run this script from the root of the repo with the command
# python utils/check_dummies.py
UpperCAmelCase__						:       Optional[Any]							=    'src/transformers'

# Matches is_xxx_available()
UpperCAmelCase__						:       Optional[int]							=    re.compile(r'is\_([a-z_]*)_available()')
# Matches from xxx import bla
UpperCAmelCase__						:       int							=    re.compile(r'\s+from\s+\S*\s+import\s+([^\(\s].*)\n')
UpperCAmelCase__						:       Dict							=    re.compile(r'^\s+if\s+not\s+\(?is\_[a-z_]*\_available\(\)')


UpperCAmelCase__						:       Dict							=    '\n{0} = None\n'

UpperCAmelCase__						:       Tuple							=    '\nclass {0}(metaclass=DummyObject):\n    _backends = {1}\n\n    def __init__(self, *args, **kwargs):\n        requires_backends(self, {1})\n'


UpperCAmelCase__						:       int							=    '\ndef {0}(*args, **kwargs):\n    requires_backends({0}, {1})\n'


def 		_lowerCamelCase				(					UpperCamelCase							)			->		Optional[int]:





  """simple docstring"""





  if _re_test_backend.search(UpperCamelCase							) is None:
    return None
  _lowercase: Optional[int]						     =    [b[0] for b in _re_backend.findall(UpperCamelCase							)]
  backends.sort()
  return "_and_".join(UpperCamelCase							)


def 		_lowerCamelCase				(					)			->		Optional[Any]:





  """simple docstring"""





  with open(os.path.join(UpperCamelCase					,     '__init__.py'							)					,     'r'					,     encoding='utf-8'					,     newline='\n'							) as f:
    _lowercase: Any						     =    f.readlines()

  # Get to the point we do the actual imports for type checking
  _lowercase: List[Any]						     =    0
  while not lines[line_index].startswith('if TYPE_CHECKING'							):
    line_index += 1

  _lowercase: Tuple						     =    {}
  # Go through the end of the file
  while line_index < len(UpperCamelCase							):
    # If the line is an if is_backend_available, we grab all objects associated.
    _lowercase: Union[str, Any]						     =    find_backend(lines[line_index]							)
    if backend is not None:
      while not lines[line_index].startswith('    else:'							):
        line_index += 1
      line_index += 1

      _lowercase: str						     =    []
      # Until we unindent, add backend objects to the list
      while len(lines[line_index]							) <= 1 or lines[line_index].startswith(' ' * 8							):
        _lowercase: Optional[int]						     =    lines[line_index]
        _lowercase: Optional[int]						     =    _re_single_line_import.search(UpperCamelCase							)
        if single_line_import_search is not None:
          objects.extend(single_line_import_search.groups()[0].split(', '							)							)
        elif line.startswith(' ' * 12							):
          objects.append(line[12:-2]							)
        line_index += 1

      _lowercase: int						     =    objects
    else:
      line_index += 1

  return backend_specific_objects


def 		_lowerCamelCase				(					UpperCamelCase					,     UpperCamelCase							)			->		Dict:





  """simple docstring"""





  if name.isupper():
    return DUMMY_CONSTANT.format(UpperCamelCase							)
  elif name.islower():
    return DUMMY_FUNCTION.format(UpperCamelCase					,     UpperCamelCase							)
  else:
    return DUMMY_CLASS.format(UpperCamelCase					,     UpperCamelCase							)


def 		_lowerCamelCase				(					UpperCamelCase=None							)			->		int:





  """simple docstring"""





  if backend_specific_objects is None:
    _lowercase: Union[str, Any]						     =    read_init()
  # For special correspondence backend to module name as used in the function requires_modulename
  _lowercase: Tuple						     =    {}

  for backend, objects in backend_specific_objects.items():
    _lowercase: Union[str, Any]						     =    '[' + ', '.join(F'"{b}"' for b in backend.split('_and_'							)							) + ']'
    _lowercase: Optional[Any]						     =    '# This file is autogenerated by the command `make fix-copies`, do not edit.\n'
    dummy_file += "from ..utils import DummyObject, requires_backends\n\n"
    dummy_file += "\n".join([create_dummy_object(UpperCamelCase					,     UpperCamelCase							) for o in objects]							)
    _lowercase: List[Any]						     =    dummy_file

  return dummy_files


def 		_lowerCamelCase				(					UpperCamelCase=False							)			->		Tuple:





  """simple docstring"""





  _lowercase: List[Any]						     =    create_dummy_files()
  # For special correspondence backend to shortcut as used in utils/dummy_xxx_objects.py
  _lowercase: int						     =    {'torch': 'pt'}

  # Locate actual dummy modules and read their content.
  _lowercase: Optional[int]						     =    os.path.join(UpperCamelCase					,     'utils'							)
  _lowercase: Tuple						     =    {
      backend: os.path.join(UpperCamelCase					,     F'dummy_{short_names.get(UpperCamelCase					,     UpperCamelCase							)}_objects.py'							)
      for backend in dummy_files.keys()
  }

  _lowercase: int						     =    {}
  for backend, file_path in dummy_file_paths.items():
    if os.path.isfile(UpperCamelCase							):
      with open(UpperCamelCase					,     'r'					,     encoding='utf-8'					,     newline='\n'							) as f:
        _lowercase: List[str]						     =    f.read()
    else:
      _lowercase: List[str]						     =    ''

  for backend in dummy_files.keys():
    if dummy_files[backend] != actual_dummies[backend]:
      if overwrite:
        print(
            F'Updating transformers.utils.dummy_{short_names.get(UpperCamelCase					,     UpperCamelCase							)}_objects.py as the main '
            '__init__ has new objects.'							)
        with open(dummy_file_paths[backend]					,     'w'					,     encoding='utf-8'					,     newline='\n'							) as f:
          f.write(dummy_files[backend]							)
      else:
        raise ValueError(
            'The main __init__ has objects that are not present in '
            F'transformers.utils.dummy_{short_names.get(UpperCamelCase					,     UpperCamelCase							)}_objects.py. Run `make fix-copies` '
            'to fix this.'							)


if __name__ == "__main__":
   UpperCAmelCase__						:       Tuple							=    argparse.ArgumentParser()
   parser.add_argument('--fix_and_overwrite', action='store_true', help='Whether to fix inconsistencies.')
   UpperCAmelCase__						:       str							=    parser.parse_args()

   check_dummies(args.fix_and_overwrite)






import math


def 		_lowerCamelCase				(					UpperCamelCase							)			->		int:





  """simple docstring"""





  return sum(int(UpperCamelCase							) for digit in str(UpperCamelCase							)							)


def 		_lowerCamelCase				(					UpperCamelCase = 30							)			->		int:





  """simple docstring"""





  _lowercase: int						     =    []
  for digit in range(2					,     100							):
    for power in range(2					,     100							):
      _lowercase: int						     =    int(math.pow(UpperCamelCase					,     UpperCamelCase							)							)
      if digit == digit_sum(UpperCamelCase							):
        digit_to_powers.append(UpperCamelCase							)

  digit_to_powers.sort()
  return digit_to_powers[n - 1]


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