





from __future__ import annotations

import math





def    __UpperCamelCase      (    a) ->bool:

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





def    __UpperCamelCase      (    a) ->list[int]:
					lowerCamelCase__       =       str(a)
					lowerCamelCase__       =       [n]
					for i in range(1,     len(a)):
										list_nums.append(int(str_num[i:]))
										list_nums.append(int(str_num[:-i]))
					return list_nums





def    __UpperCamelCase      (    a) ->bool:
					if len(str(a)) > 3:
										if not is_prime(int(str(a)[-3:])) or not is_prime(int(str(a)[:3])):
															return False
					return True





def    __UpperCamelCase      (    a = 11) ->list[int]:
					lowerCamelCase__       =       []
					lowerCamelCase__       =       13
					while len(a) != count:
										if validate(a):
															lowerCamelCase__       =       list_truncated_nums(a)
															if all(is_prime(a) for i in list_nums):
																				list_truncated_primes.append(a)
										num += 2
					return list_truncated_primes





def    __UpperCamelCase      (    ) ->int:
					return sum(compute_truncated_primes(11))


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








def    __UpperCamelCase      (    a) ->float:
					return 10 - x * x





def    __UpperCamelCase      (    a,     a) ->float:
					# Bolzano theory in order to find if there is a root between a and b
					if equation(a) * equation(a) >= 0:
										raise ValueError("Wrong space!")

					lowerCamelCase__       =       a
					while (b - a) >= 0.0_1:
										# Find middle point
										lowerCamelCase__       =       (a + b) / 2
										# Check if middle point is root
										if equation(a) == 0.0:
															break
										# Decide the side to repeat the steps
										if equation(a) * equation(a) < 0:
															lowerCamelCase__       =       c
										else:
															lowerCamelCase__       =       c
					return c


if __name__ == "__main__":
						import doctest

						doctest.testmod()

						print(bisection(-2, 5))
						print(bisection(0, 6))

