



"""simple docstring"""





from collections.abc import Iterable
from typing import Any




class 			lowercase__			:
							'''simple docstring'''







							def __init__(  self	,       snake_case = None						)			->							Tuple:
									_UpperCAmelCase							 =		value
									_UpperCAmelCase							 =		None  # Added in order to delete a node easier
									_UpperCAmelCase							 =		None
									_UpperCAmelCase							 =		None






							def __repr__(  self						)			->							Tuple:
									from pprint import pformat

									if self.left is None and self.right is None:
											return str(self.value						)
									return pformat({f'{self.value}': (self.left, self.right)}	,       indent=1						)







class 			lowercase__			:
							'''simple docstring'''







							def __init__(  self	,       snake_case = None						)			->							Union[str, Any]:
									_UpperCAmelCase							 =		root






							def __str__(  self						)			->							Union[str, Any]:
									return str(self.root						)






							def        lowerCamelCase_   (  self	,       snake_case	,       snake_case						)			->							Dict:
									if new_children is not None:  # reset its kids
											_UpperCAmelCase							 =		node.parent
									if node.parent is not None:  # reset its parent
											if self.is_right(__A						):  # If it is the right children
													_UpperCAmelCase							 =		new_children
											else:
													_UpperCAmelCase							 =		new_children
									else:
											_UpperCAmelCase							 =		new_children






							def        lowerCamelCase_   (  self	,       snake_case						)			->							Optional[int]:
									if node.parent and node.parent.right:
											return node == node.parent.right
									return False






							def        lowerCamelCase_   (  self						)			->							Optional[Any]:
									return self.root is None






							def        lowerCamelCase_   (  self	,       snake_case						)			->							Any:
									_UpperCAmelCase							 =		Node(__A						)  # create a new Node
									if self.empty():  # if Tree is empty
											_UpperCAmelCase							 =		new_node  # set its root
									else:  # Tree is not empty
											_UpperCAmelCase							 =		self.root  # from root
											if parent_node is None:
													return
											while True:  # While we don't get to a leaf
													if value < parent_node.value:  # We go left
															if parent_node.left is None:
																	_UpperCAmelCase							 =		new_node  # We insert the new node in a leaf
																	break
															else:
																	_UpperCAmelCase							 =		parent_node.left
													else:
															if parent_node.right is None:
																	_UpperCAmelCase							 =		new_node
																	break
															else:
																	_UpperCAmelCase							 =		parent_node.right
											_UpperCAmelCase							 =		parent_node






							def        lowerCamelCase_   (  self	,       *snake_case						)			->							List[str]:
									for value in values:
											self.__insert(__A						)






							def        lowerCamelCase_   (  self	,       snake_case						)			->							Any:
									if self.empty():
											raise IndexError('Warning: Tree is empty! please use another.'						)
									else:
											_UpperCAmelCase							 =		self.root
											# use lazy evaluation here to avoid NoneType Attribute error
											while node is not None and node.value is not value:
													_UpperCAmelCase							 =		node.left if value < node.value else node.right
											return node






							def        lowerCamelCase_   (  self	,       snake_case = None						)			->							Tuple:
									if node is None:
											if self.root is None:
													return None
											_UpperCAmelCase							 =		self.root

									if not self.empty():
											while node.right is not None:
													_UpperCAmelCase							 =		node.right
									return node






							def        lowerCamelCase_   (  self	,       snake_case = None						)			->							Optional[int]:
									if node is None:
											_UpperCAmelCase							 =		self.root
									if self.root is None:
											return None
									if not self.empty():
											_UpperCAmelCase							 =		self.root
											while node.left is not None:
													_UpperCAmelCase							 =		node.left
									return node






							def        lowerCamelCase_   (  self	,       snake_case						)			->							Optional[Any]:
									_UpperCAmelCase							 =		self.search(__A						)  # Look for the node with that label
									if node is not None:
											if node.left is None and node.right is None:  # If it has no children
													self.__reassign_nodes(__A	,       __A						)
											elif node.left is None:  # Has only right children
													self.__reassign_nodes(__A	,       node.right						)
											elif node.right is None:  # Has only left children
													self.__reassign_nodes(__A	,       node.left						)
											else:
													_UpperCAmelCase							 =		self.get_max(
													    node.left						)  # Gets the max value of the left branch
													self.remove(tmp_node.value						)  # type: ignore
													_UpperCAmelCase							 =		(
													    tmp_node.value  # type: ignore
													)  # Assigns the value to the node to delete and keep tree structure






							def        lowerCamelCase_   (  self	,       snake_case						)			->							Optional[int]:
									if node is not None:
											yield node  # Preorder Traversal
											yield from self.preorder_traverse(node.left						)
											yield from self.preorder_traverse(node.right						)






							def        lowerCamelCase_   (  self	,       snake_case=None						)			->							int:
									if traversal_function is None:
											return self.preorder_traverse(self.root						)
									else:
											return traversal_function(self.root						)






							def        lowerCamelCase_   (  self	,       snake_case	,       snake_case						)			->							Optional[Any]:
									if node:
											self.inorder(__A	,       node.left						)
											arr.append(node.value						)
											self.inorder(__A	,       node.right						)






							def        lowerCamelCase_   (  self	,       snake_case	,       snake_case						)			->							Dict:
									_UpperCAmelCase							 =		[]
									self.inorder(__A	,       __A						)  # append all values to list using inorder traversal
									return arr[k - 1]







def 	UpperCAmelCase     (		A	:						Node | None       ):

		'''simple docstring'''


		_UpperCAmelCase							 =		[]
		if curr_node is not None:
				_UpperCAmelCase							 =		postorder(curr_node.left       ) + postorder(curr_node.right       ) + [curr_node]
		return node_list




def 	UpperCAmelCase     (		):

		'''simple docstring'''


		_UpperCAmelCase							 =		(8, 3, 6, 1, 10, 14, 13, 4, 7)
		_UpperCAmelCase							 =		BinarySearchTree()
		for i in testlist:
				t.insert(snake_case_       )

		# Prints all the elements of the list in order traversal
		print(snake_case_       )

		if t.search(6       ) is not None:
				print('The value 6 exists'       )
		else:
				print('The value 6 doesn\'t exist'       )

		if t.search(-1       ) is not None:
				print('The value -1 exists'       )
		else:
				print('The value -1 doesn\'t exist'       )

		if not t.empty():
				print('Max Value: '     ,				t.get_max().value       )  # type: ignore
				print('Min Value: '     ,				t.get_min().value       )  # type: ignore

		for i in testlist:
				t.remove(snake_case_       )
				print(snake_case_       )


if __name__ == "__main__":
							import doctest

							doctest.testmod(verbose=True)







"""simple docstring"""





from itertools import permutations




def 	UpperCAmelCase     (		A	:						tuple       ):

		'''simple docstring'''


		if num[3] % 2 != 0:
				return False

		if (num[2] + num[3] + num[4]) % 3 != 0:
				return False

		if num[5] % 5 != 0:
				return False

		_UpperCAmelCase							 =		[7, 11, 13, 17]
		for i, test in enumerate(A       ):
				if (num[i + 4] * 100 + num[i + 5] * 10 + num[i + 6]) % test != 0:
						return False
		return True




def 	UpperCAmelCase     (		A	:						int = 10       ):

		'''simple docstring'''


		return sum(
		    int(''.join(map(A     ,				A       )       )       )
		    for num in permutations(range(A       )       )
		    if is_substring_divisible(A       )       )


if __name__ == "__main__":
					print(F'''{solution() = }''')


