





import logging
import os
from logging import (
    CRITICAL,  # NOQA
    DEBUG,  # NOQA
    ERROR,  # NOQA
    FATAL,  # NOQA
    INFO,  # NOQA
    NOTSET,  # NOQA
    WARN,  # NOQA
    WARNING,  # NOQA
)
from typing import Optional

from tqdm import auto as tqdm_lib


__lowerCamelCase       :     Any   =     {
    """debug""": logging.DEBUG,
    """info""": logging.INFO,
    """warning""": logging.WARNING,
    """error""": logging.ERROR,
    """critical""": logging.CRITICAL,
}

__lowerCamelCase       :     int   =     logging.WARNING



def 		A_				(     )						-> Optional[int]:
 UpperCamelCase	:					int       	=   os.getenv("DATASETS_VERBOSITY"							,   _lowerCAmelCase     )
 if env_level_str:
  if env_level_str in log_levels:
   return log_levels[env_level_str]
  else:
   logging.getLogger().warning(
       F"""Unknown option DATASETS_VERBOSITY={env_level_str}, """
       F"""has to be one of: { ", ".join(log_levels.keys()     ) }"""     )
 return _default_log_level



def 		A_				(     )						-> str:
 return __name__.split("."     )[0]



def 		A_				(     )						-> logging.Logger:
 return logging.getLogger(_get_library_name()     )



def 		A_				(     )						-> None:
 # Apply our default configuration to the library root logger.
 UpperCamelCase	:					Optional[int]       	=   _get_library_root_logger()
 library_root_logger.setLevel(_get_default_logging_level()     )



def 		A_				(     )						-> None:
 UpperCamelCase	:					Optional[int]       	=   _get_library_root_logger()
 library_root_logger.setLevel(logging.NOTSET     )



def 		A_				(     _lowerCAmelCase = None     )						-> logging.Logger:
 if name is None:
  UpperCamelCase	:					Union[str, Any]       	=   _get_library_name()
 return logging.getLogger(_lowerCAmelCase     )



def 		A_				(     )						-> int:
 return _get_library_root_logger().getEffectiveLevel()



def 		A_				(     _lowerCAmelCase     )						-> None:
 _get_library_root_logger().setLevel(_lowerCAmelCase     )



def 		A_				(     )						-> List[str]:
 return set_verbosity(_lowerCAmelCase     )



def 		A_				(     )						-> Dict:
 return set_verbosity(_lowerCAmelCase     )



def 		A_				(     )						-> Union[str, Any]:
 return set_verbosity(_lowerCAmelCase     )



def 		A_				(     )						-> List[Any]:
 return set_verbosity(_lowerCAmelCase     )



def 		A_				(     )						-> None:
 UpperCamelCase	:					Any       	=   False



def 		A_				(     )						-> None:
 UpperCamelCase	:					int       	=   True


# Configure the library root logger at the module level (singleton-like)
_configure_library_root_logger()



class 					A__   :





      def __init__( self       ,							*A_       ,							**A_   ):  # pylint: disable=unused-argument
       '''simple docstring'''




       UpperCamelCase	:					List[Any]       	=   args[0] if args else None





      def __iter__( self   ):
       '''simple docstring'''




       return iter(self._iterator   )





      def __getattr__( self       ,							A_   ):
       '''simple docstring'''




       def empty_fn(*A_       ,							**A_   ):  # pylint: disable=unused-argument
        return

       return empty_fn





      def __enter__( self   ):
       '''simple docstring'''




       return self





      def __exit__( self       ,							A_       ,							A_       ,							A_   ):
       '''simple docstring'''




       return


__lowerCamelCase       :     List[str]   =     True



class 					A__   :





      def __call__( self       ,							*A_       ,							A_=False       ,							**A_   ):
       '''simple docstring'''




       if _tqdm_active and not disable:
        return tqdm_lib.tqdm(*A_       ,							**A_   )
       else:
        return EmptyTqdm(*A_       ,							**A_   )





      def        __UpperCamelCase( self       ,							*A_       ,							**A_   ):
       '''simple docstring'''




       UpperCamelCase	:					int       	=   None
       if _tqdm_active:
        return tqdm_lib.tqdm.set_lock(*A_       ,							**A_   )





      def        __UpperCamelCase( self   ):
       '''simple docstring'''




       if _tqdm_active:
        return tqdm_lib.tqdm.get_lock()


__lowerCamelCase       :     int   =     _tqdm_cls()



def 		A_				(     )						-> bool:
 global _tqdm_active
 return bool(_tqdm_active     )



def 		A_				(     )						-> Any:
 global _tqdm_active
 UpperCamelCase	:					int       	=   True



def 		A_				(     )						-> Tuple:
 global _tqdm_active
 UpperCamelCase	:					Dict       	=   False







def 		A_				(     _lowerCAmelCase = 50     )						-> int:
 UpperCamelCase	:					List[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() = }""")
