

from __future__ import annotations

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

_lowerCamelCase							=TypeVar("T", bound=bool)



class 						a_			(				Generic[T]	):



      """simple docstring"""







      def __init__( self	:				Optional[Any]     ,snake_case	:				T							):
           SCREAMING_SNAKE_CASE 		=value
           SCREAMING_SNAKE_CASE 		=None
           SCREAMING_SNAKE_CASE 		=None
      @property
      def 			_lowerCAmelCase	( self	:				Optional[Any]							):
           return self._value


      @staticmethod
      def 			_lowerCAmelCase	( snake_case	:				RandomizedHeapNode[T] | None     ,snake_case	:				RandomizedHeapNode[T] | None							):
           if not roota:
                return roota

           if not roota:
                return roota

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

           if random.choice([True, False]							):
                SCREAMING_SNAKE_CASE		,    SCREAMING_SNAKE_CASE 		=roota.right, roota.left

           SCREAMING_SNAKE_CASE 		=RandomizedHeapNode.merge(roota.left     ,snake_case							)

           return roota







class 						a_			(				Generic[T]	):



      """simple docstring"""







      def __init__( self	:				Union[str, Any]     ,snake_case	:				Iterable[T] | None = ()							):
           SCREAMING_SNAKE_CASE 		=None

           if data:
                for item in data:
                     self.insert(snake_case							)
      def 			_lowerCAmelCase	( self	:				Any     ,snake_case	:				T							):
           SCREAMING_SNAKE_CASE 		=RandomizedHeapNode.merge(self._root     ,RandomizedHeapNode(snake_case							)							)
      def 			_lowerCAmelCase	( self	:				Optional[int]							):
           SCREAMING_SNAKE_CASE 		=self.top()

           if self._root is None:
                return None

           SCREAMING_SNAKE_CASE 		=RandomizedHeapNode.merge(self._root.left     ,self._root.right							)

           return result
      def 			_lowerCAmelCase	( self	:				Optional[Any]							):
           if not self._root:
                raise IndexError('Can\'t get top element for the empty heap.'							)
           return self._root.value
      def 			_lowerCAmelCase	( self	:				Union[str, Any]							):
           SCREAMING_SNAKE_CASE 		=None
      def 			_lowerCAmelCase	( self	:				str							):
           SCREAMING_SNAKE_CASE 		=[]
           while self:
                result.append(self.pop()							)

           return result


      def __bool__( self	:				List[str]							):
           return self._root is not None


if __name__ == "__main__":
 import doctest

 doctest.testmod()




def      snake_case__							(  lowerCAmelCase_ = 100     ):





     """simple docstring"""







     SCREAMING_SNAKE_CASE 		=[[0 for _ in range(lowerCAmelCase_     )] for _ in range(m + 1     )]
     for i in range(m + 1     ):
          SCREAMING_SNAKE_CASE 		=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())))

