






from __future__ import annotations

UpperCamelCase								=		list[list[int]]

# assigning initial values to the grid
UpperCamelCase								=		[
    [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
UpperCamelCase								=		[
    [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    __magic_name__    (	SCREAMING_SNAKE_CASE     ,     SCREAMING_SNAKE_CASE     ,     SCREAMING_SNAKE_CASE     ,     SCREAMING_SNAKE_CASE				)     ->    bool:
							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    __magic_name__    (	SCREAMING_SNAKE_CASE				)     ->    tuple[int, int] | None:
							for i in range(9				):
														for j in range(9				):
																					if grid[i][j] == 0:
																												return i, j
							return None






def    __magic_name__    (	SCREAMING_SNAKE_CASE				)     ->    Matrix | None:
							if location := find_empty_location(SCREAMING_SNAKE_CASE				):
														_lowercase							,							_lowercase							:   Any 							=   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				):
																					_lowercase							:   Optional[Any] 							=   digit

																					if sudoku(SCREAMING_SNAKE_CASE				) is not None:
																												return grid

																					_lowercase							:   List[Any] 							=   0

							return None






def    __magic_name__    (	SCREAMING_SNAKE_CASE				)     ->    None:
							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:")
														UpperCamelCase								=		sudoku(example_grid)
														if solution is not None:
																					print_solution(solution)
														else:
																					print("Cannot find a solution.")






'''simple docstring'''

import warnings
from functools import wraps
from typing import Callable


def        UpperCAmelCase_ (  lowerCamelCase_			):







 """simple docstring"""


 @wraps(lowerCamelCase_			)
 def _inner_fn(*lowerCamelCase_      ,			**lowerCamelCase_			):
  warnings.warn(
      (f'''\'{fn.__name__}\' is experimental and might be subject to breaking changes in the future.''')      ,			lowerCamelCase_      ,			)
  return fn(*lowerCamelCase_      ,			**lowerCamelCase_			)

 return _inner_fn





