






from collections import deque






def 							A     (       a_					)     ->						List[Any]:
					__UpperCamelCase      :					Any       		=len(a_					)
					__UpperCamelCase      :					Union[str, Any]       		=deque()
					__UpperCamelCase      :					List[Any]       		=[False for _ in range(a_					)]
					__UpperCamelCase      :					Optional[Any]       		=[-1 for _ in range(a_					)]
					__UpperCamelCase      :					int       		=index_of[:]

					def strong_connect(a_							,a_							,a_					):
										__UpperCamelCase      :					Tuple       		=index  # the number when this node is seen
										__UpperCamelCase      :					Optional[int]       		=index  # lowest rank node reachable from here
										index += 1
										stack.append(a_					)
										__UpperCamelCase      :					Dict       		=True

										for w in g[v]:
															if index_of[w] == -1:
																				__UpperCamelCase      :					List[Any]       		=strong_connect(a_							,a_							,a_					)
																				__UpperCamelCase      :					int       		=(
																				    lowlink_of[w] if lowlink_of[w] < lowlink_of[v] else lowlink_of[v]
																				)
															elif on_stack[w]:
																				__UpperCamelCase      :					Optional[int]       		=(
																				    lowlink_of[w] if lowlink_of[w] < lowlink_of[v] else lowlink_of[v]
																				)

										if lowlink_of[v] == index_of[v]:
															__UpperCamelCase      :					Optional[Any]       		=[]
															__UpperCamelCase      :					Tuple       		=stack.pop()
															__UpperCamelCase      :					List[Any]       		=False
															component.append(a_					)
															while w != v:
																				__UpperCamelCase      :					List[str]       		=stack.pop()
																				__UpperCamelCase      :					List[str]       		=False
																				component.append(a_					)
															components.append(a_					)
										return index

					__UpperCamelCase      :					List[Any]       		=[]
					for v in range(a_					):
										if index_of[v] == -1:
															strong_connect(a_							,0							,a_					)

					return components






def 							A     (       a_							,a_					)     ->						Any:
					__UpperCamelCase      :					Any       		=[[] for _ in range(a_					)]
					for u, v in edges:
										g[u].append(a_					)
					return g


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

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




"""simple docstring"""


from numpy import exp, pi, sqrt






def     a__    (    __SCREAMING_SNAKE_CASE					, __SCREAMING_SNAKE_CASE = 0.0					, __SCREAMING_SNAKE_CASE = 1.0 )	->	int:
		return 1 / sqrt(2 * pi * sigma**2 ) * exp(-((x - mu) ** 2) / (2 * sigma**2) )


if __name__ == "__main__":
			import doctest

			doctest.testmod()


