





from __future__ import annotations

from collections.abc import Iterable
from dataclasses import dataclass
from typing import Any







class 						_lowerCAmelCase:

  """simple docstring"""







  lowerCamelCase__      					=   ('''_front''', '''_back''', '''_len''')







  @dataclass
  class 						_lowerCAmelCase:

    """simple docstring"""







    lowerCamelCase__      					=   None
    lowerCamelCase__      					=   None
    lowerCamelCase__      					=   None







  class 						_lowerCAmelCase:

    """simple docstring"""







    lowerCamelCase__      					=   ('''_cur''',)

    def __init__( self  ,    UpperCAmelCase     )-> None:
       __A				 =       cur

    def __iter__( self     )-> Deque._Iterator:
       return self





    def 		SCREAMING_SNAKE_CASE__	( self     )-> Any:
       if self._cur is None:
          # finished iterating
          raise StopIteration
       __A				 =       self._cur.val
       __A				 =       self._cur.next_node

       return val

  def __init__( self  ,    UpperCAmelCase = None     )-> None:
     __A				 =       None
     __A				 =       None
     __A				 =       0

     if iterable is not None:
        # append every value to the deque
        for val in iterable:
           self.append(UpperCAmelCase     )

  def 		SCREAMING_SNAKE_CASE__	( self  ,    UpperCAmelCase     )-> None:
     __A				 =       self._Node(UpperCAmelCase  ,    UpperCAmelCase  ,    UpperCAmelCase     )
     if self.is_empty():
        # front = back
        __A				 =       __A				 =       node
        __A				 =       1
     else:
        # connect nodes
        __A				 =       node
        __A				 =       self._back
        __A				 =       node  # assign new back to the new node

        self._len += 1

        # make sure there were no errors
        assert not self.is_empty(), "Error on appending value."

  def 		SCREAMING_SNAKE_CASE__	( self  ,    UpperCAmelCase     )-> None:
     __A				 =       self._Node(UpperCAmelCase  ,    UpperCAmelCase  ,    UpperCAmelCase     )
     if self.is_empty():
        # front = back
        __A				 =       __A				 =       node
        __A				 =       1
     else:
        # connect nodes
        __A				 =       self._front
        __A				 =       node
        __A				 =       node  # assign new front to the new node

        self._len += 1

        # make sure there were no errors
        assert not self.is_empty(), "Error on appending value."

  def 		SCREAMING_SNAKE_CASE__	( self  ,    UpperCAmelCase     )-> None:
     for val in iterable:
        self.append(UpperCAmelCase     )

  def 		SCREAMING_SNAKE_CASE__	( self  ,    UpperCAmelCase     )-> None:
     for val in iterable:
        self.appendleft(UpperCAmelCase     )

  def 		SCREAMING_SNAKE_CASE__	( self     )-> Any:
     assert not self.is_empty(), "Deque is empty."

     __A				 =       self._back
     __A				 =       self._back.prev_node  # set new back
     # drop the last node - python will deallocate memory automatically
     __A				 =       None

     self._len -= 1

     return topop.val

  def 		SCREAMING_SNAKE_CASE__	( self     )-> Any:
     assert not self.is_empty(), "Deque is empty."

     __A				 =       self._front
     __A				 =       self._front.next_node  # set new front and drop the first node
     __A				 =       None

     self._len -= 1

     return topop.val

  def 		SCREAMING_SNAKE_CASE__	( self     )-> bool:
     return self._front is None

  def __len__( self     )-> int:
     return self._len

  def __eq__( self  ,    UpperCAmelCase     )-> bool:

     if not isinstance(UpperCAmelCase  ,    UpperCAmelCase     ):
        return NotImplemented

     __A				 =       self._front
     __A				 =       other._front

     # if the length of the dequeues are not the same, they are not equal
     if len(self     ) != len(UpperCAmelCase     ):
        return False

     while me is not None and oth is not None:
        # compare every value
        if me.val != oth.val:
           return False
        __A				 =       me.next_node
        __A				 =       oth.next_node

     return True

  def __iter__( self     )-> Deque._Iterator:
     return Deque._Iterator(self._front     )





  def __repr__( self     )-> str:
     __A				 =       []
     __A				 =       self._front
     while aux is not None:
        # append the values in a list to display
        values_list.append(aux.val     )
        __A				 =       aux.next_node

     return f"[{', '.join(repr(UpperCAmelCase     ) for val in values_list     )}]"


if __name__ == "__main__":
    import doctest

    doctest.testmod()








def 				__UpperCamelCase  (		snake_case = 1_0_0     )  ->						int:


   '''simple docstring'''







   __A				 =       [[0 for _ in range(snake_case     )] for _ in range(m + 1     )]
   for i in range(m + 1     ):
      __A				 =       1

   for n in range(m + 1     ):
      for k in range(1    ,	snake_case     ):
         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())))

