
"""simple docstring"""




def       __UpperCAmelCase      (				__UpperCamelCase					,							__UpperCamelCase = 10_00					):
			if (not isinstance(__UpperCamelCase					,							__UpperCamelCase					)) or (digit_position <= 0):
						raise ValueError('''Digit position must be a positive integer'''					)
			elif (not isinstance(__UpperCamelCase					,							__UpperCamelCase					)) or (precision < 0):
						raise ValueError('''Precision must be a nonnegative integer'''					)

			# compute an approximation of (16 ** (n - 1)) * pi whose fractional part is mostly
			# accurate
			__lowercase	:       str				=   (
			    4 * _subsum(__UpperCamelCase					,							1					,							__UpperCamelCase					)
			    - 2 * _subsum(__UpperCamelCase					,							4					,							__UpperCamelCase					)
			    - _subsum(__UpperCamelCase					,							5					,							__UpperCamelCase					)
			    - _subsum(__UpperCamelCase					,							6					,							__UpperCamelCase					)
			)

			# return the first hex digit of the fractional part of the result
			return hex(int((sum_result % 1) * 16					)					)[2:]







def       __UpperCAmelCase      (				__UpperCamelCase					,							__UpperCamelCase					,							__UpperCamelCase					):
			__lowercase	:       List[Any]				=   0.0
			for sum_index in range(digit_pos_to_extract + precision					):
						__lowercase	:       Optional[int]				=   8 * sum_index + denominator_addend
						if sum_index < digit_pos_to_extract:
									# if the exponential term is an integer and we mod it by the denominator
									# before dividing, only the integer part of the sum will change;
									# the fractional part will not
									__lowercase	:       Dict				=   pow(
									    16					,							digit_pos_to_extract - 1 - sum_index					,							__UpperCamelCase					)
						else:
									__lowercase	:       Optional[Any]				=   pow(16					,							digit_pos_to_extract - 1 - sum_index					)
						total += exponential_term / denominator
			return total


if __name__ == "__main__":
			import doctest

			doctest.testmod()









"""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       __UpperCAmelCase      (				__UpperCamelCase					):
			__lowercase	:       int				=   Queue()
			__lowercase	:       str				=   [False] * len(__UpperCamelCase					)
			__lowercase	:       str				=   [-1] * len(__UpperCamelCase					)

			def bfs():
						while not queue.empty():
									__lowercase	:       int				=   queue.get()
									__lowercase	:       List[str]				=   True

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

												if color[neighbour] == -1:
															__lowercase	:       str				=   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					)
									__lowercase	:       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]}))



