


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

__magic_name__   :   str  							=[2, 1, 4, 5, 6, 0, 8, 9, 1, 2, 0, 6, 4, 2, 0, 6, 5, 3, 2, 7]






class 		UpperCamelCase_		:





						"""simple docstring"""




						def __init__( self				:					List[str]	,				_lowerCamelCase				:					int  )							->					None:
										__magic_name__	  = -1
										__magic_name__	  = -1
										__magic_name__	  = [-1] * length
										__magic_name__	  = None
										__magic_name__	  = None

						def __repr__( self				:					Optional[Any]  )							->					str:
										return f'Node(min_value={self.minn} max_value={self.maxx})'





def      __snake_case       (       lowerCamelCase_ :				list[int]						):
				'''simple docstring'''




				__magic_name__	  = Node(len(lowerCamelCase_						)						)
				__magic_name__  ,      __magic_name__	  = min(lowerCamelCase_						), max(lowerCamelCase_						)
				# Leaf node case where the node contains only one unique value
				if root.minn == root.maxx:
								return root
				__magic_name__	  = (root.minn + root.maxx) // 2

				__magic_name__	  = []
				__magic_name__	  = []

				for index, num in enumerate(lowerCamelCase_						):
								if num <= pivot:
												left_arr.append(lowerCamelCase_						)
								else:
												right_arr.append(lowerCamelCase_						)
								__magic_name__	  = len(lowerCamelCase_						)
				__magic_name__	  = build_tree(lowerCamelCase_						)
				__magic_name__	  = build_tree(lowerCamelCase_						)
				return root




def      __snake_case       (       lowerCamelCase_ :				Node | None	,  lowerCamelCase_ :				int	,  lowerCamelCase_ :				int						):
				'''simple docstring'''




				if index < 0 or node is None:
								return 0
				# Leaf node cases
				if node.minn == node.maxx:
								return index + 1 if node.minn == num else 0
				__magic_name__	  = (node.minn + node.maxx) // 2
				if num <= pivot:
								# go the left subtree and map index to the left subtree
								return rank_till_index(node.left	,  lowerCamelCase_	,  node.map_left[index] - 1						)
				else:
								# go to the right subtree and map index to the right subtree
								return rank_till_index(node.right	,  lowerCamelCase_	,  index - node.map_left[index]						)




def      __snake_case       (       lowerCamelCase_ :				Node | None	,  lowerCamelCase_ :				int	,  lowerCamelCase_ :				int	,  lowerCamelCase_ :				int						):
				'''simple docstring'''




				if start > end:
								return 0
				__magic_name__	  = rank_till_index(lowerCamelCase_	,  lowerCamelCase_	,  lowerCamelCase_						)
				__magic_name__	  = rank_till_index(lowerCamelCase_	,  lowerCamelCase_	,  start - 1						)
				return rank_till_end - rank_before_start




def      __snake_case       (       lowerCamelCase_ :				Node | None	,  lowerCamelCase_ :				int	,  lowerCamelCase_ :				int	,  lowerCamelCase_ :				int						):
				'''simple docstring'''




				if index > (end - start) or start > end or node is None:
								return -1
				# Leaf node case
				if node.minn == node.maxx:
								return node.minn
				# Number of elements in the left subtree in interval [start, end]
				__magic_name__	  = node.map_left[end] - (
				    node.map_left[start - 1] if start else 0
				)
				if num_elements_in_left_tree > index:
								return quantile(
								    node.left	,  lowerCamelCase_	,  (node.map_left[start - 1] if start else 0)	,  node.map_left[end] - 1	,  )
				else:
								return quantile(
								    node.right	,  index - num_elements_in_left_tree	,  start - (node.map_left[start - 1] if start else 0)	,  end - node.map_left[end]	,  )




def      __snake_case       (       lowerCamelCase_ :				Node | None	,  lowerCamelCase_ :				int	,  lowerCamelCase_ :				int	,  lowerCamelCase_ :				int	,  lowerCamelCase_ :				int						):
				'''simple docstring'''




				if (
				    start > end
				    or node is None
				    or start_num > end_num
				    or node.minn > end_num
				    or node.maxx < start_num
				):
								return 0
				if start_num <= node.minn and node.maxx <= end_num:
								return end - start + 1
				__magic_name__	  = range_counting(
				    node.left	,  (node.map_left[start - 1] if start else 0)	,  node.map_left[end] - 1	,  lowerCamelCase_	,  lowerCamelCase_	,  )
				__magic_name__	  = range_counting(
				    node.right	,  start - (node.map_left[start - 1] if start else 0)	,  end - node.map_left[end]	,  lowerCamelCase_	,  lowerCamelCase_	,  )
				return left + right


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())))



