

"""simple docstring"""


def  _lowercase					(    __lowerCAmelCase = 50							)       ->				int:
      SCREAMING_SNAKE_CASE__   :      Tuple      		=	[[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 re
from pathlib import Path
from unittest import TestCase

import pytest

@pytest.mark.integration
class      __a							(UpperCamelCase_):






     '''simple docstring'''

     def 					_a			(						self	,    _a  )  ->      Union[str, Any]:


           """simple docstring"""


           with open(_a	,    encoding="""utf-8"""  ) as input_file:
                 SCREAMING_SNAKE_CASE__   :      str      		=	re.compile(r"""(?!.*\b(?:encoding|rb|w|wb|w+|wb+|ab|ab+)\b)(?<=\s)(open)\((.*)\)"""  )
                 SCREAMING_SNAKE_CASE__   :      Optional[Any]      		=	input_file.read()
                 SCREAMING_SNAKE_CASE__   :      str      		=	regexp.search(_a  )

           return match

     def 					_a			(						self	,    _a  )  ->      Optional[Any]:


           """simple docstring"""


           with open(_a	,    encoding="""utf-8"""  ) as input_file:
                 SCREAMING_SNAKE_CASE__   :      Tuple      		=	re.compile(r"""#[^\r\n]*print\(|\"[^\r\n]*print\(|\"\"\".*?print\(.*?\"\"\"|(print\()"""	,    re.DOTALL  )
                 SCREAMING_SNAKE_CASE__   :      List[Any]      		=	input_file.read()
                 # use `re.finditer` to handle the case where the ignored groups would be matched first by `re.search`
                 SCREAMING_SNAKE_CASE__   :      Dict      		=	regexp.finditer(_a  )

           SCREAMING_SNAKE_CASE__   :      int      		=	[match for match in matches if match is not None and match.group(1  ) is not None]
           return matches[0] if matches else None

     def 					_a			(						self  )  ->      str:


           """simple docstring"""


           SCREAMING_SNAKE_CASE__   :      Optional[int]      		=	Path("""./datasets"""  )
           SCREAMING_SNAKE_CASE__   :      Union[str, Any]      		=	list(dataset_paths.absolute().glob("""**/*.py"""  )  )

           for dataset in dataset_files:
                 if self._no_encoding_on_file_open(str(_a  )  ):
                       raise AssertionError(f'''open(...) must use utf-8 encoding in {dataset}'''  )





     def 					_a			(						self  )  ->      Dict:


           """simple docstring"""


           SCREAMING_SNAKE_CASE__   :      Union[str, Any]      		=	Path("""./datasets"""  )
           SCREAMING_SNAKE_CASE__   :      List[str]      		=	list(dataset_paths.absolute().glob("""**/*.py"""  )  )

           for dataset in dataset_files:
                 if self._no_print_statements(str(_a  )  ):
                       raise AssertionError(f'''print statement found in {dataset}. Use datasets.logger/logging instead.'''  )




