






'''simple docstring'''







from collections import deque
def 						A__			(				__lowerCAmelCase		:			Optional[int]						):
						lowerCamelCase__         =  len(__lowerCAmelCase						)
						lowerCamelCase__         =  deque()
						lowerCamelCase__         =  [False for _ in range(__lowerCAmelCase						)]
						lowerCamelCase__         =  [-1 for _ in range(__lowerCAmelCase						)]
						lowerCamelCase__         =  index_of[:]

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

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

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

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

						return components
def 						A__			(				__lowerCAmelCase		:			Optional[Any]   ,    __lowerCAmelCase		:			Union[str, Any]						):
						lowerCamelCase__         =  [[] for _ in range(__lowerCAmelCase						)]
						for u, v in edges:
												g[u].append(__lowerCAmelCase						)
						return g


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

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









'''simple docstring'''







from __future__ import annotations

import math
def 						A__			(				__lowerCAmelCase		:			int						):

						if 1 < number < 4:
												# 2 and 3 are primes
												return True
						elif number < 2 or number % 2 == 0 or number % 3 == 0:
												# Negatives, 0, 1, all even numbers, all multiples of 3 are not primes
												return False

						# All primes number are in format of 6k +/- 1
						for i in range(5   ,    int(math.sqrt(__lowerCAmelCase						) + 1						)   ,    6						):
												if number % i == 0 or number % (i + 2) == 0:
																		return False
						return True


UpperCamelCase    :      str  			=		[num for num in range(3, 10_00_01, 2) if not is_prime(num)]
def 						A__			(				__lowerCAmelCase		:			int						):
						if not isinstance(__lowerCAmelCase   ,    __lowerCAmelCase						):
												raise ValueError("""n must be an integer"""						)
						if n <= 0:
												raise ValueError("""n must be >= 0"""						)

						lowerCamelCase__         =  []
						for num in range(len(__lowerCAmelCase						)						):
												lowerCamelCase__         =  0
												while 2 * i * i <= odd_composites[num]:
																		lowerCamelCase__         =  odd_composites[num] - 2 * i * i
																		if is_prime(__lowerCAmelCase						):
																								break
																		i += 1
												else:
																		list_nums.append(odd_composites[num]						)
																		if len(__lowerCAmelCase						) == n:
																								return list_nums

						return []
def 						A__			(				):
						return compute_nums(1						)[0]


if __name__ == "__main__":
							print(F'{solution() = }')

