



"""simple docstring"""





import unittest

from transformers.utils.backbone_utils import (
    BackboneMixin,
    get_aligned_output_features_output_indices,
    verify_out_features_out_indices,
)



class    _lowerCAmelCase    (				unittest.TestCase		):





		"""simple docstring"""






		def    UpperCAmelCase__							(					self   ) ->						List[Any]:







								'''simple docstring'''

								snake_case_   : int						=			["a", "b", "c"]

								# Defaults to last layer if both are None
								snake_case_   : Tuple						=			get_aligned_output_features_output_indices(a_							,    a_							,    a_   )
								self.assertEqual(a_							,    ["""c"""]   )
								self.assertEqual(a_							,    [2]   )

								# Out indices set to match out features
								snake_case_   : Optional[int]						=			get_aligned_output_features_output_indices(["""a""", """c"""]							,    a_							,    a_   )
								self.assertEqual(a_							,    ["""a""", """c"""]   )
								self.assertEqual(a_							,    [0, 2]   )

								# Out features set to match out indices
								snake_case_   : Tuple						=			get_aligned_output_features_output_indices(a_							,    [0, 2]							,    a_   )
								self.assertEqual(a_							,    ["""a""", """c"""]   )
								self.assertEqual(a_							,    [0, 2]   )

								# Out features selected from negative indices
								snake_case_   : Dict						=			get_aligned_output_features_output_indices(a_							,    [-3, -1]							,    a_   )
								self.assertEqual(a_							,    ["""a""", """c"""]   )
								self.assertEqual(a_							,    [-3, -1]   )





		def    UpperCAmelCase__							(					self   ) ->						List[str]:







								'''simple docstring'''

								with self.assertRaises(a_   ):
														verify_out_features_out_indices(["""a""", """b"""]							,    (0, 1)							,    a_   )

								# Out features must be a list
								with self.assertRaises(a_   ):
														verify_out_features_out_indices(("""a""", """b""")							,    (0, 1)							,    ["""a""", """b"""]   )

								# Out features must be a subset of stage names
								with self.assertRaises(a_   ):
														verify_out_features_out_indices(["""a""", """b"""]							,    (0, 1)							,    ["""a"""]   )

								# Out indices must be a list or tuple
								with self.assertRaises(a_   ):
														verify_out_features_out_indices(a_							,    0							,    ["""a""", """b"""]   )

								# Out indices must be a subset of stage names
								with self.assertRaises(a_   ):
														verify_out_features_out_indices(a_							,    (0, 1)							,    ["""a"""]   )

								# Out features and out indices must be the same length
								with self.assertRaises(a_   ):
														verify_out_features_out_indices(["""a""", """b"""]							,    (0,)							,    ["""a""", """b""", """c"""]   )

								# Out features should match out indices
								with self.assertRaises(a_   ):
														verify_out_features_out_indices(["""a""", """b"""]							,    (0, 2)							,    ["""a""", """b""", """c"""]   )

								# Out features and out indices should be in order
								with self.assertRaises(a_   ):
														verify_out_features_out_indices(["""b""", """a"""]							,    (0, 1)							,    ["""a""", """b"""]   )

								# Check passes with valid inputs
								verify_out_features_out_indices(["""a""", """b""", """d"""]							,    (0, 1, -1)							,    ["""a""", """b""", """c""", """d"""]   )





		def    UpperCAmelCase__							(					self   ) ->						Dict:







								'''simple docstring'''

								snake_case_   : List[Any]						=			BackboneMixin()

								snake_case_   : List[Any]						=			["a", "b", "c"]
								snake_case_   : Optional[int]						=			["a", "c"]
								snake_case_   : Dict						=			[0, 2]

								# Check that the output features and indices are set correctly
								self.assertEqual(backbone.out_features							,    ["""a""", """c"""]   )
								self.assertEqual(backbone.out_indices							,    [0, 2]   )

								# Check out features and indices are updated correctly
								snake_case_   : Union[str, Any]						=			["a", "b"]
								self.assertEqual(backbone.out_features							,    ["""a""", """b"""]   )
								self.assertEqual(backbone.out_indices							,    [0, 1]   )

								snake_case_   : str						=			[-3, -1]
								self.assertEqual(backbone.out_features							,    ["""a""", """c"""]   )
								self.assertEqual(backbone.out_indices							,    [-3, -1]   )






"""simple docstring"""





def 	__lowerCAmelCase						(		__UpperCamelCase      :			int					, __UpperCamelCase      :			int    ):


						'''simple docstring'''






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


						'''simple docstring'''






						return binomial_coefficient(2 * node_count					, __UpperCamelCase    ) // (node_count + 1)
def 	__lowerCAmelCase						(		__UpperCamelCase      :			int    ):


						'''simple docstring'''






						if n < 0:
												raise ValueError("""factorial() not defined for negative values"""    )
						snake_case_   : Optional[int]						=			1
						for i in range(1					, n + 1    ):
												result *= i
						return result
def 	__lowerCAmelCase						(		__UpperCamelCase      :			int    ):


						'''simple docstring'''






						return catalan_number(__UpperCamelCase    ) * factorial(__UpperCamelCase    )


if __name__ == "__main__":
					__lowerCAmelCase       :					Optional[Any]      					=					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.'''
					)

