





from itertools import combinations_with_replacement





def  a_       (							_lowercase = 100     ):
						_UpperCamelCase    :      list[int]						     =					[*list(range(1 ,		21     )     ), 25]
						_UpperCamelCase    :      list[int]						     =					[2 * x for x in range(1 ,		21     )] + [50]
						_UpperCamelCase    :      list[int]						     =					[3 * x for x in range(1 ,		21     )]
						_UpperCamelCase    :      list[int]						     =					singles + doubles + triples + [0]

						_UpperCamelCase    :      int						     =					0
						_UpperCamelCase    :      int
						_UpperCamelCase    :      int
						_UpperCamelCase    :      int
						_UpperCamelCase    :      int

						for double in doubles:
												for throwa, throwa in combinations_with_replacement(_lowercase ,		2     ):
																		_UpperCamelCase    :      Tuple						     =					double + throwa + throwa
																		if checkout_total < limit:
																								num_checkouts += 1

						return num_checkouts


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










"""simple docstring"""




UpperCamelCase_     =1_000





def  a_       (							_lowercase     ):
						return x * x





def  a_       (							_lowercase ,		_lowercase ,		_lowercase ,		_lowercase = 4     ):
						assert callable(
						    _lowercase     ), F"""the function(object) passed should be callable your input : {function}"""
						assert isinstance(_lowercase ,		(float, int)     ), F"""a should be float or integer your input : {a}"""
						assert isinstance(function(_lowercase     ) ,		(float, int)     ), (
						    "the function should return integer or float return type of your function, "
						    F"""{type(_lowercase     )}"""
						)
						assert isinstance(_lowercase ,		(float, int)     ), F"""b should be float or integer your input : {b}"""
						assert (
						    isinstance(_lowercase ,		_lowercase     ) and precision > 0
						), F"""precision should be positive integer your input : {precision}"""

						# just applying the formula of simpson for approximate integration written in
						# mentioned article in first comment of this file and above this function

						_UpperCamelCase    :      str						     =					(b - a) / N_STEPS
						_UpperCamelCase    :      Dict						     =					function(_lowercase     ) + function(_lowercase     )

						for i in range(1 ,		_lowercase     ):
												_UpperCamelCase    :      List[Any]						     =					a + h * i
												result += function(_lowercase     ) * (4 if i % 2 else 2)

						result *= h / 3
						return round(_lowercase ,		_lowercase     )


if __name__ == "__main__":
						import doctest

						doctest.testmod()



