



class 		snake_case						:



   '''simple docstring'''






   def __init__(					self							:			int				,		lowerCAmelCase							:			int)				->				Optional[Any]:

    """simple docstring"""







    _snake_case    :  Optional[int]					=					n
    _snake_case    :  List[Any]					=					[None] * self.n
    _snake_case    :  Optional[Any]					=					0  # index of the first element
    _snake_case    :  List[Any]					=					0
    _snake_case    :  Any					=					0

   def __len__(					self							:			Any)				->				int:

    """simple docstring"""







    return self.size

   def      UpperCamelCase_  (					self							:			Tuple)				->				bool:

    """simple docstring"""







    return self.size == 0

   def      UpperCamelCase_  (					self							:			Dict)				->				Dict:

    """simple docstring"""







    return False if self.is_empty() else self.array[self.front]

   def      UpperCamelCase_  (					self							:			str				,		lowerCAmelCase							:			Any)				->				List[str]:

    """simple docstring"""







    if self.size >= self.n:
     raise Exception("""QUEUE IS FULL""")

    _snake_case    :  Dict					=					data
    _snake_case    :  Optional[Any]					=					(self.rear + 1) % self.n
    self.size += 1
    return self


   def      UpperCamelCase_  (					self							:			Optional[Any])				->				Dict:

    """simple docstring"""







    if self.size == 0:
     raise Exception("""UNDERFLOW""")

    _snake_case    :  Union[str, Any]					=					self.array[self.front]
    _snake_case    :  Any					=					None
    _snake_case    :  Any					=					(self.front + 1) % self.n
    self.size -= 1
    return temp





# 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.



def       lowercase       (   SCREAMING_SNAKE_CASE__       :	Dict				)  ->     Union[str, Any]:
 _snake_case    :  str					=					[False] * len(SCREAMING_SNAKE_CASE__				)
 _snake_case    :  Dict					=					[-1] * len(SCREAMING_SNAKE_CASE__				)

 def dfs(SCREAMING_SNAKE_CASE__       :	Optional[int]				,       SCREAMING_SNAKE_CASE__       :	Union[str, Any]				):
  _snake_case    :  Optional[Any]					=					True
  _snake_case    :  Tuple					=					c
  for u in graph[v]:
   if not visited[u]:
    dfs(SCREAMING_SNAKE_CASE__				,       1 - c				)

 for i in range(len(SCREAMING_SNAKE_CASE__				)				):
  if not visited[i]:
   dfs(SCREAMING_SNAKE_CASE__				,       0				)

 for i in range(len(SCREAMING_SNAKE_CASE__				)				):
  for j in graph[i]:
   if color[i] == color[j]:
    return False

 return True


# Adjacency list of graph
a__    =	{0: [1, 3], 1: [0, 2], 2: [1, 3], 3: [0, 2], 4: []}

print(check_bipartite_dfs(graph))
