



from collections import deque






def     a(      A       :    List[Any]       )		->       Tuple:
					"""simple docstring"""





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

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

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

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

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

					return components






def     a(      A       :    List[str] ,     A       :    Optional[Any]       )		->       Optional[int]:
					"""simple docstring"""





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


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

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





import cmath
import math






def     a(      A       :    float ,     A       :    float ,     A       :    float ,     A       :    float       )		->       complex:
					"""simple docstring"""





					a					     =   math.radians(A       )
					a					     =   math.radians(A       )

					# Convert voltage and current to rectangular form
					a					     =   cmath.rect(A ,     A       )
					a					     =   cmath.rect(A ,     A       )

					# Calculate apparent power
					return voltage_rect * current_rect


if __name__ == "__main__":
				import doctest

				doctest.testmod()
