






"""simple docstring"""







from __future__ import annotations

import math


def      UpperCamelCase       ( _A )     ->       bool:

				if 1 < number < 4:
								# 2 and 3 are primes
								return True
				elif number < 2 or number % 2 == 0 or number % 3 == 0:
								# Negatives, 0, 1, all even numbers, all multiples of 3 are not primes
								return False

				# All primes number are in format of 6k +/- 1
				for i in range(5  ,				int(math.sqrt(_A ) + 1 )  ,				6 ):
								if number % i == 0 or number % (i + 2) == 0:
												return False
				return True


def      UpperCamelCase       ( _A )     ->       list[int]:
				lowercase    :      Tuple       = str(_A )
				lowercase    :      int       = [n]
				for i in range(1  ,				len(_A ) ):
								list_nums.append(int(str_num[i:] ) )
								list_nums.append(int(str_num[:-i] ) )
				return list_nums


def      UpperCamelCase       ( _A )     ->       bool:
				if len(str(_A ) ) > 3:
								if not is_prime(int(str(_A )[-3:] ) ) or not is_prime(int(str(_A )[:3] ) ):
												return False
				return True


def      UpperCamelCase       ( _A = 11 )     ->       list[int]:
				lowercase    :      list[int]       = []
				lowercase    :      int       = 13
				while len(_A ) != count:
								if validate(_A ):
												lowercase    :      List[str]       = list_truncated_nums(_A )
												if all(is_prime(_A ) for i in list_nums ):
																list_truncated_primes.append(_A )
								num += 2
				return list_truncated_primes


def      UpperCamelCase       ( )     ->       int:
				return sum(compute_truncated_primes(11 ) )


if __name__ == "__main__":
				print(F'{sum(compute_truncated_primes(11)) = }')








"""simple docstring"""







def      UpperCamelCase       ( _A  ,				_A )     ->       int:
				lowercase    :      int       = 1  # To kept the Calculated Value
				# Since C(n, k) = C(n, n-k)
				if k > (n - k):
								lowercase    :      List[Any]       = n - k
				# Calculate C(n,k)
				for i in range(_A ):
								result *= n - i
								result //= i + 1
				return result


def      UpperCamelCase       ( _A )     ->       int:
				return binomial_coefficient(2 * node_count  ,				_A ) // (node_count + 1)


def      UpperCamelCase       ( _A )     ->       int:
				if n < 0:
								raise ValueError("""factorial() not defined for negative values""" )
				lowercase    :      Union[str, Any]       = 1
				for i in range(1  ,				n + 1 ):
								result *= i
				return result


def      UpperCamelCase       ( _A )     ->       int:
				return catalan_number(_A ) * factorial(_A )


if __name__ == "__main__":
				_lowerCAmelCase            =	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.'
				)
