


"""simple docstring"""






def __lowercase  (   lowerCamelCase_	:   int    ,       lowerCamelCase_	:   int	):
				SCREAMING_SNAKE_CASE__  				=					1.0
				for i in range(1    ,       r + 1	):
								ret *= (n + 1 - i) / i
				return round(_a	)


def __lowercase  (   lowerCamelCase_	:   int	):
				return choose(8 + n    ,       _a	) + choose(9 + n    ,       _a	) - 10


def __lowercase  (   lowerCamelCase_	:   int	):
				return sum(non_bouncy_exact(_a	) for i in range(1    ,       n + 1	)	)


def __lowercase  (   lowerCamelCase_	:   int = 100	):
				return non_bouncy_upto(_a	)


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







import numpy as np






def 				_lowerCAmelCase			(	_a :       Optional[int]       , _a :       str      )						->      Union[str, Any]:
     lowerCAmelCase_       :							int			 =		np.array(_a      )
     lowerCAmelCase_       :							str			 =		np.array(_a      )

     lowerCAmelCase_       :							Optional[Any]			 =		abs(predict - actual      )
     lowerCAmelCase_       :							Dict			 =		difference.mean()

     return score






def 				_lowerCAmelCase			(	_a :       Union[str, Any]       , _a :       int      )						->      Tuple:
     lowerCAmelCase_       :							int			 =		np.array(_a      )
     lowerCAmelCase_       :							int			 =		np.array(_a      )

     lowerCAmelCase_       :							Union[str, Any]			 =		predict - actual
     lowerCAmelCase_       :							Tuple			 =		np.square(_a      )

     lowerCAmelCase_       :							Tuple			 =		square_diff.mean()
     return score






def 				_lowerCAmelCase			(	_a :       Optional[Any]       , _a :       Tuple      )						->      Optional[int]:
     lowerCAmelCase_       :							Optional[Any]			 =		np.array(_a      )
     lowerCAmelCase_       :							Optional[Any]			 =		np.array(_a      )

     lowerCAmelCase_       :							int			 =		predict - actual
     lowerCAmelCase_       :							Any			 =		np.square(_a      )
     lowerCAmelCase_       :							Union[str, Any]			 =		square_diff.mean()
     lowerCAmelCase_       :							Optional[Any]			 =		np.sqrt(_a      )
     return score






def 				_lowerCAmelCase			(	_a :       Optional[Any]       , _a :       Optional[Any]      )						->      List[Any]:
     lowerCAmelCase_       :							Dict			 =		np.array(_a      )
     lowerCAmelCase_       :							List[Any]			 =		np.array(_a      )

     lowerCAmelCase_       :							str			 =		np.log(predict + 1      )
     lowerCAmelCase_       :							Any			 =		np.log(actual + 1      )

     lowerCAmelCase_       :							List[str]			 =		log_predict - log_actual
     lowerCAmelCase_       :							Dict			 =		np.square(_a      )
     lowerCAmelCase_       :							Optional[Any]			 =		square_diff.mean()

     lowerCAmelCase_       :							int			 =		np.sqrt(_a      )

     return score






def 				_lowerCAmelCase			(	_a :       str       , _a :       List[Any]      )						->      int:
     lowerCAmelCase_       :							Any			 =		np.array(_a      )
     lowerCAmelCase_       :							Optional[int]			 =		np.array(_a      )

     lowerCAmelCase_       :							Optional[int]			 =		predict - actual
     lowerCAmelCase_       :							str			 =		np.sum(_a      ) / len(_a      )
     lowerCAmelCase_       :							List[str]			 =		np.sum(_a      ) / len(_a      )
     # print(numerator, denumerator)
     lowerCAmelCase_       :							int			 =		float(_a      ) / denumerator * 1_00

     return score







def 				_lowerCAmelCase			(	_a :       Any       , _a :       Union[str, Any]      )						->      str:
     return np.mean(np.array(_a      ) == np.array(_a      )      )
