

from __future__ import annotations

lowerCAmelCase_       	=	list[list[int]]

# assigning initial values to the grid
lowerCAmelCase_       	=	[
    [3, 0, 6, 5, 0, 8, 4, 0, 0],
    [5, 2, 0, 0, 0, 0, 0, 0, 0],
    [0, 8, 7, 0, 0, 0, 0, 3, 1],
    [0, 0, 3, 0, 1, 0, 0, 8, 0],
    [9, 0, 0, 8, 6, 3, 0, 0, 5],
    [0, 5, 0, 0, 9, 0, 6, 0, 0],
    [1, 3, 0, 0, 0, 0, 2, 5, 0],
    [0, 0, 0, 0, 0, 0, 0, 7, 4],
    [0, 0, 5, 2, 0, 6, 3, 0, 0],
]

# a grid with no solution
lowerCAmelCase_       	=	[
    [5, 0, 6, 5, 0, 8, 4, 0, 3],
    [5, 2, 0, 0, 0, 0, 0, 0, 2],
    [1, 8, 7, 0, 0, 0, 0, 3, 1],
    [0, 0, 3, 0, 1, 0, 0, 8, 0],
    [9, 0, 0, 8, 6, 3, 0, 0, 5],
    [0, 5, 0, 0, 9, 0, 6, 0, 0],
    [1, 3, 0, 0, 0, 0, 2, 5, 0],
    [0, 0, 0, 0, 0, 0, 0, 7, 4],
    [0, 0, 5, 2, 0, 6, 3, 0, 0],
]


def   __SCREAMING_SNAKE_CASE					(SCREAMING_SNAKE_CASE__  ,		SCREAMING_SNAKE_CASE__  ,		SCREAMING_SNAKE_CASE__  ,		SCREAMING_SNAKE_CASE__       ):
						for i in range(9       ):
												if grid[row][i] == n or grid[i][column] == n:
																		return False

						for i in range(3       ):
												for j in range(3       ):
																		if grid[(row - row % 3) + i][(column - column % 3) + j] == n:
																								return False

						return True


def   __SCREAMING_SNAKE_CASE					(SCREAMING_SNAKE_CASE__       ):
						for i in range(9       ):
												for j in range(9       ):
																		if grid[i][j] == 0:
																								return i, j
						return None


def   __SCREAMING_SNAKE_CASE					(SCREAMING_SNAKE_CASE__       ):
						if location := find_empty_location(SCREAMING_SNAKE_CASE__       ):
												snake_case_,    snake_case_   =	location
						else:
												# If the location is ``None``, then the grid is solved.
												return grid

						for digit in range(1  ,		10       ):
												if is_safe(SCREAMING_SNAKE_CASE__  ,		SCREAMING_SNAKE_CASE__  ,		SCREAMING_SNAKE_CASE__  ,		SCREAMING_SNAKE_CASE__       ):
																		snake_case_   =	digit

																		if sudoku(SCREAMING_SNAKE_CASE__       ) is not None:
																								return grid

																		snake_case_   =	0

						return None


def   __SCREAMING_SNAKE_CASE					(SCREAMING_SNAKE_CASE__       ):
						for row in grid:
												for cell in row:
																		print(SCREAMING_SNAKE_CASE__  ,		end=''' '''       )
												print()


if __name__ == "__main__":
					# make a copy of grid so that you can compare with the unmodified grid
					for example_grid in (initial_grid, no_solution):
										print('''\nExample grid:\n''' + '''=''' * 20)
										print_solution(example_grid)
										print('''\nExample grid solution:''')
										lowerCAmelCase_       	=	sudoku(example_grid)
										if solution is not None:
															print_solution(solution)
										else:
															print('''Cannot find a solution.''')


from __future__ import annotations

from collections.abc import Generator


def   __SCREAMING_SNAKE_CASE					():
						snake_case_   =	{}
						snake_case_   =	2
						while True:
												snake_case_   =	factor_map.pop(SCREAMING_SNAKE_CASE__  ,		SCREAMING_SNAKE_CASE__       )
												if factor:
																		snake_case_   =	factor + prime
																		while x in factor_map:
																								x += factor
																		snake_case_   =	factor
												else:
																		snake_case_   =	prime
																		yield prime
												prime += 1


def   __SCREAMING_SNAKE_CASE					(SCREAMING_SNAKE_CASE__ = 1E10       ):
						snake_case_   =	sieve()

						snake_case_   =	1
						while True:
												snake_case_   =	next(SCREAMING_SNAKE_CASE__       )
												if (2 * prime * n) > limit:
																		return n
												# Ignore the next prime as the reminder will be 2.
												next(SCREAMING_SNAKE_CASE__       )
												n += 2


if __name__ == "__main__":
					print(solution())