




'''simple docstring'''







def 		snake_case_							(_a			:							int  ):
    UpperCAmelCase     =	[[0 for _ in range(_a  )] for _ in range(m + 1  )]
    for i in range(m + 1  ):
        UpperCAmelCase     =	1

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

    return memo[m][m - 1]


if __name__ == "__main__":
   import sys

   if len(sys.argv) == 1:
      try:
         A									=int(input('Enter a number: ').strip())
         print(partition(n))
      except ValueError:
         print('Please enter a number.')
   else:
      try:
         A									=int(sys.argv[1])
         print(partition(n))
      except ValueError:
         print('Please pass a number.')










'''simple docstring'''







def 		snake_case_							(_a			:							list[list[int]]					,     _a			:							int					,     _a			:							int					,     _a			:							list[int]  ):

    # 1. Validate that path exists between current and next vertices
    if graph[path[curr_ind - 1]][next_ver] == 0:
        return False

    # 2. Validate that next vertex is not already in path
    return not any(vertex == next_ver for vertex in path  )





def 		snake_case_							(_a			:							list[list[int]]					,     _a			:							list[int]					,     _a			:							int  ):

    # Base Case
    if curr_ind == len(_a  ):
        # return whether path exists between current and starting vertices
        return graph[path[curr_ind - 1]][path[0]] == 1

    # Recursive Step
    for next_ver in range(0					,     len(_a  )  ):
        if valid_connection(_a					,     _a					,     _a					,     _a  ):
            # Insert current vertex  into path as next transition
            UpperCAmelCase     =	next_ver
            # Validate created path
            if util_hamilton_cycle(_a					,     _a					,     curr_ind + 1  ):
                return True
            # Backtrack
            UpperCAmelCase     =	-1
    return False







def 		snake_case_							(_a			:							list[list[int]]					,     _a			:							int = 0  ):
    UpperCAmelCase     =	[-1] * (len(_a  ) + 1)
    # initialize start and end of path with starting index
    UpperCAmelCase     =	UpperCAmelCase     =	start_index
    # evaluate and if we find answer return path either return empty array
    return path if util_hamilton_cycle(_a					,     _a					,     1  ) else []




