




"""simple docstring"""




import collections
import os
import re
from pathlib import Path


lowerCAmelCase				:     List[str]					=				"""src/transformers"""


# Matches is_xxx_available()
lowerCAmelCase				:     str					=				re.compile(r"""is\_([a-z_]*)_available()""")
# Catches a one-line _import_struct = {xxx}
lowerCAmelCase				:     List[str]					=				re.compile(r"""^_import_structure\s+=\s+\{([^\}]+)\}""")
# Catches a line with a key-values pattern: "bla": ["foo", "bar"]
lowerCAmelCase				:     Tuple					=				re.compile(r"""\s+\"\S*\":\s+\[([^\]]*)\]""")
# Catches a line if not is_foo_available
lowerCAmelCase				:     Tuple					=				re.compile(r"""^\s*if\s+not\s+is\_[a-z_]*\_available\(\)""")
# Catches a line _import_struct["bla"].append("foo")
lowerCAmelCase				:     Optional[int]					=				re.compile(r"""^\s*_import_structure\[\"\S*\"\]\.append\(\"(\S*)\"\)""")
# Catches a line _import_struct["bla"].extend(["foo", "bar"]) or _import_struct["bla"] = ["foo", "bar"]
lowerCAmelCase				:     str					=				re.compile(r"""^\s*_import_structure\[\S*\](?:\.extend\(|\s*=\s+)\[([^\]]*)\]""")
# Catches a line with an object between quotes and a comma:     "MyModel",
lowerCAmelCase				:     Tuple					=				re.compile(r"""^\s+\"([^\"]+)\",""")
# Catches a line with objects between brackets only:    ["foo", "bar"],
lowerCAmelCase				:     Any					=				re.compile(r"""^\s+\[([^\]]+)\]""")
# Catches a line with from foo import bar, bla, boo
lowerCAmelCase				:     Any					=				re.compile(r"""\s+from\s+\S*\s+import\s+([^\(\s].*)\n""")
# Catches a line with try:
lowerCAmelCase				:     Optional[int]					=				re.compile(r"""^\s*try:""")
# Catches a line with else:
lowerCAmelCase				:     Optional[Any]					=				re.compile(r"""^\s*else:""")



def        a__					(							snake_case__							)		->   int:
			if _re_test_backend.search(snake_case__							) is None:
						return None
			lowerCamelCase      =   [b[0] for b in _re_backend.findall(snake_case__							)]
			backends.sort()
			return "_and_".join(snake_case__							)



