

'''simple docstring'''




def 			__UpperCamelCase    (    _A    :				str = 50				)    ->      str:




	"""simple docstring"""





	lowerCAmelCase					:    Union[str, Any]      							= [[0] * 3 for _ in range(length + 1				)]

	for row_length in range(length + 1				):
		for tile_length in range(2					,   5				):
			for tile_start in range(row_length - tile_length + 1				):
				different_colour_ways_number[row_length][tile_length - 2] += (
				    different_colour_ways_number[row_length - tile_start - tile_length][
				        tile_length - 2
				    ]
				    + 1
				)

	return sum(different_colour_ways_number[length]				)


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




'''simple docstring'''




import argparse
import os
import re


_lowerCAmelCase  :		Dict		     =	'src/diffusers'

# Pattern that looks at the indentation in a line.
_lowerCAmelCase  :		str		     =	re.compile(r'^(\s*)\S')
# Pattern that matches `"key":" and puts `key` in group 0.
_lowerCAmelCase  :		Any		     =	re.compile(r'^\s*"([^"]+)":')
# Pattern that matches `_import_structure["key"]` and puts `key` in group 0.
_lowerCAmelCase  :		List[Any]		     =	re.compile(r'^\s*_import_structure\["([^"]+)"\]')
# Pattern that matches `"key",` and puts `key` in group 0.
_lowerCAmelCase  :		int		     =	re.compile(r'^\s*"([^"]+)",\s*$')
# Pattern that matches any `[stuff]` and puts `stuff` in group 0.
_lowerCAmelCase  :		Optional[Any]		     =	re.compile(r'\[([^\]]+)\]')

def 			__UpperCamelCase    (    _A    :				Union[str, Any]				)    ->      Dict:




	"""simple docstring"""





	lowerCAmelCase					:    Any      							= _re_indent.search(_A				)
	return "" if search is None else search.groups()[0]

def 			__UpperCamelCase    (    _A    :				Dict					,   _A    :				Any=""					,   _A    :				List[str]=None					,   _A    :				Any=None				)    ->      Tuple:




	"""simple docstring"""





	lowerCAmelCase					:    Optional[int]      							= 0
	lowerCAmelCase					:    Tuple      							= code.split('\n'				)
	if start_prompt is not None:
		while not lines[index].startswith(_A				):
			index += 1
		lowerCAmelCase					:    Optional[int]      							= ['\n'.join(lines[:index]				)]
	else:
		lowerCAmelCase					:    int      							= []

	# We split into blocks until we get to the `end_prompt` (or the end of the block).
	lowerCAmelCase					:    Tuple      							= [lines[index]]
	index += 1
	while index < len(_A				) and (end_prompt is None or not lines[index].startswith(_A				)):
		if len(lines[index]				) > 0 and get_indent(lines[index]				) == indent_level:
			if len(_A				) > 0 and get_indent(current_block[-1]				).startswith(indent_level + ' '				):
				current_block.append(lines[index]				)
				blocks.append('\n'.join(_A				)				)
				if index < len(_A				) - 1:
					lowerCAmelCase					:    List[Any]      							= [lines[index + 1]]
					index += 1
				else:
					lowerCAmelCase					:    int      							= []
			else:
				blocks.append('\n'.join(_A				)				)
				lowerCAmelCase					:    Any      							= [lines[index]]
		else:
			current_block.append(lines[index]				)
		index += 1

	# Adds current block if it's nonempty.
	if len(_A				) > 0:
		blocks.append('\n'.join(_A				)				)

	# Add final block after end_prompt if provided.
	if end_prompt is not None and index < len(_A				):
		blocks.append('\n'.join(lines[index:]				)				)

	return blocks

def 			__UpperCamelCase    (    _A    :				Dict				)    ->      List[Any]:




	"""simple docstring"""





	def _inner(_A    :				Tuple				):
		return key(_A				).lower().replace('_'					,   ''				)

	return _inner

