'''simple docstring'''





SCREAMING_SNAKE_CASE_:     dict[tuple[int, int, int], int]  ={}





def 	lowerCAmelCase_				(					snake_case_       : str					,    snake_case_       : int					,    snake_case_       : Any			)    ->      int:


     '''simple docstring'''




     if late == 3 or absent == 2:
          return 0

     # if we have no days left, and have not failed any other rules,
     # we have a prize string
     if days == 0:
          return 1

     # No easy solution, so now we need to do the recursive calculation

     # First, check if the combination is already in the cache, and
     # if yes, return the stored value from there since we already
     # know the number of possible prize strings from this point on
     UpperCAmelCase_           =   (days, absent, late)
     if key in cache:
          return cache[key]

     # now we calculate the three possible ways that can unfold from
     # this point on, depending on our attendance today

     # 1) if we are late (but not absent), the "absent" counter stays as
     # it is, but the "late" counter increases by one
     UpperCAmelCase_           =   _calculate(days - 1					,    lowerCAmelCase_					,    late + 1			)

     # 2) if we are absent, the "absent" counter increases by 1, and the
     # "late" counter resets to 0
     UpperCAmelCase_           =   _calculate(days - 1					,    absent + 1					,    0			)

     # 3) if we are on time, this resets the "late" counter and keeps the
     # absent counter
     UpperCAmelCase_           =   _calculate(days - 1					,    lowerCAmelCase_					,    0			)

     UpperCAmelCase_           =   state_late + state_absent + state_ontime

     UpperCAmelCase_           =   prizestrings
     return prizestrings





def 	lowerCAmelCase_				(					snake_case_       : List[Any] = 30			)    ->      int:


     '''simple docstring'''




     return _calculate(lowerCAmelCase_					,    absent=0					,    late=0			)


if __name__ == "__main__":
    print(solution())








from argparse import ArgumentParser

from .add_new_model import AddNewModelCommand
from .add_new_model_like import AddNewModelLikeCommand
from .convert import ConvertCommand
from .download import DownloadCommand
from .env import EnvironmentCommand
from .lfs import LfsCommands
from .pt_to_tf import PTtoTFCommand
from .run import RunCommand
from .serving import ServeCommand
from .user import UserCommands



def 	lowerCAmelCase       (						)->       int:
				lowerCAmelCase_       :					int			 = ArgumentParser('''Transformers CLI tool'''       ,      usage='''transformers-cli <command> [<args>]'''       )
				lowerCAmelCase_       :					Dict			 = parser.add_subparsers(help='''transformers-cli command helpers'''       )

				# Register commands
				ConvertCommand.register_subcommand(lowerCAmelCase_       )
				DownloadCommand.register_subcommand(lowerCAmelCase_       )
				EnvironmentCommand.register_subcommand(lowerCAmelCase_       )
				RunCommand.register_subcommand(lowerCAmelCase_       )
				ServeCommand.register_subcommand(lowerCAmelCase_       )
				UserCommands.register_subcommand(lowerCAmelCase_       )
				AddNewModelCommand.register_subcommand(lowerCAmelCase_       )
				AddNewModelLikeCommand.register_subcommand(lowerCAmelCase_       )
				LfsCommands.register_subcommand(lowerCAmelCase_       )
				PTtoTFCommand.register_subcommand(lowerCAmelCase_       )

				# Let's go
				lowerCAmelCase_       :					Union[str, Any]			 = parser.parse_args()

				if not hasattr(lowerCAmelCase_       ,      '''func'''       ):
								parser.print_help()
								exit(1       )

				# Run
				lowerCAmelCase_       :					List[Any]			 = args.func(lowerCAmelCase_       )
				service.run()


if __name__ == "__main__":
						main()