






from __future__ import annotations

import math


def        _a  (     UpperCamelCase_					:				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


a_							=    [num for num in range(3, 10_0001, 2) if not is_prime(num)]


def        _a  (     UpperCamelCase_					:				int   ) ->   list[int]:
						"""simple docstring"""







						if not isinstance(UpperCamelCase_    ,   UpperCamelCase_   ):
												raise ValueError("n must be an integer"   )
						if n <= 0:
												raise ValueError("n must be >= 0"   )

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

						return []


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







						return compute_nums(1   )[0]


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














from collections import defaultdict
from math import ceil, sqrt


def        _a  (     UpperCamelCase_					:				int = 1_000_000    ,   UpperCamelCase_					:				int = 10   ) ->   int:
						"""simple docstring"""







						lowerCAmelCase__       =						defaultdict(UpperCamelCase_   )

						for outer_width in range(3    ,   (t_limit // 4) + 2   ):
												if outer_width * outer_width > t_limit:
																		lowerCAmelCase__       =						max(
																		    ceil(sqrt(outer_width * outer_width - t_limit   )   )    ,   1   )
												else:
																		lowerCAmelCase__       =						1

												hole_width_lower_bound += (outer_width - hole_width_lower_bound) % 2

												for hole_width in range(UpperCamelCase_    ,   outer_width - 1    ,   2   ):
																		count[outer_width * outer_width - hole_width * hole_width] += 1

						return sum(1 for n in count.values() if 1 <= n <= 10   )


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






