


def        UpperCamelCase_(				_A   :Optional[Any]				,     _A   :Optional[Any]  )->		Optional[int]:
			assert x is not None
			assert y is not None

			UpperCamelCase__					=       len(lowerCamelCase__  )
			UpperCamelCase__					=       len(lowerCamelCase__  )

			# declaring the array for storing the dp values
			UpperCamelCase__					=       [[0] * (n + 1) for _ in range(m + 1  )]  # noqa: E741

			for i in range(1				,     m + 1  ):
						for j in range(1				,     n + 1  ):
									UpperCamelCase__					=       1 if x[i - 1] == y[j - 1] else 0

									UpperCamelCase__					=       max(l[i - 1][j]				,     l[i][j - 1]				,     l[i - 1][j - 1] + match  )

			UpperCamelCase__					=       ""
			UpperCamelCase__					=       m, n
			while i > 0 and j > 0:
						UpperCamelCase__					=       1 if x[i - 1] == y[j - 1] else 0

						if l[i][j] == l[i - 1][j - 1] + match:
									if match == 1:
												UpperCamelCase__					=       x[i - 1] + seq
									i -= 1
									j -= 1
						elif l[i][j] == l[i - 1][j]:
									i -= 1
						else:
									j -= 1

			return l[m][n], seq


if __name__ == "__main__":
						__UpperCamelCase    		=       "AGGTAB"
						__UpperCamelCase    		=       "GXTXAYB"
						__UpperCamelCase    		=       4
						__UpperCamelCase    		=       "GTAB"

						__UpperCamelCase    		=       longest_common_subsequence(a, b)
						print('len =', ln, ', sub-sequence =', subseq)
						import doctest

						doctest.testmod()






from collections import deque
def        UpperCamelCase_(				_A   :Union[str, Any]  )->		List[Any]:
			UpperCamelCase__					=       len(_A  )
			UpperCamelCase__					=       deque()
			UpperCamelCase__					=       [False for _ in range(_A  )]
			UpperCamelCase__					=       [-1 for _ in range(_A  )]
			UpperCamelCase__					=       index_of[:]

			def strong_connect(_A   :Optional[int]				,     _A   :Optional[int]				,     _A   :List[Any]  ):
						UpperCamelCase__					=       index  # the number when this node is seen
						UpperCamelCase__					=       index  # lowest rank node reachable from here
						index += 1
						stack.append(_A  )
						UpperCamelCase__					=       True

						for w in g[v]:
									if index_of[w] == -1:
												UpperCamelCase__					=       strong_connect(_A				,     _A				,     _A  )
												UpperCamelCase__					=       (
												    lowlink_of[w] if lowlink_of[w] < lowlink_of[v] else lowlink_of[v]
												)
									elif on_stack[w]:
												UpperCamelCase__					=       (
												    lowlink_of[w] if lowlink_of[w] < lowlink_of[v] else lowlink_of[v]
												)

						if lowlink_of[v] == index_of[v]:
									UpperCamelCase__					=       []
									UpperCamelCase__					=       stack.pop()
									UpperCamelCase__					=       False
									component.append(_A  )
									while w != v:
												UpperCamelCase__					=       stack.pop()
												UpperCamelCase__					=       False
												component.append(_A  )
									components.append(_A  )
						return index

			UpperCamelCase__					=       []
			for v in range(_A  ):
						if index_of[v] == -1:
									strong_connect(_A				,     0				,     _A  )

			return components
def        UpperCamelCase_(				_A   :Optional[Any]				,     _A   :Any  )->		Union[str, Any]:
			UpperCamelCase__					=       [[] for _ in range(_A  )]
			for u, v in edges:
						g[u].append(_A  )
			return g


if __name__ == "__main__":
						# Test
						__UpperCamelCase    		=       7
						__UpperCamelCase    		=       [0, 0, 1, 2, 3, 3, 4, 4, 6]
						__UpperCamelCase    		=       [1, 3, 2, 0, 1, 4, 5, 6, 5]
						__UpperCamelCase    		=       [(u, v) for u, v in zip(source, target)]
						__UpperCamelCase    		=       create_graph(n_vertices, edges)

						assert [[5], [6], [4], [3, 2, 1, 0]] == tarjan(g)


