


from __future__ import annotations

import math






def 			UpperCamelCase (     __magic_name__					:							int					)       ->  bool:
		"""simple docstring"""




		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(__magic_name__					) + 1					)   ,   6					):
				if number % i == 0 or number % (i + 2) == 0:
						return False
		return True






def 			UpperCamelCase (     __magic_name__					:							int					)       ->  list[int]:
		"""simple docstring"""




		lowercase__					      =		str(__magic_name__					)
		lowercase__					      =		[n]
		for i in range(1   ,   len(__magic_name__					)					):
				list_nums.append(int(str_num[i:]					)					)
				list_nums.append(int(str_num[:-i]					)					)
		return list_nums






def 			UpperCamelCase (     __magic_name__					:							int					)       ->  bool:
		"""simple docstring"""




		if len(str(__magic_name__					)					) > 3:
				if not is_prime(int(str(__magic_name__					)[-3:]					)					) or not is_prime(int(str(__magic_name__					)[:3]					)					):
						return False
		return True






def 			UpperCamelCase (     __magic_name__					:							int = 11					)       ->  list[int]:
		"""simple docstring"""




		lowercase__					      =		[]
		lowercase__					      =		13
		while len(__magic_name__					) != count:
				if validate(__magic_name__					):
						lowercase__					      =		list_truncated_nums(__magic_name__					)
						if all(is_prime(__magic_name__					) for i in list_nums					):
								list_truncated_primes.append(__magic_name__					)
				num += 2
		return list_truncated_primes






def 			UpperCamelCase (     )       ->  int:
		"""simple docstring"""




		return sum(compute_truncated_primes(11					)					)


if __name__ == "__main__":
	print(F'{sum(compute_truncated_primes(1_1)) = }')





def 			UpperCamelCase (     __magic_name__					:							str					)       ->  List[str]:  # noqa: E741
		"""simple docstring"""




		lowercase__					      =		len(__magic_name__					)
		lowercase__					      =		0
		lowercase__					      =		[0] * n
		lowercase__					      =		[False] * n
		lowercase__					      =		[False] * n

		def dfs(__magic_name__					:							str   ,   __magic_name__					:							List[str]   ,   __magic_name__					:							str   ,   __magic_name__					:							Any					):
				if parent == root:
						out_edge_count += 1
				lowercase__					      =		True
				lowercase__					      =		at

				for to in l[at]:
						if to == parent:
								pass
						elif not visited[to]:
								lowercase__					      =		dfs(__magic_name__   ,   __magic_name__   ,   __magic_name__   ,   __magic_name__					)
								lowercase__					      =		min(low[at]   ,   low[to]					)

								# AP found via bridge
								if at < low[to]:
										lowercase__					      =		True
								# AP found via cycle
								if at == low[to]:
										lowercase__					      =		True
						else:
								lowercase__					      =		min(low[at]   ,   __magic_name__					)
				return out_edge_count

		for i in range(__magic_name__					):
				if not visited[i]:
						lowercase__					      =		0
						lowercase__					      =		dfs(__magic_name__   ,   __magic_name__   ,   -1   ,   __magic_name__					)
						lowercase__					      =		out_edge_count > 1

		for x in range(len(__magic_name__					)					):
				if is_art[x] is True:
						print(__magic_name__					)


# Adjacency list of graph
A	:		List[str]    =       {
    0: [1, 2],
    1: [0, 2],
    2: [0, 1, 3, 5],
    3: [2, 4],
    4: [3],
    5: [2, 6, 8],
    6: [5, 7],
    7: [6, 8],
    8: [5, 7],
}







compute_ap(data)