def        a__					(							snake_case__							)		->   int:
			with open(snake_case__			,					"""r"""			,					encoding="""utf-8"""			,					newline="""\n"""							) as f:
						lowerCamelCase      =   f.readlines()

			lowerCamelCase      =   0
			while line_index < len(snake_case__							) and not lines[line_index].startswith("""_import_structure = {"""							):
						line_index += 1

			# If this is a traditional init, just return.
			if line_index >= len(snake_case__							):
						return None

			# First grab the objects without a specific backend in _import_structure
			lowerCamelCase      =   []
			while not lines[line_index].startswith("""if TYPE_CHECKING"""							) and find_backend(lines[line_index]							) is None:
						lowerCamelCase      =   lines[line_index]
						# If we have everything on a single line, let's deal with it.
						if _re_one_line_import_struct.search(snake_case__							):
									lowerCamelCase      =   _re_one_line_import_struct.search(snake_case__							).groups()[0]
									lowerCamelCase      =   re.findall(R"""\[([^\]]+)\]"""			,					snake_case__							)
									for imp in imports:
												objects.extend([obj[1:-1] for obj in imp.split(""", """							)]							)
									line_index += 1
									continue
						lowerCamelCase      =   _re_import_struct_key_value.search(snake_case__							)
						if single_line_import_search is not None:
									lowerCamelCase      =   [obj[1:-1] for obj in single_line_import_search.groups()[0].split(""", """							) if len(snake_case__							) > 0]
									objects.extend(snake_case__							)
						elif line.startswith(""" """ * 8 + """\""""							):
									objects.append(line[9:-3]							)
						line_index += 1

			lowerCamelCase      =   {"""none""": objects}
			# Let's continue with backend-specific objects in _import_structure
			while not lines[line_index].startswith("""if TYPE_CHECKING"""							):
						# If the line is an if not is_backend_available, we grab all objects associated.
						lowerCamelCase      =   find_backend(lines[line_index]							)
						# Check if the backend declaration is inside a try block:
						if _re_try.search(lines[line_index - 1]							) is None:
									lowerCamelCase      =   None

						if backend is not None:
									line_index += 1

									# Scroll until we hit the else block of try-except-else
									while _re_else.search(lines[line_index]							) is None:
												line_index += 1

									line_index += 1

									lowerCamelCase      =   []
									# Until we unindent, add backend objects to the list
									while len(lines[line_index]							) <= 1 or lines[line_index].startswith(""" """ * 4							):
												lowerCamelCase      =   lines[line_index]
												if _re_import_struct_add_one.search(snake_case__							) is not None:
															objects.append(_re_import_struct_add_one.search(snake_case__							).groups()[0]							)
												elif _re_import_struct_add_many.search(snake_case__							) is not None:
															lowerCamelCase      =   _re_import_struct_add_many.search(snake_case__							).groups()[0].split(""", """							)
															lowerCamelCase      =   [obj[1:-1] for obj in imports if len(snake_case__							) > 0]
															objects.extend(snake_case__							)
												elif _re_between_brackets.search(snake_case__							) is not None:
															lowerCamelCase      =   _re_between_brackets.search(snake_case__							).groups()[0].split(""", """							)
															lowerCamelCase      =   [obj[1:-1] for obj in imports if len(snake_case__							) > 0]
															objects.extend(snake_case__							)
												elif _re_quote_object.search(snake_case__							) is not None:
															objects.append(_re_quote_object.search(snake_case__							).groups()[0]							)
												elif line.startswith(""" """ * 8 + """\""""							):
															objects.append(line[9:-3]							)
												elif line.startswith(""" """ * 12 + """\""""							):
															objects.append(line[13:-3]							)
												line_index += 1

									lowerCamelCase      =   objects
						else:
									line_index += 1

    # At this stage we are in the TYPE_CHECKING part, first grab the objects without a specific backend
			lowerCamelCase      =   []
			while (
			    line_index < len(snake_case__							)
			    and find_backend(lines[line_index]							) is None
			    and not lines[line_index].startswith("""else"""							)
			):
						lowerCamelCase      =   lines[line_index]
						lowerCamelCase      =   _re_import.search(snake_case__							)
						if single_line_import_search is not None:
									objects.extend(single_line_import_search.groups()[0].split(""", """							)							)
						elif line.startswith(""" """ * 8							):
									objects.append(line[8:-2]							)
						line_index += 1

			lowerCamelCase      =   {"""none""": objects}
			# Let's continue with backend-specific objects
			while line_index < len(snake_case__							):
						# If the line is an if is_backend_available, we grab all objects associated.
						lowerCamelCase      =   find_backend(lines[line_index]							)
						# Check if the backend declaration is inside a try block:
						if _re_try.search(lines[line_index - 1]							) is None:
									lowerCamelCase      =   None

						if backend is not None:
									line_index += 1

									# Scroll until we hit the else block of try-except-else
									while _re_else.search(lines[line_index]							) is None:
												line_index += 1

									line_index += 1

									lowerCamelCase      =   []
									# Until we unindent, add backend objects to the list
									while len(lines[line_index]							) <= 1 or lines[line_index].startswith(""" """ * 8							):
												lowerCamelCase      =   lines[line_index]
												lowerCamelCase      =   _re_import.search(snake_case__							)
												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

									lowerCamelCase      =   objects
						else:
									line_index += 1

			return import_dict_objects, type_hint_objects



def        a__					(							snake_case__			,					snake_case__							)		->   Any:

			def find_duplicates(snake_case__							):
						return [k for k, v in collections.Counter(snake_case__							).items() if v > 1]

			if list(import_dict_objects.keys()							) != list(type_hint_objects.keys()							):
						return ["Both sides of the init do not have the same backends!"]

			lowerCamelCase      =   []
			for key in import_dict_objects.keys():
						lowerCamelCase      =   find_duplicates(import_dict_objects[key]							)
						if duplicate_imports:
									errors.append(F'Duplicate _import_structure definitions for: {duplicate_imports}'							)
						lowerCamelCase      =   find_duplicates(type_hint_objects[key]							)
						if duplicate_type_hints:
									errors.append(F'Duplicate TYPE_CHECKING objects for: {duplicate_type_hints}'							)

						if sorted(set(import_dict_objects[key]							)							) != sorted(set(type_hint_objects[key]							)							):
									lowerCamelCase      =   """base imports""" if key == """none""" else F'{key} backend'
									errors.append(F'Differences for {name}:'							)
									for a in type_hint_objects[key]:
												if a not in import_dict_objects[key]:
															errors.append(F'  {a} in TYPE_HINT but not in _import_structure.'							)
									for a in import_dict_objects[key]:
												if a not in type_hint_objects[key]:
															errors.append(F'  {a} in _import_structure but not in TYPE_HINT.'							)
			return errors



