


from __future__ import annotations

from fractions import Fraction
def 							UpperCamelCase_(					_A :int					,  _A :int	)->		bool:
			return (
			    num != den and num % 10 == den // 10 and (num // 10) / (den % 10) == num / den
			)
def 							UpperCamelCase_(					_A :int	)->		list[str]:
			UpperCamelCase__       =							[]
			UpperCamelCase__       =							11
			UpperCamelCase__       =							int("1" + "0" * digit_len	)
			for num in range(_A					,  _A	):
						while den <= 99:
									if (num != den) and (num % 10 == den // 10) and (den % 10 != 0):
												if is_digit_cancelling(_A					,  _A	):
															solutions.append(F'''{num}/{den}'''	)
									den += 1
						num += 1
						UpperCamelCase__       =							10
			return solutions
def 							UpperCamelCase_(					_A :int = 2	)->		int:
			UpperCamelCase__       =							1.0
			for fraction in fraction_list(_A	):
						UpperCamelCase__       =							Fraction(_A	)
						result *= frac.denominator / frac.numerator
			return int(_A	)


if __name__ == "__main__":
						print(solution())






def 							UpperCamelCase_(					_A :Union[str, Any]	)->		List[str]:
			UpperCamelCase__       =							[0] * len(_A	)
			UpperCamelCase__       =							[]
			UpperCamelCase__       =							[]
			UpperCamelCase__       =							0

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

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

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

			if cnt != len(_A	):
						print("Cycle exists"	)
			else:
						print(_A	)


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







topological_sort(graph)


