


from __future__ import annotations

from typing import Generic, TypeVar

snake_case__      			=    TypeVar('''T''')


class        lowerCAmelCase_			(							Generic[T]):




						def __init__(						self    : Any ,  __A    : T    )   ->Optional[Any]:






									"""simple docstring"""






									a__			:Union[str, Any]    	=     data
									a__			:List[Any]    	=     self
									a__			:int    	=     0






class        lowerCAmelCase_			(							Generic[T]):




						def __init__(						self    : Optional[Any]    )   ->Tuple:






									"""simple docstring"""






									a__			:Dict    	=     {}




						def 			_snake_case       (						self    : Union[str, Any] ,  __A    : T    )   ->Any:






									"""simple docstring"""






									a__			:Tuple    	=     DisjointSetTreeNode(UpperCamelCase_    )




						def 			_snake_case       (						self    : List[Any] ,  __A    : T    )   ->List[str]:






									"""simple docstring"""






									a__			:int    	=     self.map[data]
									if elem_ref != elem_ref.parent:
												a__			:Any    	=     self.find_set(elem_ref.parent.data    )
									return elem_ref.parent




						def 			_snake_case       (						self    : int ,  __A    : DisjointSetTreeNode[T] ,  __A    : DisjointSetTreeNode[T]    )   ->Union[str, Any]:






									"""simple docstring"""






									if nodea.rank > nodea.rank:
												a__			:List[Any]    	=     nodea
									else:
												a__			:Tuple    	=     nodea
												if nodea.rank == nodea.rank:
															nodea.rank += 1






						def 			_snake_case       (						self    : Tuple ,  __A    : T ,  __A    : T    )   ->Tuple:






									"""simple docstring"""






									self.link(self.find_set(UpperCamelCase_    ) ,  self.find_set(UpperCamelCase_    )    )






class        lowerCAmelCase_			(							Generic[T]):




						def __init__(						self    : Optional[int]    )   ->str:






									"""simple docstring"""






									a__			:str    	=     {}




						def 			_snake_case       (						self    : int ,  __A    : T    )   ->str:






									"""simple docstring"""






									if node not in self.connections:
												a__			:Tuple    	=     {}




						def 			_snake_case       (						self    : Dict ,  __A    : T ,  __A    : T ,  __A    : int    )   ->Optional[Any]:






									"""simple docstring"""






									self.add_node(UpperCamelCase_    )
									self.add_node(UpperCamelCase_    )
									a__			:Optional[int]    	=     weight
									a__			:List[Any]    	=     weight






						def 			_snake_case       (						self    : Dict    )   ->Union[str, Any]:






									"""simple docstring"""






									a__			:Dict    	=     []
									a__			:int    	=     set()
									for start in self.connections:
												for end in self.connections[start]:
															if (start, end) not in seen:
																		seen.add((end, start)    )
																		edges.append((start, end, self.connections[start][end])    )
									edges.sort(key=lambda __A    : x[2]    )

									# creating the disjoint set
									a__			:Any    	=     DisjointSetTree[T]()
									for node in self.connections:
												disjoint_set.make_set(UpperCamelCase_    )

									# MST generation
									a__			:Tuple    	=     0
									a__			:str    	=     0
									a__			:Optional[Any]    	=     GraphUndirectedWeighted[T]()
									while num_edges < len(self.connections    ) - 1:
												a__	,	a__	,	a__			:Dict    	=     edges[index]
												index += 1
												a__			:List[str]    	=     disjoint_set.find_set(UpperCamelCase_    )
												a__			:List[Any]    	=     disjoint_set.find_set(UpperCamelCase_    )
												if parent_u != parent_v:
															num_edges += 1
															graph.add_edge(UpperCamelCase_ ,  UpperCamelCase_ ,  UpperCamelCase_    )
															disjoint_set.union(UpperCamelCase_ ,  UpperCamelCase_    )
									return graph










from __future__ import annotations



def       _SCREAMING_SNAKE_CASE    (			__lowercase :      list[int]      ,					__lowercase :      int     )    ->   bool:





    """simple docstring"""

    if len(__lowercase     ) == 0:
        return False
    __A       =						len(__lowercase     ) // 2
    if a_list[midpoint] == item:
        return True
    if item < a_list[midpoint]:
        return binary_search(a_list[:midpoint]      ,					__lowercase     )
    else:
        return binary_search(a_list[midpoint + 1 :]      ,					__lowercase     )


if __name__ == "__main__":
  __a   :							Tuple						= input("Enter numbers separated by comma:\n").strip()
  __a   :							Any						= [int(item.strip()) for item in user_input.split(",")]
  __a   :							List[Any]						= int(input("Enter the number to be found in the list:\n").strip())
  __a   :							Optional[int]						= "" if binary_search(sequence, target) else "not "
  print(f"""{target} was {not_str}found in {sequence}""")




