
'''simple docstring'''







def 					snake_case_		(				__SCREAMING_SNAKE_CASE					: int      ,      __SCREAMING_SNAKE_CASE					: int							):



						"""simple docstring"""





						lowercase_	:     str													=       1  # To kept the Calculated Value
						# Since C(n, k) = C(n, n-k)
						if k > (n - k):
												lowercase_	:     Any													=       n - k
						# Calculate C(n,k)
						for i in range(__SCREAMING_SNAKE_CASE							):
												result *= n - i
												result //= i + 1
						return result
def 					snake_case_		(				__SCREAMING_SNAKE_CASE					: int							):



						"""simple docstring"""





						return binomial_coefficient(2 * node_count      ,      __SCREAMING_SNAKE_CASE							) // (node_count + 1)
def 					snake_case_		(				__SCREAMING_SNAKE_CASE					: int							):



						"""simple docstring"""





						if n < 0:
												raise ValueError('''factorial() not defined for negative values'''							)
						lowercase_	:     List[Any]													=       1
						for i in range(1      ,      n + 1							):
												result *= i
						return result
def 					snake_case_		(				__SCREAMING_SNAKE_CASE					: int							):



						"""simple docstring"""





						return catalan_number(__SCREAMING_SNAKE_CASE							) * factorial(__SCREAMING_SNAKE_CASE							)


if __name__ == "__main__":
							_lowercase :  Tuple    							=       int(input("Enter the number of nodes: ").strip() or 0)
							if node_count <= 0:
														raise ValueError("We need some nodes to work with.")
							print(
							    f"""Given {node_count} nodes, there are {binary_tree_count(node_count)} """
							    f"""binary trees and {catalan_number(node_count)} binary search trees."""
							)




import itertools
import string
from collections.abc import Generator, Iterable
def       A	(    _lowercase		,  _lowercase						):
						SCREAMING_SNAKE_CASE							:    Union[str, Any]							=							iter(_lowercase						)
						while True:
												SCREAMING_SNAKE_CASE							:    Optional[Any]							=							tuple(itertools.islice(_lowercase		,  _lowercase						)						)
												if not chunk:
																		return
												yield chunk
def       A	(    _lowercase						):
						SCREAMING_SNAKE_CASE							:    int							=							''''''.join([c.upper() for c in dirty if c in string.ascii_letters]						)
						SCREAMING_SNAKE_CASE							:    List[str]							=							''''''

						if len(_lowercase						) < 2:
												return dirty

						for i in range(len(_lowercase						) - 1						):
												clean += dirty[i]

												if dirty[i] == dirty[i + 1]:
																		clean += "X"

						clean += dirty[-1]

						if len(_lowercase						) & 1:
												clean += "X"

						return clean
def       A	(    _lowercase						):
						# I and J are used interchangeably to allow
						# us to use a 5x5 table (25 letters)
						SCREAMING_SNAKE_CASE							:    Optional[Any]							=							'''ABCDEFGHIKLMNOPQRSTUVWXYZ'''
						# we're using a list instead of a '2d' array because it makes the math
						# for setting up the table and doing the actual encoding/decoding simpler
						SCREAMING_SNAKE_CASE							:    List[Any]							=							[]

						# copy key chars into the table if they are in `alphabet` ignoring duplicates
						for char in key.upper():
												if char not in table and char in alphabet:
																		table.append(_lowercase						)

    # fill the rest of the table in with the remaining alphabet chars
						for char in alphabet:
												if char not in table:
																		table.append(_lowercase						)

						return table
def       A	(    _lowercase		,  _lowercase						):
						SCREAMING_SNAKE_CASE							:    Any							=							generate_table(_lowercase						)
						SCREAMING_SNAKE_CASE							:    Any							=							prepare_input(_lowercase						)
						SCREAMING_SNAKE_CASE							:    Union[str, Any]							=							''''''

						# https://en.wikipedia.org/wiki/Playfair_cipher#Description
						for chara, chara in chunker(_lowercase		,  2						):
												SCREAMING_SNAKE_CASE				,  SCREAMING_SNAKE_CASE							:    int							=							divmod(table.index(_lowercase						)		,  5						)
												SCREAMING_SNAKE_CASE				,  SCREAMING_SNAKE_CASE							:    Union[str, Any]							=							divmod(table.index(_lowercase						)		,  5						)

												if rowa == rowa:
																		ciphertext += table[rowa * 5 + (cola + 1) % 5]
																		ciphertext += table[rowa * 5 + (cola + 1) % 5]
												elif cola == cola:
																		ciphertext += table[((rowa + 1) % 5) * 5 + cola]
																		ciphertext += table[((rowa + 1) % 5) * 5 + cola]
												else:  # rectangle
																		ciphertext += table[rowa * 5 + cola]
																		ciphertext += table[rowa * 5 + cola]

						return ciphertext



def       A	(    _lowercase		,  _lowercase						):
						SCREAMING_SNAKE_CASE							:    Any							=							generate_table(_lowercase						)
						SCREAMING_SNAKE_CASE							:    List[Any]							=							''''''

						# https://en.wikipedia.org/wiki/Playfair_cipher#Description
						for chara, chara in chunker(_lowercase		,  2						):
												SCREAMING_SNAKE_CASE				,  SCREAMING_SNAKE_CASE							:    List[str]							=							divmod(table.index(_lowercase						)		,  5						)
												SCREAMING_SNAKE_CASE				,  SCREAMING_SNAKE_CASE							:    Optional[Any]							=							divmod(table.index(_lowercase						)		,  5						)

												if rowa == rowa:
																		plaintext += table[rowa * 5 + (cola - 1) % 5]
																		plaintext += table[rowa * 5 + (cola - 1) % 5]
												elif cola == cola:
																		plaintext += table[((rowa - 1) % 5) * 5 + cola]
																		plaintext += table[((rowa - 1) % 5) * 5 + cola]
												else:  # rectangle
																		plaintext += table[rowa * 5 + cola]
																		plaintext += table[rowa * 5 + cola]

						return plaintext





