

from collections import deque




def 					_lowercase     (				a_				:					Any				)				->	List[Any]:




					'''simple docstring'''







					__magic_name__							=    len(a_				)
					__magic_name__							=    deque()
					__magic_name__							=    [False for _ in range(a_				)]
					__magic_name__							=    [-1 for _ in range(a_				)]
					__magic_name__							=    index_of[:]

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

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

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

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

					return components




def 					_lowercase     (				a_				:					int					,a_				:					Union[str, Any]				)				->	str:




					'''simple docstring'''







					__magic_name__							=    [[] for _ in range(a_				)]
					for u, v in edges:
										g[u].append(a_				)
					return g


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

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







from math import factorial, radians




def 					_lowercase     (				a_				:					float					,a_				:					int = 1_8					,a_				:					int = 1_0				)				->	float:




					'''simple docstring'''







					__magic_name__							=    angle_in_degrees - ((angle_in_degrees // 360.0) * 360.0)

					# Converting from degrees to radians
					__magic_name__							=    radians(a_				)

					__magic_name__							=    angle_in_radians
					__magic_name__							=    3
					__magic_name__							=    -1

					for _ in range(a_				):
										result += (b * (angle_in_radians**a)) / factorial(a_				)

										__magic_name__							=    -b  # One positive term and the next will be negative and so on...
										a += 2  # Increased by 2 for every term.

					return round(a_					,a_				)


if __name__ == "__main__":
						__import__("doctest").testmod()




