





"""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  (     snake_case_						:						str		)     ->str:



    '''simple docstring'''







    __A					:		Dict						=  Queue()
    __A					:		str						=  [False] * len(snake_case_		)
    __A					:		List[Any]						=  [-1] * len(snake_case_		)

    def bfs():
        while not queue.empty():
            __A					:		Union[str, Any]						=  queue.get()
            __A					:		Any						=  True

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

                if color[neighbour] == -1:
                    __A					:		Union[str, Any]						=  1 - color[u]
                    queue.put(snake_case_		)

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

        return True

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











"""simple docstring"""



import decimal







def 	__lowercase  (     )     ->int:



    '''simple docstring'''







    __A					:		List[str]						=  0
    __A					:		Tuple						=  decimal.Context(prec=105		)
    for i in range(2       ,100		):
        __A					:		int						=  decimal.Decimal(snake_case_		)
        __A					:		str						=  number.sqrt(snake_case_		)
        if len(str(snake_case_		)		) > 1:
            answer += int(str(snake_case_		)[0]		)
            __A					:		Optional[Any]						=  str(snake_case_		)[2:101]
            answer += sum(int(snake_case_		) for x in sqrt_number_str		)
    return answer


if __name__ == "__main__":
       import doctest

       doctest.testmod()
       print(f'''{solution() = }''')




