code: 
  
  # 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        __SCREAMING_SNAKE_CASE    (      a__						:      Dict					)				->							Any:
  	__A   : Tuple								= Queue()
  	__A   : List[Any]								= [False] * len(a__					)
  	__A   : int								= [-1] * len(a__					)
  
  	def bfs():
  		while not queue.empty():
  			__A   : Any								= queue.get()
  			__A   : Tuple								= True
  
  			for neighbour in graph[u]:
  				if neighbour == u:
  					return False
  
  				if color[neighbour] == -1:
  					__A   : Dict								= 1 - color[u]
  					queue.put(a__					)
  
  				elif color[neighbour] == color[u]:
  					return False
  
  		return True
  
  	for i in range(len(a__					)					):
  		if not visited[i]:
  			queue.put(a__					)
  			__A   : List[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]}))
  
  
  
  
  
  
style_context: 
  
  UpperCAmelCase_       :				str		   =      [
      [0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0],
      [0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0],
      [0, 1, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0],
      [0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 0, 0],
      [0, 1, 0, 0, 1, 1, 0, 0, 1, 1, 1, 0, 0],
      [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0],
      [0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0],
      [0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0],
  ]
  def        __SCREAMING_SNAKE_CASE    (      a__						:      int ,a__						:      int ,a__						:      int ,a__						:      int					)				->							bool:
  	return 0 <= row < rows and 0 <= col < cols
  def        __SCREAMING_SNAKE_CASE    (      a__						:      int ,a__						:      int ,a__						:      set ,a__						:      list[list[int]]					)				->							int:
  	__A   : Union[str, Any]								= len(a__					)
  	__A   : Any								= len(mat[0]					)
  	if is_safe(a__ ,a__ ,a__ ,a__					) and (row, col) not in seen and mat[row][col] == 1:
  		seen.add((row, col)					)
  		return (
  		    1
  		    + depth_first_search(row + 1 ,a__ ,a__ ,a__					)
  		    + depth_first_search(row - 1 ,a__ ,a__ ,a__					)
  		    + depth_first_search(a__ ,col + 1 ,a__ ,a__					)
  		    + depth_first_search(a__ ,col - 1 ,a__ ,a__					)
  		)
  	else:
  		return 0
  def        __SCREAMING_SNAKE_CASE    (      a__						:      list[list[int]]					)				->							int:
  	__A   : set								= set()
  
  	__A   : Union[str, Any]								= 0
  	for row, line in enumerate(a__					):
  		for col, item in enumerate(a__					):
  			if item == 1 and (row, col) not in seen:
  				# Maximizing the area
  				__A   : Optional[Any]								= max(a__ ,depth_first_search(a__ ,a__ ,a__ ,a__					)					)
  	return max_area
  
  
  if __name__ == "__main__":
  			import doctest
  
  			print(find_max_area(matrix))  # Output -> 6
  			doctest.testmod()
  
  
  
  
  
  