






'''simple docstring'''

class      A     :






 """simple docstring"""





 def __init__(				self      ,  __lowerCAmelCase			):
       UpperCamelCase_					: int            =				val
       UpperCamelCase_					: List[Any]            =				None
       UpperCamelCase_					: List[Any]            =				None





 def 	_UpperCAmelCase							(				self      ,  __lowerCAmelCase			):
       if self.val:
             if val < self.val:
                   if self.left is None:
                         UpperCamelCase_					: List[str]            =				Node(__lowerCAmelCase			)
                   else:
                         self.left.insert(__lowerCAmelCase			)
             elif val > self.val:
                   if self.right is None:
                         UpperCamelCase_					: Dict            =				Node(__lowerCAmelCase			)
                   else:
                         self.right.insert(__lowerCAmelCase			)
       else:
             UpperCamelCase_					: Optional[int]            =				val






def 				snake_case       (  a_				:			Any     , a_				:			Dict						)							->					Any:





      """simple docstring"""

      if root:
            inorder(root.left     , a_						)
            res.append(root.val						)
            inorder(root.right     , a_						)



def 				snake_case       (  a_				:			str						)							->					Union[str, Any]:





      """simple docstring"""

      if len(a_						) == 0:
            return arr
      UpperCamelCase_					: Union[str, Any]            =				Node(arr[0]						)
      for i in range(1     , len(a_						)						):
            root.insert(arr[i]						)
      # Traverse BST in order.
      UpperCamelCase_					: List[Any]            =				[]
      inorder(a_     , a_						)
      return res


if __name__ == "__main__":
      print(tree_sort([10, 1, 3, 2, 9, 14, 13]))














'''simple docstring'''

from abc import ABC, abstractmethod
from argparse import ArgumentParser




class      A     (   SCREAMING_SNAKE_CASE__    ):






 """simple docstring"""





 @staticmethod
 @abstractmethod
 def 	_UpperCAmelCase							(				__lowerCAmelCase			):
       raise NotImplementedError()





 @abstractmethod
 def 	_UpperCAmelCase							(				self			):
       raise NotImplementedError()






