

import numpy as np




def        __UpperCamelCase     (      _A					:							List[Any]      ,  _A					:							Tuple		)				->Dict:



							"""simple docstring"""
							lowerCamelCase_								=np.array(_A		)
							lowerCamelCase_								=np.array(_A		)

							lowerCamelCase_								=abs(predict - actual		)
							lowerCamelCase_								=difference.mean()

							return score




def        __UpperCamelCase     (      _A					:							Dict      ,  _A					:							int		)				->List[str]:



							"""simple docstring"""
							lowerCamelCase_								=np.array(_A		)
							lowerCamelCase_								=np.array(_A		)

							lowerCamelCase_								=predict - actual
							lowerCamelCase_								=np.square(_A		)

							lowerCamelCase_								=square_diff.mean()
							return score




def        __UpperCamelCase     (      _A					:							Optional[Any]      ,  _A					:							Dict		)				->str:



							"""simple docstring"""
							lowerCamelCase_								=np.array(_A		)
							lowerCamelCase_								=np.array(_A		)

							lowerCamelCase_								=predict - actual
							lowerCamelCase_								=np.square(_A		)
							lowerCamelCase_								=square_diff.mean()
							lowerCamelCase_								=np.sqrt(_A		)
							return score




def        __UpperCamelCase     (      _A					:							List[str]      ,  _A					:							Any		)				->Tuple:



							"""simple docstring"""
							lowerCamelCase_								=np.array(_A		)
							lowerCamelCase_								=np.array(_A		)

							lowerCamelCase_								=np.log(predict + 1		)
							lowerCamelCase_								=np.log(actual + 1		)

							lowerCamelCase_								=log_predict - log_actual
							lowerCamelCase_								=np.square(_A		)
							lowerCamelCase_								=square_diff.mean()

							lowerCamelCase_								=np.sqrt(_A		)

							return score




def        __UpperCamelCase     (      _A					:							Any      ,  _A					:							Optional[int]		)				->Tuple:



							"""simple docstring"""
							lowerCamelCase_								=np.array(_A		)
							lowerCamelCase_								=np.array(_A		)

							lowerCamelCase_								=predict - actual
							lowerCamelCase_								=np.sum(_A		) / len(_A		)
							lowerCamelCase_								=np.sum(_A		) / len(_A		)
							# print(numerator, denumerator)
							lowerCamelCase_								=float(_A		) / denumerator * 100

							return score






def        __UpperCamelCase     (      _A					:							List[Any]      ,  _A					:							Tuple		)				->Any:



							"""simple docstring"""
							return np.mean(np.array(_A		) == np.array(_A		)		)



from math import factorial




def        __UpperCamelCase     (      _A					:							Union[str, Any]      ,  _A					:							Tuple		)				->Any:



							"""simple docstring"""
							return factorial(_A		) / (factorial(_A		) * factorial(n - r		))




def        __UpperCamelCase     (      )				->Any:



							"""simple docstring"""
							lowerCamelCase_								=0

							for i in range(1      ,  101		):
														for j in range(1      ,  i + 1		):
																					if combinations(_A      ,  _A		) > 1E6:
																												total += 1
							return total


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