



from __future__ import annotations

import math



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



def 	__a					(   lowerCAmelCase_       : int    )				->			list[int]:






						'''simple docstring'''



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



def 	__a					(   lowerCAmelCase_       : int    )				->			bool:






						'''simple docstring'''



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



def 	__a					(   lowerCAmelCase_       : int = 11    )				->			list[int]:






						'''simple docstring'''



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



def 	__a					(   )				->			int:






						'''simple docstring'''



						return sum(compute_truncated_primes(11    )    )


if __name__ == "__main__":
					print(f'{sum(compute_truncated_primes(11)) = }')









def 	__a					(   lowerCAmelCase_       : Dict    )				->			Dict:






						'''simple docstring'''



						return [
						    {
						        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],
						    },
						    {
						        0: [6],
						        1: [9],
						        2: [4, 5],
						        3: [4],
						        4: [2, 3],
						        5: [2],
						        6: [0, 7],
						        7: [6],
						        8: [],
						        9: [1],
						    },
						    {
						        0: [4],
						        1: [6],
						        2: [],
						        3: [5, 6, 7],
						        4: [0, 6],
						        5: [3, 8, 9],
						        6: [1, 3, 4, 7],
						        7: [3, 6, 8, 9],
						        8: [5, 7],
						        9: [5, 7],
						    },
						    {
						        0: [1, 3],
						        1: [0, 2, 4],
						        2: [1, 3, 4],
						        3: [0, 2, 4],
						        4: [1, 2, 3],
						    },
						][index]



def 	__a					(   lowerCAmelCase_       : dict[int, list[int]]    )				->			list[tuple[int, int]]:






						'''simple docstring'''



						UpperCAmelCase_=       0
						UpperCAmelCase_=       len(lowerCAmelCase_    )  # No of vertices in graph
						UpperCAmelCase_=       [0] * n
						UpperCAmelCase_=       [False] * n

						def dfs(lowerCAmelCase_       : Optional[int]      ,lowerCAmelCase_       : Dict      ,lowerCAmelCase_       : Any      ,lowerCAmelCase_       : int    ):
												UpperCAmelCase_=       True
												UpperCAmelCase_=       id_
												id_ += 1
												for to in graph[at]:
																		if to == parent:
																								pass
																		elif not visited[to]:
																								dfs(lowerCAmelCase_      ,lowerCAmelCase_      ,lowerCAmelCase_      ,id_    )
																								UpperCAmelCase_=       min(low[at]      ,low[to]    )
																								if id_ <= low[to]:
																														bridges.append((at, to) if at < to else (to, at)    )
																		else:
																								# This edge is a back edge and cannot be a bridge
																								UpperCAmelCase_=       min(low[at]      ,low[to]    )

						UpperCAmelCase_=       []
						for i in range(lowerCAmelCase_    ):
												if not visited[i]:
																		dfs(lowerCAmelCase_      ,-1      ,lowerCAmelCase_      ,id_    )
						return bridges


if __name__ == "__main__":
	import doctest

	doctest.testmod()




