"""simple docstring"""







import unittest

from .lib import (
    Matrix,
    Vector,
    axpy,
    square_zero_matrix,
    unit_basis_vector,
    zero_vector,
)







class        UpperCamelCase		(			unittest.TestCase  ):
   def 			_UpperCAmelCase   (			self			)	->      None:


        '''simple docstring'''


        lowercase_	:				Union[str, Any]													=	Vector([1, 2, 3]			)
        self.assertEqual(x.component(0			)     ,1			)
        self.assertEqual(x.component(2			)     ,3			)
        lowercase_	:				Optional[Any]													=	Vector()
   def 			_UpperCAmelCase   (			self			)	->      None:


        '''simple docstring'''


        lowercase_	:				Union[str, Any]													=	Vector([0, 0, 0, 0, 0, 1]			)
        self.assertEqual(str(__UpperCamelCase			)     ,'(0,0,0,0,0,1)'			)
   def 			_UpperCAmelCase   (			self			)	->      None:


        '''simple docstring'''


        lowercase_	:				str													=	Vector([1, 2, 3, 4]			)
        self.assertEqual(len(__UpperCamelCase			)     ,4			)
   def 			_UpperCAmelCase   (			self			)	->      None:


        '''simple docstring'''


        lowercase_	:				str													=	Vector([1, 2]			)
        lowercase_	:				List[str]													=	Vector([1, 2, 3, 4, 5]			)
        lowercase_	:				Optional[Any]													=	Vector([0, 0, 0, 0, 0, 0, 0, 0, 0, 0]			)
        lowercase_	:				Optional[Any]													=	Vector([1, -1, 1, -1, 2, -3, 4, -5]			)
        self.assertAlmostEqual(x.euclidean_length()     ,2.236     ,3			)
        self.assertAlmostEqual(y.euclidean_length()     ,7.416     ,3			)
        self.assertEqual(z.euclidean_length()     ,0			)
        self.assertAlmostEqual(w.euclidean_length()     ,7.616     ,3			)
   def 			_UpperCAmelCase   (			self			)	->      None:


        '''simple docstring'''


        lowercase_	:				Union[str, Any]													=	Vector([1, 2, 3]			)
        lowercase_	:				List[str]													=	Vector([1, 1, 1]			)
        self.assertEqual((x + y).component(0			)     ,2			)
        self.assertEqual((x + y).component(1			)     ,3			)
        self.assertEqual((x + y).component(2			)     ,4			)
   def 			_UpperCAmelCase   (			self			)	->      None:


        '''simple docstring'''


        lowercase_	:				List[str]													=	Vector([1, 2, 3]			)
        lowercase_	:				str													=	Vector([1, 1, 1]			)
        self.assertEqual((x - y).component(0			)     ,0			)
        self.assertEqual((x - y).component(1			)     ,1			)
        self.assertEqual((x - y).component(2			)     ,2			)
   def 			_UpperCAmelCase   (			self			)	->      None:


        '''simple docstring'''


        lowercase_	:				Any													=	Vector([1, 2, 3]			)
        lowercase_	:				List[str]													=	Vector([2, -1, 4]			)  # for test of dot product
        lowercase_	:				Dict													=	Vector([1, -2, -1]			)
        self.assertEqual(str(x * 3.0			)     ,'(3.0,6.0,9.0)'			)
        self.assertEqual((a * b)     ,0			)
   def 			_UpperCAmelCase   (			self			)	->      None:


        '''simple docstring'''


        self.assertEqual(str(zero_vector(10			)			).count('0'			)     ,10			)
   def 			_UpperCAmelCase   (			self			)	->      None:


        '''simple docstring'''


        self.assertEqual(str(unit_basis_vector(3     ,1			)			)     ,'(0,1,0)'			)
   def 			_UpperCAmelCase   (			self			)	->      None:


        '''simple docstring'''


        lowercase_	:				Optional[int]													=	Vector([1, 2, 3]			)
        lowercase_	:				Optional[Any]													=	Vector([1, 0, 1]			)
        self.assertEqual(str(axpy(2     ,__UpperCamelCase     ,__UpperCamelCase			)			)     ,'(3,4,7)'			)
   def 			_UpperCAmelCase   (			self			)	->      None:


        '''simple docstring'''


        lowercase_	:				Optional[Any]													=	Vector([1, 0, 0, 0, 0, 0]			)
        lowercase_	:				Any													=	x.copy()
        self.assertEqual(str(__UpperCamelCase			)     ,str(__UpperCamelCase			)			)
   def 			_UpperCAmelCase   (			self			)	->      None:


        '''simple docstring'''


        lowercase_	:				List[Any]													=	Vector([1, 0, 0]			)
        x.change_component(0     ,0			)
        x.change_component(1     ,1			)
        self.assertEqual(str(__UpperCamelCase			)     ,'(0,1,0)'			)
   def 			_UpperCAmelCase   (			self			)	->      None:


        '''simple docstring'''


        lowercase_	:				Union[str, Any]													=	Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]     ,3     ,3			)
        self.assertEqual('|1,2,3|\n|2,4,5|\n|6,7,8|\n'     ,str(__UpperCamelCase			)			)
   def 			_UpperCAmelCase   (			self			)	->      None:


        '''simple docstring'''


        lowercase_	:				Dict													=	Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]     ,3     ,3			)
        lowercase_	:				Optional[Any]													=	[[-3, -14, -10], [-5, -10, -5], [-2, -1, 0]]
        for x in range(a.height()			):
             for y in range(a.width()			):
                  self.assertEqual(minors[x][y]     ,a.minor(__UpperCamelCase     ,__UpperCamelCase			)			)
   def 			_UpperCAmelCase   (			self			)	->      None:


        '''simple docstring'''


        lowercase_	:				int													=	Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]     ,3     ,3			)
        lowercase_	:				str													=	[[-3, 14, -10], [5, -10, 5], [-2, 1, 0]]
        for x in range(a.height()			):
             for y in range(a.width()			):
                  self.assertEqual(cofactors[x][y]     ,a.cofactor(__UpperCamelCase     ,__UpperCamelCase			)			)
   def 			_UpperCAmelCase   (			self			)	->      None:


        '''simple docstring'''


        lowercase_	:				str													=	Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]     ,3     ,3			)
        self.assertEqual(-5     ,a.determinant()			)
   def 			_UpperCAmelCase   (			self			)	->      None:


        '''simple docstring'''


        lowercase_	:				str													=	Matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]]     ,3     ,3			)
        lowercase_	:				Union[str, Any]													=	Vector([1, 2, 3]			)
        self.assertEqual('(14,32,50)'     ,str(a * x			)			)
        self.assertEqual('|2,4,6|\n|8,10,12|\n|14,16,18|\n'     ,str(a * 2			)			)
   def 			_UpperCAmelCase   (			self			)	->      None:


        '''simple docstring'''


        lowercase_	:				Any													=	Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]     ,3     ,3			)
        a.change_component(0     ,2     ,5			)
        self.assertEqual('|1,2,5|\n|2,4,5|\n|6,7,8|\n'     ,str(__UpperCamelCase			)			)
   def 			_UpperCAmelCase   (			self			)	->      None:


        '''simple docstring'''


        lowercase_	:				Dict													=	Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]     ,3     ,3			)
        self.assertEqual(7     ,a.component(2     ,1			)     ,0.01			)
   def 			_UpperCAmelCase   (			self			)	->      None:


        '''simple docstring'''


        lowercase_	:				List[str]													=	Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]     ,3     ,3			)
        lowercase_	:				List[Any]													=	Matrix([[1, 2, 7], [2, 4, 5], [6, 7, 10]]     ,3     ,3			)
        self.assertEqual('|2,4,10|\n|4,8,10|\n|12,14,18|\n'     ,str(a + b			)			)
   def 			_UpperCAmelCase   (			self			)	->      None:


        '''simple docstring'''


        lowercase_	:				Optional[Any]													=	Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]     ,3     ,3			)
        lowercase_	:				Optional[int]													=	Matrix([[1, 2, 7], [2, 4, 5], [6, 7, 10]]     ,3     ,3			)
        self.assertEqual('|0,0,-4|\n|0,0,0|\n|0,0,-2|\n'     ,str(a - b			)			)







   def 			_UpperCAmelCase   (			self			)	->      None:


        '''simple docstring'''


        self.assertEqual(
            '|0,0,0,0,0|\n|0,0,0,0,0|\n|0,0,0,0,0|\n|0,0,0,0,0|\n|0,0,0,0,0|\n'     ,str(square_zero_matrix(5			)			)     ,)


if __name__ == "__main__":
       unittest.main()


"""simple docstring"""







__SCREAMING_SNAKE_CASE    	={}



def 			lowercase__(       __SCREAMING_SNAKE_CASE							:     int     ,			__SCREAMING_SNAKE_CASE							:     int     ,			__SCREAMING_SNAKE_CASE							:     int      ):

     # if we are absent twice, or late 3 consecutive days,
     # no further prize strings are possible
     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
     lowercase_	:				Any													=	(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
     lowercase_	:				Optional[int]													=	_calculate(days - 1     ,			__SCREAMING_SNAKE_CASE     ,			late + 1      )

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

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

     lowercase_	:				str													=	state_late + state_absent + state_ontime

     lowercase_	:				Tuple													=	prizestrings
     return prizestrings



def 			lowercase__(       __SCREAMING_SNAKE_CASE							:     int = 30      ):
     return _calculate(__SCREAMING_SNAKE_CASE     ,			absent=0     ,			late=0      )


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

