






class 						SCREAMING_SNAKE_CASE				:





							"""simple docstring"""

							def __init__(  self:   str		,     __A:   list[int]   )    ->				None:
												_A								= len(__A   )
												_A								= [0] * len_array

												if len_array > 0:
																	_A								= array[0]

												for i in range(1		,     __A   ):
																	_A								= self.prefix_sum[i - 1] + array[i]

							def       __A (  self:   Optional[int]		,     __A:   int		,     __A:   int   )    ->				int:
												if start == 0:
																	return self.prefix_sum[end]

												return self.prefix_sum[end] - self.prefix_sum[start - 1]



							def       __A (  self:   Optional[int]		,     __A:   int   )    ->				bool:
												_A								= {0}
												for sum_item in self.prefix_sum:
																	if sum_item - target_sum in sums:
																						return True

																	sums.add(__A   )

												return False


if __name__ == "__main__":
				import doctest

				doctest.testmod()











def      __A					(     _lowercase ):

					'''simple docstring'''







					_A								= [0] * len(_lowercase )
					_A								= []
					_A								= []
					_A								= 0

					for values in graph.values():
										for i in values:
															indegree[i] += 1

					for i in range(len(_lowercase ) ):
										if indegree[i] == 0:
															queue.append(_lowercase )

					while queue:
										_A								= queue.pop(0 )
										cnt += 1
										topo.append(_lowercase )
										for x in graph[vertex]:
															indegree[x] -= 1
															if indegree[x] == 0:
																				queue.append(_lowercase )

					if cnt != len(_lowercase ):
										print('''Cycle exists''' )
					else:
										print(_lowercase )


# Adjacency List of Graph
__A      =				{0: [1, 2], 1: [3], 2: [3], 3: [4, 5], 4: [], 5: []}


topological_sort(graph)



