






"""simple docstring"""







# A Bipartite Graph is a graph whose vertices can be divided into two independent sets,
# U and V such that every edge (u, v) either connects a vertex from U to V or a vertex
# from V to U. In other words, for every edge (u, v), either u belongs to U and v to V,
# or u belongs to V and v to U. We can also say that there is no edge that connects
# vertices of same set.
from queue import Queue





def 						lowercase__(A						)				->Union[str, Any]:




						"""simple docstring"""



						lowercase__				:      Optional[Any]=       Queue()
						lowercase__				:      str=       [False] * len(lowercase_						)
						lowercase__				:      List[Any]=       [-1] * len(lowercase_						)

						def bfs():
												while not queue.empty():
																		lowercase__				:      Tuple=       queue.get()
																		lowercase__				:      Dict=       True

																		for neighbour in graph[u]:
																								if neighbour == u:
																														return False

																								if color[neighbour] == -1:
																														lowercase__				:      Tuple=       1 - color[u]
																														queue.put(lowercase_						)

																								elif color[neighbour] == color[u]:
																														return False

												return True

						for i in range(len(lowercase_						)						):
												if not visited[i]:
																		queue.put(lowercase_						)
																		lowercase__				:      Union[str, Any]=       0
																		if bfs() is False:
																								return False

						return True


if __name__ == "__main__":
			# Adjacency List of graph
			print(check_bipartite({0: [1, 3], 1: [0, 2], 2: [1, 3], 3: [0, 2]}))









from typing import Callable



def    UpperCamelCase(					lowercase_							)	->				List[str]:





  '''simple docstring'''





  def wrapper(lowercase_							):
    snake_case_       						=      function_with_docstring.__doc__
    return target_function

  return wrapper