


# 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 			_a      (    __UpperCamelCase			):
     a_     :  Optional[int]				      =     Queue()
     a_     :  Union[str, Any]				      =     [False] * len(__UpperCamelCase			)
     a_     :  Union[str, Any]				      =     [-1] * len(__UpperCamelCase			)

     def bfs():
          while not queue.empty():
               a_     :  Any				      =     queue.get()
               a_     :  Dict				      =     True

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

                    if color[neighbour] == -1:
                         a_     :  Optional[int]				      =     1 - color[u]
                         queue.put(__UpperCamelCase			)

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

          return True

     for i in range(len(__UpperCamelCase			)			):
          if not visited[i]:
               queue.put(__UpperCamelCase			)
               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]}))







def   a						(				SCREAMING_SNAKE_CASE_   :		int							):






       """simple docstring"""





       UpperCamelCase     :						Tuple 						=		[True for i in range(n + 1							)]
       UpperCamelCase     :						Tuple 						=		[i - 1 for i in range(n + 1							)]
       UpperCamelCase     :						Optional[Any] 						=		[]
       for i in range(2				,      n + 1							):
              if is_prime[i]:
                     primes.append(SCREAMING_SNAKE_CASE_							)
              for j in range(0				,      len(SCREAMING_SNAKE_CASE_							)							):
                     if i * primes[j] >= n:
                            break
                     UpperCamelCase     :						Any 						=		False

                     if i % primes[j] == 0:
                            UpperCamelCase     :						int 						=		totients[i] * primes[j]
                            break

                     UpperCamelCase     :						Dict 						=		totients[i] * (primes[j] - 1)

       return totients


if __name__ == "__main__":
  import doctest

  doctest.testmod()