def 			__UpperCamelCase    (    _A    :				Union[str, Any]					,   _A    :				Any=None				)    ->      Optional[Any]:




	"""simple docstring"""





	def noop(_A    :				Any				):
		return x

	if key is None:
		lowerCAmelCase					:    List[str]      							= noop
	# Constants are all uppercase, they go first.
	lowerCAmelCase					:    str      							= [obj for obj in objects if key(_A				).isupper()]
	# Classes are not all uppercase but start with a capital, they go second.
	lowerCAmelCase					:    List[str]      							= [obj for obj in objects if key(_A				)[0].isupper() and not key(_A				).isupper()]
	# Functions begin with a lowercase, they go last.
	lowerCAmelCase					:    Optional[Any]      							= [obj for obj in objects if not key(_A				)[0].isupper()]

	lowerCAmelCase					:    Tuple      							= ignore_underscore(_A				)
	return sorted(_A					,   key=_A				) + sorted(_A					,   key=_A				) + sorted(_A					,   key=_A				)

def 			__UpperCamelCase    (    _A    :				Union[str, Any]				)    ->      int:




	"""simple docstring"""





	def _replace(_A    :				List[Any]				):
		lowerCAmelCase					:    List[Any]      							= match.groups()[0]
		if "," not in imports:
			return F"[{imports}]"
		lowerCAmelCase					:    Dict      							= [part.strip().replace('"'					,   ''				) for part in imports.split(','				)]
		# We will have a final empty element if the line finished with a comma.
		if len(keys[-1]				) == 0:
			lowerCAmelCase					:    List[str]      							= keys[:-1]
		return "[" + ", ".join([F"\"{k}\"" for k in sort_objects(_A				)]				) + "]"

	lowerCAmelCase					:    Optional[int]      							= import_statement.split('\n'				)
	if len(_A				) > 3:
		# Here we have to sort internal imports that are on several lines (one per name):
		# key: [
		#     "object1",
		#     "object2",
		#     ...
		# ]

		# We may have to ignore one or two lines on each side.
		lowerCAmelCase					:    Optional[Any]      							= 2 if lines[1].strip() == '[' else 1
		lowerCAmelCase					:    List[str]      							= [(i, _re_strip_line.search(_A				).groups()[0]) for i, line in enumerate(lines[idx:-idx]				)]
		lowerCAmelCase					:    Optional[Any]      							= sort_objects(_A					,   key=lambda _A				: x[1]				)
		lowerCAmelCase					:    Dict      							= [lines[x[0] + idx] for x in sorted_indices]
		return "\n".join(lines[:idx] + sorted_lines + lines[-idx:]				)
	elif len(_A				) == 3:
		# Here we have to sort internal imports that are on one separate line:
		# key: [
		#     "object1", "object2", ...
		# ]
		if _re_bracket_content.search(lines[1]				) is not None:
			lowerCAmelCase					:    Optional[int]      							= _re_bracket_content.sub(_replace					,   lines[1]				)
		else:
			lowerCAmelCase					:    List[Any]      							= [part.strip().replace('"'					,   ''				) for part in lines[1].split(','				)]
			# We will have a final empty element if the line finished with a comma.
			if len(keys[-1]				) == 0:
				lowerCAmelCase					:    int      							= keys[:-1]
			lowerCAmelCase					:    Tuple      							= get_indent(lines[1]				) + ', '.join([F"\"{k}\"" for k in sort_objects(_A				)]				)
		return "\n".join(_A				)
	else:
		# Finally we have to deal with imports fitting on one line
		lowerCAmelCase					:    Union[str, Any]      							= _re_bracket_content.sub(_replace					,   _A				)
		return import_statement

