code: 
  
  
  from __future__ import annotations
  
  import unittest
  from collections.abc import Iterator
  
  
  
  
  
  
  
  class 				__SCREAMING_SNAKE_CASE   :
  
  
        def __init__(							self							,						SCREAMING_SNAKE_CASE__							,						SCREAMING_SNAKE_CASE__		):
              lowercase			:   Optional[Any]					   =		label
              lowercase			:   Union[str, Any]					   =		parent
              lowercase			:   Node | None					   =		None
              lowercase			:   Node | None					   =		None
  
  
  
  
  
  
  
  class 				__SCREAMING_SNAKE_CASE   :
  
  
        def __init__(							self		):
              lowercase			:   Node | None					   =		None
  
  
        def        __lowerCamelCase			(							self		):
              lowercase			:   Optional[Any]					   =		None
  
  
        def        __lowerCamelCase			(							self		):
              return self.root is None
  
  
        def        __lowerCamelCase			(							self							,						SCREAMING_SNAKE_CASE__		):
              lowercase			:   Union[str, Any]					   =		self._put(self.root							,						SCREAMING_SNAKE_CASE__		)
  
  
        def        __lowerCamelCase			(							self							,						SCREAMING_SNAKE_CASE__							,						SCREAMING_SNAKE_CASE__							,						SCREAMING_SNAKE_CASE__ = None		):
              if node is None:
                    lowercase			:   Tuple					   =		Node(SCREAMING_SNAKE_CASE__							,						SCREAMING_SNAKE_CASE__		)
              else:
                    if label < node.label:
                          lowercase			:   List[str]					   =		self._put(node.left							,						SCREAMING_SNAKE_CASE__							,						SCREAMING_SNAKE_CASE__		)
                    elif label > node.label:
                          lowercase			:   List[Any]					   =		self._put(node.right							,						SCREAMING_SNAKE_CASE__							,						SCREAMING_SNAKE_CASE__		)
                    else:
                          lowercase			:   Any					   =		f"""Node with label {label} already exists"""
                          raise Exception(SCREAMING_SNAKE_CASE__		)
  
              return node
  
  
        def        __lowerCamelCase			(							self							,						SCREAMING_SNAKE_CASE__		):
              return self._search(self.root							,						SCREAMING_SNAKE_CASE__		)
  
  
        def        __lowerCamelCase			(							self							,						SCREAMING_SNAKE_CASE__							,						SCREAMING_SNAKE_CASE__		):
              if node is None:
                    lowercase			:   Optional[int]					   =		f"""Node with label {label} does not exist"""
                    raise Exception(SCREAMING_SNAKE_CASE__		)
              else:
                    if label < node.label:
                          lowercase			:   Optional[int]					   =		self._search(node.left							,						SCREAMING_SNAKE_CASE__		)
                    elif label > node.label:
                          lowercase			:   Tuple					   =		self._search(node.right							,						SCREAMING_SNAKE_CASE__		)
  
              return node
  
  
        def        __lowerCamelCase			(							self							,						SCREAMING_SNAKE_CASE__		):
              lowercase			:   str					   =		self.search(SCREAMING_SNAKE_CASE__		)
              if node.right and node.left:
                    lowercase			:   Union[str, Any]					   =		self._get_lowest_node(node.right		)
                    lowercase			:   Union[str, Any]					   =		node.left
                    lowercase			:   List[str]					   =		node.right
                    lowercase			:   Tuple					   =		lowest_node
                    if node.right:
                          lowercase			:   Any					   =		lowest_node
                    self._reassign_nodes(SCREAMING_SNAKE_CASE__							,						SCREAMING_SNAKE_CASE__		)
              elif not node.right and node.left:
                    self._reassign_nodes(SCREAMING_SNAKE_CASE__							,						node.left		)
              elif node.right and not node.left:
                    self._reassign_nodes(SCREAMING_SNAKE_CASE__							,						node.right		)
              else:
                    self._reassign_nodes(SCREAMING_SNAKE_CASE__							,						SCREAMING_SNAKE_CASE__		)
  
  
        def        __lowerCamelCase			(							self							,						SCREAMING_SNAKE_CASE__							,						SCREAMING_SNAKE_CASE__		):
              if new_children:
                    lowercase			:   str					   =		node.parent
  
              if node.parent:
                    if node.parent.right == node:
                          lowercase			:   int					   =		new_children
                    else:
                          lowercase			:   str					   =		new_children
              else:
                    lowercase			:   Optional[int]					   =		new_children
  
  
        def        __lowerCamelCase			(							self							,						SCREAMING_SNAKE_CASE__		):
              if node.left:
                    lowercase			:   Dict					   =		self._get_lowest_node(node.left		)
              else:
                    lowercase			:   int					   =		node
                    self._reassign_nodes(SCREAMING_SNAKE_CASE__							,						node.right		)
  
              return lowest_node
  
  
        def        __lowerCamelCase			(							self							,						SCREAMING_SNAKE_CASE__		):
              try:
                    self.search(SCREAMING_SNAKE_CASE__		)
                    return True
              except Exception:
                    return False
  
  
        def        __lowerCamelCase			(							self		):
              if self.root is None:
                    raise Exception('''Binary search tree is empty'''		)
  
              lowercase			:   List[str]					   =		self.root
              while node.right is not None:
                    lowercase			:   Optional[int]					   =		node.right
  
              return node.label
  
  
        def        __lowerCamelCase			(							self		):
              if self.root is None:
                    raise Exception('''Binary search tree is empty'''		)
  
              lowercase			:   Optional[int]					   =		self.root
              while node.left is not None:
                    lowercase			:   Union[str, Any]					   =		node.left
  
              return node.label
  
  
        def        __lowerCamelCase			(							self		):
              return self._inorder_traversal(self.root		)
  
  
        def        __lowerCamelCase			(							self							,						SCREAMING_SNAKE_CASE__		):
              if node is not None:
                    yield from self._inorder_traversal(node.left		)
                    yield node
                    yield from self._inorder_traversal(node.right		)
  
  
        def        __lowerCamelCase			(							self		):
              return self._preorder_traversal(self.root		)
  
  
  
  
  
  
        def        __lowerCamelCase			(							self							,						SCREAMING_SNAKE_CASE__		):
              if node is not None:
                    yield node
                    yield from self._preorder_traversal(node.left		)
                    yield from self._preorder_traversal(node.right		)
  
  
  
  
  
  
  
  class 				__SCREAMING_SNAKE_CASE   (			unittest.TestCase   ):
  
  
        @staticmethod
        def        __lowerCamelCase			(							):
              lowercase			:   Optional[Any]					   =		BinarySearchTree()
              t.put(8		)
              t.put(3		)
              t.put(6		)
              t.put(1		)
              t.put(10		)
              t.put(14		)
              t.put(13		)
              t.put(4		)
              t.put(7		)
              t.put(5		)
  
              return t
  
  
        def        __lowerCamelCase			(							self		):
              lowercase			:   Optional[int]					   =		BinarySearchTree()
              assert t.is_empty()
  
              t.put(8		)
              assert t.root is not None
              assert t.root.parent is None
              assert t.root.label == 8
  
              t.put(10		)
              assert t.root.right is not None
              assert t.root.right.parent == t.root
              assert t.root.right.label == 10
  
              t.put(3		)
              assert t.root.left is not None
              assert t.root.left.parent == t.root
              assert t.root.left.label == 3
  
              t.put(6		)
              assert t.root.left.right is not None
              assert t.root.left.right.parent == t.root.left
              assert t.root.left.right.label == 6
  
              t.put(1		)
              assert t.root.left.left is not None
              assert t.root.left.left.parent == t.root.left
              assert t.root.left.left.label == 1
  
              with self.assertRaises(SCREAMING_SNAKE_CASE__		):  # noqa: B017
                    t.put(1		)
  
  
        def        __lowerCamelCase			(							self		):
              lowercase			:   Optional[int]					   =		self._get_binary_search_tree()
  
              lowercase			:   List[str]					   =		t.search(6		)
              assert node.label == 6
  
              lowercase			:   Union[str, Any]					   =		t.search(13		)
              assert node.label == 13
  
              with self.assertRaises(SCREAMING_SNAKE_CASE__		):  # noqa: B017
                    t.search(2		)
  
  
        def        __lowerCamelCase			(							self		):
              lowercase			:   Dict					   =		self._get_binary_search_tree()
  
              t.remove(13		)
              assert t.root is not None
              assert t.root.right is not None
              assert t.root.right.right is not None
              assert t.root.right.right.right is None
              assert t.root.right.right.left is None
  
              t.remove(7		)
              assert t.root.left is not None
              assert t.root.left.right is not None
              assert t.root.left.right.left is not None
              assert t.root.left.right.right is None
              assert t.root.left.right.left.label == 4
  
              t.remove(6		)
              assert t.root.left.left is not None
              assert t.root.left.right.right is not None
              assert t.root.left.left.label == 1
              assert t.root.left.right.label == 4
              assert t.root.left.right.right.label == 5
              assert t.root.left.right.left is None
              assert t.root.left.left.parent == t.root.left
              assert t.root.left.right.parent == t.root.left
  
              t.remove(3		)
              assert t.root is not None
              assert t.root.left.label == 4
              assert t.root.left.right.label == 5
              assert t.root.left.left.label == 1
              assert t.root.left.parent == t.root
              assert t.root.left.left.parent == t.root.left
              assert t.root.left.right.parent == t.root.left
  
              t.remove(4		)
              assert t.root.left is not None
              assert t.root.left.left is not None
              assert t.root.left.label == 5
              assert t.root.left.right is None
              assert t.root.left.left.label == 1
              assert t.root.left.parent == t.root
              assert t.root.left.left.parent == t.root.left
  
  
        def        __lowerCamelCase			(							self		):
              lowercase			:   int					   =		self._get_binary_search_tree()
  
              t.remove(3		)
              assert t.root is not None
              assert t.root.left is not None
              assert t.root.left.left is not None
              assert t.root.left.right is not None
              assert t.root.left.right.left is not None
              assert t.root.left.right.right is not None
              assert t.root.left.label == 4
              assert t.root.left.right.label == 6
              assert t.root.left.left.label == 1
              assert t.root.left.right.right.label == 7
              assert t.root.left.right.left.label == 5
              assert t.root.left.parent == t.root
              assert t.root.left.right.parent == t.root.left
              assert t.root.left.left.parent == t.root.left
              assert t.root.left.right.left.parent == t.root.left.right
  
  
        def        __lowerCamelCase			(							self		):
              lowercase			:   List[Any]					   =		self._get_binary_search_tree()
              t.empty()
              assert t.root is None
  
  
        def        __lowerCamelCase			(							self		):
              lowercase			:   int					   =		self._get_binary_search_tree()
              assert not t.is_empty()
  
              t.empty()
              assert t.is_empty()
  
  
        def        __lowerCamelCase			(							self		):
              lowercase			:   List[str]					   =		self._get_binary_search_tree()
  
              assert t.exists(6		)
              assert not t.exists(-1		)
  
  
        def        __lowerCamelCase			(							self		):
              lowercase			:   str					   =		self._get_binary_search_tree()
  
              assert t.get_max_label() == 14
  
              t.empty()
              with self.assertRaises(SCREAMING_SNAKE_CASE__		):  # noqa: B017
                    t.get_max_label()
  
  
        def        __lowerCamelCase			(							self		):
              lowercase			:   Tuple					   =		self._get_binary_search_tree()
  
              assert t.get_min_label() == 1
  
              t.empty()
              with self.assertRaises(SCREAMING_SNAKE_CASE__		):  # noqa: B017
                    t.get_min_label()
  
  
        def        __lowerCamelCase			(							self		):
              lowercase			:   Any					   =		self._get_binary_search_tree()
  
              lowercase			:   Optional[Any]					   =		[i.label for i in t.inorder_traversal()]
              assert inorder_traversal_nodes == [1, 3, 4, 5, 6, 7, 8, 10, 13, 14]
  
  
  
  
  
  
        def        __lowerCamelCase			(							self		):
              lowercase			:   str					   =		self._get_binary_search_tree()
  
              lowercase			:   Dict					   =		[i.label for i in t.preorder_traversal()]
              assert preorder_traversal_nodes == [8, 3, 1, 6, 4, 5, 7, 10, 14, 13]
  
  
  
  
  
  def 			__lowercase	(						)    ->None:
  
  
  
  
  
  
  
        """simple docstring"""
  
        lowercase			:   Tuple					   =		BinarySearchTree()
        t.put(8     )
        t.put(3     )
        t.put(6     )
        t.put(1     )
        t.put(10     )
        t.put(14     )
        t.put(13     )
        t.put(4     )
        t.put(7     )
        t.put(5     )
  
        print(
            '''
              8
             / \\
            3   10
           / \\    \\
          1   6    14
             / \\   /
            4   7 13
             \\
              5
          '''     )
  
        print('''Label 6 exists:''',    t.exists(6     )     )
        print('''Label 13 exists:''',    t.exists(13     )     )
        print('''Label -1 exists:''',    t.exists(-1     )     )
        print('''Label 12 exists:''',    t.exists(12     )     )
  
        # Prints all the elements of the list in inorder traversal
        lowercase			:   str					   =		[i.label for i in t.inorder_traversal()]
        print('''Inorder traversal:''',    _UpperCamelCase     )
  
        # Prints all the elements of the list in preorder traversal
        lowercase			:   Dict					   =		[i.label for i in t.preorder_traversal()]
        print('''Preorder traversal:''',    _UpperCamelCase     )
  
        print('''Max. label:''',    t.get_max_label()     )
        print('''Min. label:''',    t.get_min_label()     )
  
        # Delete elements
        print('''\nDeleting elements 13, 10, 8, 3, 6, 14'''     )
        print(
            '''
            4
           / \\
          1   7
               \\
                5
          '''     )
        t.remove(13     )
        t.remove(10     )
        t.remove(8     )
        t.remove(3     )
        t.remove(6     )
        t.remove(14     )
  
        # Prints all the elements of the list in inorder traversal after delete
        lowercase			:   List[str]					   =		[i.label for i in t.inorder_traversal()]
        print('''Inorder traversal after delete:''',    _UpperCamelCase     )
  
        # Prints all the elements of the list in preorder traversal after delete
        lowercase			:   int					   =		[i.label for i in t.preorder_traversal()]
        print('''Preorder traversal after delete:''',    _UpperCamelCase     )
  
        print('''Max. label:''',    t.get_max_label()     )
        print('''Min. label:''',    t.get_min_label()     )
  
  
  if __name__ == "__main__":
    binary_search_tree_example()
  
style_context: 
  
  
  from __future__ import annotations
  
  
  
  
  def 			__lowercase	(						_UpperCamelCase     )    ->list[int]:
  
  
  
  
  
  
  
        """simple docstring"""
  
        assert (
            isinstance(_UpperCamelCase,    _UpperCamelCase     ) and mask > 0
        ), f"""mask needs to be positive integer, your input {mask}"""
        lowercase			:   Optional[int]					   =		[]
        lowercase			:   Optional[int]					   =		mask
  
        while submask:
              all_submasks.append(_UpperCamelCase     )
              lowercase			:   Dict					   =		(submask - 1) & mask
  
        return all_submasks
  
  
  if __name__ == "__main__":
    import doctest
  
    doctest.testmod()
  
  