


'''simple docstring'''
from __future__ import annotations

from collections.abc import Iterable, Iterator
from typing import Any, Generic, TypeVar

__magic_name__   :   List[Any]  							=TypeVar('T', bound=bool)






class 		UpperCamelCase_		(					Generic[T]   ):





						"""simple docstring"""




						def __init__( self				:					Optional[Any]	,				_lowerCamelCase				:					T  )							->					None:
										__magic_name__	  = value
										__magic_name__	  = None
										__magic_name__	  = None
						@property
						def 					__A					( self				:					Dict  )							->					T:
										return self._value

						@staticmethod
						def 					__A					( _lowerCamelCase				:					SkewNode[T] | None	,				_lowerCamelCase				:					SkewNode[T] | None  )							->					SkewNode[T] | None:
										if not roota:
														return roota

										if not roota:
														return roota

										if roota.value > roota.value:
														__magic_name__  ,      __magic_name__	  = roota, roota

										__magic_name__	  = roota
										__magic_name__	  = roota.right
										__magic_name__	  = roota.left
										__magic_name__	  = SkewNode.merge(_lowerCamelCase	,				_lowerCamelCase  )

										return result






class 		UpperCamelCase_		(					Generic[T]   ):





						"""simple docstring"""




						def __init__( self				:					Dict	,				_lowerCamelCase				:					Iterable[T] | None = ()  )							->					None:
										__magic_name__	  = None
										if data:
														for item in data:
																		self.insert(_lowerCamelCase  )
						def __bool__( self				:					int  )							->					bool:
										return self._root is not None
						def __iter__( self				:					str  )							->					Iterator[T]:
										__magic_name__	  = []
										while self:
														result.append(self.pop()  )

										# Pushing items back to the heap not to clear it.
										for item in result:
														self.insert(_lowerCamelCase  )

										return iter(_lowerCamelCase  )
						def 					__A					( self				:					Dict	,				_lowerCamelCase				:					T  )							->					None:
										__magic_name__	  = SkewNode.merge(self._root	,				SkewNode(_lowerCamelCase  )  )
						def 					__A					( self				:					List[Any]  )							->					T | None:
										__magic_name__	  = self.top()
										__magic_name__	  = (
										    SkewNode.merge(self._root.left	,				self._root.right  ) if self._root else None
										)

										return result
						def 					__A					( self				:					int  )							->					T:
										if not self._root:
														raise IndexError("Can't get top element for the empty heap."  )
										return self._root.value

						def 					__A					( self				:					int  )							->					None:
										__magic_name__	  = None


if __name__ == "__main__":
						import doctest

						doctest.testmod()







'''simple docstring'''
def      __snake_case       (       lowerCamelCase_ :				int = 100						):
				'''simple docstring'''




				__magic_name__	  = [[0 for _ in range(lowerCamelCase_						)] for _ in range(m + 1						)]
				for i in range(m + 1						):
								__magic_name__	  = 1

				for n in range(m + 1						):
								for k in range(1	,  lowerCamelCase_						):
												memo[n][k] += memo[n][k - 1]
												if n > k:
																memo[n][k] += memo[n - k - 1][k]

				return memo[m][m - 1] - 1


if __name__ == "__main__":
						print(solution(int(input('Enter a number: ').strip())))