def        a__					(							)		->   List[str]:
			lowerCamelCase      =   []
			for root, _, files in os.walk(snake_case__							):
						if "__init__.py" in files:
									lowerCamelCase      =   os.path.join(snake_case__			,					"""__init__.py"""							)
									lowerCamelCase      =   parse_init(snake_case__							)
									if objects is not None:
												lowerCamelCase      =   analyze_results(*snake_case__							)
												if len(snake_case__							) > 0:
															lowerCamelCase      =   F'Problem in {fname}, both halves do not define the same objects.\n{errors[0]}'
															failures.append("""\n""".join(snake_case__							)							)
			if len(snake_case__							) > 0:
						raise ValueError("""\n\n""".join(snake_case__							)							)



def        a__					(							)		->   int:
			lowerCamelCase      =   []
			for path, directories, files in os.walk(snake_case__							):
						for folder in directories:
									# Ignore private modules
									if folder.startswith("""_"""							):
												directories.remove(snake_case__							)
												continue
									# Ignore leftovers from branches (empty folders apart from pycache)
									if len(list((Path(snake_case__							) / folder).glob("""*.py"""							)							)							) == 0:
												continue
									lowerCamelCase      =   str((Path(snake_case__							) / folder).relative_to(snake_case__							)							)
									lowerCamelCase      =   short_path.replace(os.path.sep			,					"""."""							)
									submodules.append(snake_case__							)
						for fname in files:
									if fname == "__init__.py":
												continue
									lowerCamelCase      =   str((Path(snake_case__							) / fname).relative_to(snake_case__							)							)
									lowerCamelCase      =   short_path.replace(""".py"""			,					""""""							).replace(os.path.sep			,					"""."""							)
									if len(submodule.split("""."""							)							) == 1:
												submodules.append(snake_case__							)
			return submodules


lowerCAmelCase				:     Dict					=				[
    """convert_pytorch_checkpoint_to_tf2""",
    """modeling_flax_pytorch_utils""",
    """models.esm.openfold_utils""",
]



def        a__					(							)		->   Tuple:
			# This is to make sure the transformers module imported is the one in the repo.
			from transformers.utils import direct_transformers_import

			lowerCamelCase      =   direct_transformers_import(snake_case__							)

			lowerCamelCase      =   set(transformers._import_structure.keys()							)
			# This contains all the base keys of the _import_structure object defined in the init, but if the user is missing
			# some optional dependencies, they may not have all of them. Thus we read the init to read all additions and
			# (potentiall re-) add them.
			with open(os.path.join(snake_case__			,					"""__init__.py"""							)			,					"""r"""							) as f:
						lowerCamelCase      =   f.read()
			import_structure_keys.update(set(re.findall(R"""import_structure\[\"([^\"]*)\"\]"""			,					snake_case__							)							)							)

			lowerCamelCase      =   [
			    module
			    for module in get_transformers_submodules()
			    if module not in IGNORE_SUBMODULES and module not in import_structure_keys
			]

			if len(snake_case__							) > 0:
						lowerCamelCase      =   """\n""".join(F'- {module}' for module in module_not_registered							)
						raise ValueError(
						    """The following submodules are not properly registed in the main init of Transformers:\n"""
						    F'{list_of_modules}\n'
						    """Make sure they appear somewhere in the keys of `_import_structure` with an empty list as value."""							)


if __name__ == "__main__":
					check_all_inits()
					check_submodules()









"""simple docstring"""




def        a__					(							snake_case__ = 10_00							)		->   int:
			lowerCamelCase ,  lowerCamelCase      =   1, 1
			lowerCamelCase      =   2
			while True:
						lowerCamelCase      =   0
						lowerCamelCase      =   fa + fa
						lowerCamelCase ,  lowerCamelCase      =   fa, f
						index += 1
						for _ in str(snake_case__							):
									i += 1
						if i == n:
									break
			return index


if __name__ == "__main__":
					print(solution(int(str(input()).strip())))