def 			__UpperCamelCase    (    _A    :				str					,   _A    :				Tuple=True				)    ->      Optional[Any]:




	"""simple docstring"""





	with open(_A					,   'r'				) as f:
		lowerCAmelCase					:    Optional[int]      							= f.read()

	if "_import_structure" not in code:
		return

	# Blocks of indent level 0
	lowerCAmelCase					:    List[Any]      							= split_code_in_indented_blocks(
	    _A					,   start_prompt='_import_structure = {'					,   end_prompt='if TYPE_CHECKING:'				)

	# We ignore block 0 (everything until start_prompt) and the last block (everything after end_prompt).
	for block_idx in range(1					,   len(_A				) - 1				):
		# Check if the block contains some `_import_structure`s thingy to sort.
		lowerCAmelCase					:    List[str]      							= main_blocks[block_idx]
		lowerCAmelCase					:    Union[str, Any]      							= block.split('\n'				)

		# Get to the start of the imports.
		lowerCAmelCase					:    Optional[Any]      							= 0
		while line_idx < len(_A				) and "_import_structure" not in block_lines[line_idx]:
			# Skip dummy import blocks
			if "import dummy" in block_lines[line_idx]:
				lowerCAmelCase					:    Optional[Any]      							= len(_A				)
			else:
				line_idx += 1
		if line_idx >= len(_A				):
			continue

		# Ignore beginning and last line: they don't contain anything.
		lowerCAmelCase					:    str      							= '\n'.join(block_lines[line_idx:-1]				)
		lowerCAmelCase					:    str      							= get_indent(block_lines[1]				)
		# Slit the internal block into blocks of indent level 1.
		lowerCAmelCase					:    Optional[Any]      							= split_code_in_indented_blocks(_A					,   indent_level=_A				)
		# We have two categories of import key: list or _import_structure[key].append/extend
		lowerCAmelCase					:    Union[str, Any]      							= _re_direct_key if '_import_structure' in block_lines[0] else _re_indirect_key
		# Grab the keys, but there is a trap: some lines are empty or just comments.
		lowerCAmelCase					:    int      							= [(pattern.search(_A				).groups()[0] if pattern.search(_A				) is not None else None) for b in internal_blocks]
		# We only sort the lines with a key.
		lowerCAmelCase					:    Dict      							= [(i, key) for i, key in enumerate(_A				) if key is not None]
		lowerCAmelCase					:    List[Any]      							= [x[0] for x in sorted(_A					,   key=lambda _A				: x[1]				)]

		# We reorder the blocks by leaving empty lines/comments as they were and reorder the rest.
		lowerCAmelCase					:    int      							= 0
		lowerCAmelCase					:    Dict      							= []
		for i in range(len(_A				)				):
			if keys[i] is None:
				reordered_blocks.append(internal_blocks[i]				)
			else:
				lowerCAmelCase					:    str      							= sort_objects_in_import(internal_blocks[sorted_indices[count]]				)
				reordered_blocks.append(_A				)
				count += 1

        # And we put our main block back together with its first and last line.
		lowerCAmelCase					:    str      							= '\n'.join(block_lines[:line_idx] + reordered_blocks + [block_lines[-1]]				)

	if code != "\n".join(_A				):
		if check_only:
			return True
		else:
			print(F"Overwriting {file}."				)
			with open(_A					,   'w'				) as f:
				f.write('\n'.join(_A				)				)

def 			__UpperCamelCase    (    _A    :				Tuple=True				)    ->      Any:




	"""simple docstring"""





	lowerCAmelCase					:    Tuple      							= []
	for root, _, files in os.walk(_A				):
		if "__init__.py" in files:
			lowerCAmelCase					:    Any      							= sort_imports(os.path.join(_A					,   '__init__.py'				)					,   check_only=_A				)
			if result:
				lowerCAmelCase					:    Optional[Any]      							= [os.path.join(_A					,   '__init__.py'				)]
	if len(_A				) > 0:
		raise ValueError(F"Would overwrite {len(_A				)} files, run `make style`."				)


if __name__ == "__main__":
				_lowerCAmelCase  :		Union[str, Any]		     =	argparse.ArgumentParser()
				parser.add_argument('--check_only', action='store_true', help='Whether to only check or fix style.')
				_lowerCAmelCase  :		Optional[int]		     =	parser.parse_args()

				sort_imports_in_all_inits(check_only=args.check_only)
