import collections
import os
import re
from pathlib import Path


__UpperCamelCase		:       str									=     'src/transformers'


# Matches is_xxx_available()
__UpperCamelCase		:       int									=     re.compile(R'is\_([a-z_]*)_available()')
# Catches a one-line _import_struct = {xxx}
__UpperCamelCase		:       int									=     re.compile(R'^_import_structure\s+=\s+\{([^\}]+)\}')
# Catches a line with a key-values pattern: "bla": ["foo", "bar"]
__UpperCamelCase		:       List[str]									=     re.compile(R'\s+"\S*":\s+\[([^\]]*)\]')
# Catches a line if not is_foo_available
__UpperCamelCase		:       List[Any]									=     re.compile(R'^\s*if\s+not\s+is\_[a-z_]*\_available\(\)')
# Catches a line _import_struct["bla"].append("foo")
__UpperCamelCase		:       List[Any]									=     re.compile(R'^\s*_import_structure\["\S*"\]\.append\("(\S*)"\)')
# Catches a line _import_struct["bla"].extend(["foo", "bar"]) or _import_struct["bla"] = ["foo", "bar"]
__UpperCamelCase		:       Tuple									=     re.compile(R'^\s*_import_structure\[\S*\](?:\.extend\(|\s*=\s+)\[([^\]]*)\]')
# Catches a line with an object between quotes and a comma:     "MyModel",
__UpperCamelCase		:       Tuple									=     re.compile(R'^\s+"([^"]+)",')
# Catches a line with objects between brackets only:    ["foo", "bar"],
__UpperCamelCase		:       List[str]									=     re.compile(R'^\s+\[([^\]]+)\]')
# Catches a line with from foo import bar, bla, boo
__UpperCamelCase		:       str									=     re.compile(R'\s+from\s+\S*\s+import\s+([^\(\s].*)\n')
# Catches a line with try:
__UpperCamelCase		:       Union[str, Any]									=     re.compile(R'^\s*try:')
# Catches a line with else:
__UpperCamelCase		:       Dict									=     re.compile(R'^\s*else:')
def       A	(    _lowercase						):
						if _re_test_backend.search(SCREAMING_SNAKE_CASE__						) is None:
												return None
						SCREAMING_SNAKE_CASE							:    Union[str, Any]							=							[b[0] for b in _re_backend.findall(SCREAMING_SNAKE_CASE__						)]
						backends.sort()
						return "_and_".join(SCREAMING_SNAKE_CASE__						)
