





from __future__ import annotations

from typing import Generic, TypeVar

__lowerCAmelCase     =			TypeVar("T")




class   _UpperCAmelCase	(   _lowercase					):
					pass




class   _UpperCAmelCase	(   _lowercase					):
					pass




class   _UpperCAmelCase	(   Generic[T]					):




					def __init__(						self    ,      __lowerCAmelCase = 10       )						->  Dict:
							UpperCamelCase__         =	[]
							UpperCamelCase__         =	limit




					def __bool__(						self       )						->  bool:
							return bool(self.stack       )




					def __str__(						self       )						->  str:
							return str(self.stack       )




					def 	snake_case_		(						self    ,      __lowerCAmelCase       )						->  None:
							if len(self.stack       ) >= self.limit:
									raise StackOverflowError
							self.stack.append(__lowerCAmelCase       )




					def 	snake_case_		(						self       )						->  T:
							if not self.stack:
									raise StackUnderflowError
							return self.stack.pop()




					def 	snake_case_		(						self       )						->  T:
							if not self.stack:
									raise StackUnderflowError
							return self.stack[-1]




					def 	snake_case_		(						self       )						->  bool:
							return not bool(self.stack       )




					def 	snake_case_		(						self       )						->  bool:
							return self.size() == self.limit




					def 	snake_case_		(						self       )						->  int:
							return len(self.stack       )




					def __contains__(						self    ,      __lowerCAmelCase       )						->  bool:
							return item in self.stack



def     a						(      )     ->None:
		UpperCamelCase__         =	Stack(1_0       )
		assert bool(_lowercase       ) is False
		assert stack.is_empty() is True
		assert stack.is_full() is False
		assert str(_lowercase       ) == "[]"

		try:
				UpperCamelCase__         =	stack.pop()
				raise AssertionError  # This should not happen
		except StackUnderflowError:
				assert True  # This should happen

		try:
				UpperCamelCase__         =	stack.peek()
				raise AssertionError  # This should not happen
		except StackUnderflowError:
				assert True  # This should happen

		for i in range(1_0       ):
				assert stack.size() == i
				stack.push(_lowercase       )

		assert bool(_lowercase       )
		assert not stack.is_empty()
		assert stack.is_full()
		assert str(_lowercase       ) == str(list(range(1_0       )       )       )
		assert stack.pop() == 9
		assert stack.peek() == 8

		stack.push(1_0_0       )
		assert str(_lowercase       ) == str([0, 1, 2, 3, 4, 5, 6, 7, 8, 1_0_0]       )

		try:
				stack.push(2_0_0       )
				raise AssertionError  # This should not happen
		except StackOverflowError:
				assert True  # This should happen

		assert not stack.is_empty()
		assert stack.size() == 1_0

		assert 5 in stack
		assert 5_5 not in stack


if __name__ == "__main__":
				test_stack()












def     a						(      _lowercase   :     int ,						_lowercase   :     int       )     ->int:
		UpperCamelCase__         =	1.0
		for i in range(1 ,						r + 1       ):
				ret *= (n + 1 - i) / i
		return round(_lowercase       )

def     a						(      _lowercase   :     int       )     ->int:
		return choose(8 + n ,						_lowercase       ) + choose(9 + n ,						_lowercase       ) - 1_0

def     a						(      _lowercase   :     int       )     ->int:
		return sum(non_bouncy_exact(_lowercase       ) for i in range(1 ,						n + 1       )       )

def     a						(      _lowercase   :     int = 1_0_0       )     ->int:
		return non_bouncy_upto(_lowercase       )


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