def       A	(    _lowercase						):
						with open(SCREAMING_SNAKE_CASE__		,  '''r'''		,  encoding='''utf-8'''		,  newline='''\n'''						) as f:
												SCREAMING_SNAKE_CASE							:    List[Any]							=							f.readlines()

						SCREAMING_SNAKE_CASE							:    Dict							=							0
						while line_index < len(SCREAMING_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(SCREAMING_SNAKE_CASE__						):
												return None

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

						SCREAMING_SNAKE_CASE							:    str							=							{'''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.
												SCREAMING_SNAKE_CASE							:    Optional[Any]							=							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:
																		SCREAMING_SNAKE_CASE							:    Optional[Any]							=							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

																		SCREAMING_SNAKE_CASE							:    Dict							=							[]
																		# Until we unindent, add backend objects to the list
																		while len(lines[line_index]						) <= 1 or lines[line_index].startswith(''' ''' * 4						):
																								SCREAMING_SNAKE_CASE							:    Optional[Any]							=							lines[line_index]
																								if _re_import_struct_add_one.search(SCREAMING_SNAKE_CASE__						) is not None:
																														objects.append(_re_import_struct_add_one.search(SCREAMING_SNAKE_CASE__						).groups()[0]						)
																								elif _re_import_struct_add_many.search(SCREAMING_SNAKE_CASE__						) is not None:
																														SCREAMING_SNAKE_CASE							:    int							=							_re_import_struct_add_many.search(SCREAMING_SNAKE_CASE__						).groups()[0].split(''', '''						)
																														SCREAMING_SNAKE_CASE							:    Tuple							=							[obj[1:-1] for obj in imports if len(SCREAMING_SNAKE_CASE__						) > 0]
																														objects.extend(SCREAMING_SNAKE_CASE__						)
																								elif _re_between_brackets.search(SCREAMING_SNAKE_CASE__						) is not None:
																														SCREAMING_SNAKE_CASE							:    List[Any]							=							_re_between_brackets.search(SCREAMING_SNAKE_CASE__						).groups()[0].split(''', '''						)
																														SCREAMING_SNAKE_CASE							:    Optional[int]							=							[obj[1:-1] for obj in imports if len(SCREAMING_SNAKE_CASE__						) > 0]
																														objects.extend(SCREAMING_SNAKE_CASE__						)
																								elif _re_quote_object.search(SCREAMING_SNAKE_CASE__						) is not None:
																														objects.append(_re_quote_object.search(SCREAMING_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

																		SCREAMING_SNAKE_CASE							:    Union[str, Any]							=							objects
												else:
																		line_index += 1

    # At this stage we are in the TYPE_CHECKING part, first grab the objects without a specific backend
						SCREAMING_SNAKE_CASE							:    Dict							=							[]
						while (
						    line_index < len(SCREAMING_SNAKE_CASE__						)
						    and find_backend(lines[line_index]						) is None
						    and not lines[line_index].startswith('''else'''						)
						):
												SCREAMING_SNAKE_CASE							:    Optional[Any]							=							lines[line_index]
												SCREAMING_SNAKE_CASE							:    Union[str, Any]							=							_re_import.search(SCREAMING_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

						SCREAMING_SNAKE_CASE							:    List[str]							=							{'''none''': objects}
						# Let's continue with backend-specific objects
						while line_index < len(SCREAMING_SNAKE_CASE__						):
												# If the line is an if is_backend_available, we grab all objects associated.
												SCREAMING_SNAKE_CASE							:    Union[str, Any]							=							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:
																		SCREAMING_SNAKE_CASE							:    Dict							=							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

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

																		SCREAMING_SNAKE_CASE							:    str							=							objects
												else:
																		line_index += 1

						return import_dict_objects, type_hint_objects
def       A	(    _lowercase		,  _lowercase						):

						def find_duplicates(_lowercase						):
												return [k for k, v in collections.Counter(SCREAMING_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!"]

						SCREAMING_SNAKE_CASE							:    Any							=							[]
						for key in import_dict_objects.keys():
												SCREAMING_SNAKE_CASE							:    List[str]							=							find_duplicates(import_dict_objects[key]						)
												if duplicate_imports:
																		errors.append(f"""Duplicate _import_structure definitions for: {duplicate_imports}"""						)
												SCREAMING_SNAKE_CASE							:    Tuple							=							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]						)						):
																		SCREAMING_SNAKE_CASE							:    Optional[int]							=							'''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	(    ):
						SCREAMING_SNAKE_CASE							:    List[str]							=							[]
						for root, _, files in os.walk(SCREAMING_SNAKE_CASE__						):
												if "__init__.py" in files:
																		SCREAMING_SNAKE_CASE							:    Optional[int]							=							os.path.join(SCREAMING_SNAKE_CASE__		,  '''__init__.py'''						)
																		SCREAMING_SNAKE_CASE							:    Tuple							=							parse_init(SCREAMING_SNAKE_CASE__						)
																		if objects is not None:
																								SCREAMING_SNAKE_CASE							:    Optional[Any]							=							analyze_results(*SCREAMING_SNAKE_CASE__						)
																								if len(SCREAMING_SNAKE_CASE__						) > 0:
																														SCREAMING_SNAKE_CASE							:    List[str]							=							f"""Problem in {fname}, both halves do not define the same objects.\n{errors[0]}"""
																														failures.append('''\n'''.join(SCREAMING_SNAKE_CASE__						)						)
						if len(SCREAMING_SNAKE_CASE__						) > 0:
												raise ValueError('''\n\n'''.join(SCREAMING_SNAKE_CASE__						)						)
def       A	(    ):
						SCREAMING_SNAKE_CASE							:    str							=							[]
						for path, directories, files in os.walk(SCREAMING_SNAKE_CASE__						):
												for folder in directories:
																		# Ignore private modules
																		if folder.startswith('''_'''						):
																								directories.remove(SCREAMING_SNAKE_CASE__						)
																								continue
																		# Ignore leftovers from branches (empty folders apart from pycache)
																		if len(list((Path(SCREAMING_SNAKE_CASE__						) / folder).glob('''*.py'''						)						)						) == 0:
																								continue
																		SCREAMING_SNAKE_CASE							:    Dict							=							str((Path(SCREAMING_SNAKE_CASE__						) / folder).relative_to(SCREAMING_SNAKE_CASE__						)						)
																		SCREAMING_SNAKE_CASE							:    List[str]							=							short_path.replace(os.path.sep		,  '''.'''						)
																		submodules.append(SCREAMING_SNAKE_CASE__						)
												for fname in files:
																		if fname == "__init__.py":
																								continue
																		SCREAMING_SNAKE_CASE							:    List[Any]							=							str((Path(SCREAMING_SNAKE_CASE__						) / fname).relative_to(SCREAMING_SNAKE_CASE__						)						)
																		SCREAMING_SNAKE_CASE							:    List[Any]							=							short_path.replace('''.py'''		,  ''''''						).replace(os.path.sep		,  '''.'''						)
																		if len(submodule.split('''.'''						)						) == 1:
																								submodules.append(SCREAMING_SNAKE_CASE__						)
						return submodules


__UpperCamelCase		:       Optional[Any]									=     [
    'convert_pytorch_checkpoint_to_tf2',
    'modeling_flax_pytorch_utils',
    'models.esm.openfold_utils',
]
def       A	(    ):
						# This is to make sure the transformers module imported is the one in the repo.
						from transformers.utils import direct_transformers_import

						SCREAMING_SNAKE_CASE							:    Tuple							=							direct_transformers_import(SCREAMING_SNAKE_CASE__						)

						SCREAMING_SNAKE_CASE							:    Optional[Any]							=							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(SCREAMING_SNAKE_CASE__		,  '''__init__.py'''						)		,  '''r'''						) as f:
												SCREAMING_SNAKE_CASE							:    Optional[int]							=							f.read()
						import_structure_keys.update(set(re.findall(R'''import_structure\[\"([^\"]*)\"\]'''		,  SCREAMING_SNAKE_CASE__						)						)						)

						SCREAMING_SNAKE_CASE							:    Any							=							[
						    module
						    for module in get_transformers_submodules()
						    if module not in IGNORE_SUBMODULES and module not in import_structure_keys
						]

						if len(SCREAMING_SNAKE_CASE__						) > 0:
												SCREAMING_SNAKE_CASE							:    List[str]							=							'''\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()








import math


def   __SCREAMING_SNAKE_CASE					(SCREAMING_SNAKE_CASE__  ,		SCREAMING_SNAKE_CASE__       ):
						if 0 not in (x, y):
												# We use the relation x^y = y*log10(x), where 10 is the base.
												return y * math.logaa(SCREAMING_SNAKE_CASE__       )
						else:
												if x == 0:  # 0 raised to any number is 0
																		return 0
												elif y == 0:
																		return 1  # any number raised to 0 is 1
						raise AssertionError('''This should never happen'''       )


if __name__ == "__main__":  # Main function
					# Read two numbers from input and typecast them to int using map function.
					# Here x is the base and y is the power.
					lowerCAmelCase_       	=	'''Enter the base and the power separated by a comma: '''
					lowerCAmelCase_	,      lowerCAmelCase_       	=	map(int, input(prompt).split(''','''))
					lowerCAmelCase_	,      lowerCAmelCase_       	=	map(int, input(prompt).split(''','''))

					# We find the log of each number, using the function res(), which takes two
					# arguments.
					lowerCAmelCase_       	=	res(xa, ya)
					lowerCAmelCase_       	=	res(xa, ya)

					# We check for the largest number
					if resa > resa:
										print('''Largest number is''', xa, '''^''', ya)
					elif resa > resa:
										print('''Largest number is''', xa, '''^''', ya)
					else:
										print('''Both are equal''')