





'''simple docstring'''






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 					_a						(       _lowerCamelCase    ,	_lowerCamelCase    ,	_lowerCamelCase    ,	_lowerCamelCase ) ->				bool:



			"""simple docstring"""


			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 					_a						(       _lowerCamelCase ) ->				tuple[int, int] | None:



			"""simple docstring"""


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







def 					_a						(       _lowerCamelCase ) ->				Matrix | None:



			"""simple docstring"""


			if location := find_empty_location(_lowerCamelCase ):
						__snake_case      ,     __snake_case					:      Any							      =     location
			else:
						# If the location is ``None``, then the grid is solved.
						return grid

			for digit in range(1    ,	10 ):
						if is_safe(_lowerCamelCase    ,	_lowerCamelCase    ,	_lowerCamelCase    ,	_lowerCamelCase ):
									__snake_case					:      Optional[int]							      =     digit

									if sudoku(_lowerCamelCase ) is not None:
												return grid

									__snake_case					:      List[str]							      =     0

			return None







def 					_a						(       _lowerCamelCase ) ->				None:



			"""simple docstring"""


			for row in grid:
						for cell in row:
									print(_lowerCamelCase    ,	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"""






from ...configuration_utils import PretrainedConfig
from ...utils import logging
from ...utils.backbone_utils import BackboneConfigMixin, get_aligned_output_features_output_indices


__SCREAMING_SNAKE_CASE							=     logging.get_logger(__name__)

__SCREAMING_SNAKE_CASE							=     {
    'microsoft/focalnet-tiny': 'https://huggingface.co/microsoft/focalnet-tiny/resolve/main/config.json',
}





class 				a__					(						A__   ,							A__       ):
     UpperCAmelCase__         =      '''focalnet'''



     def __init__(							self :Any      ,  _lowerCamelCase :List[Any]=224      ,  _lowerCamelCase :str=4      ,  _lowerCamelCase :List[str]=3      ,  _lowerCamelCase :Optional[Any]=96      ,  _lowerCamelCase :Dict=False      ,  _lowerCamelCase :Optional[Any]=[192, 384, 768, 768]      ,  _lowerCamelCase :Tuple=[2, 2, 6, 2]      ,  _lowerCamelCase :List[Any]=[2, 2, 2, 2]      ,  _lowerCamelCase :Optional[int]=[3, 3, 3, 3]      ,  _lowerCamelCase :Optional[Any]="gelu"      ,  _lowerCamelCase :Tuple=4.0      ,  _lowerCamelCase :Optional[Any]=0.0      ,  _lowerCamelCase :int=0.1      ,  _lowerCamelCase :List[str]=False      ,  _lowerCamelCase :str=1E-4      ,  _lowerCamelCase :Optional[int]=False      ,  _lowerCamelCase :List[str]=False      ,  _lowerCamelCase :str=False      ,  _lowerCamelCase :Optional[int]=0.02      ,  _lowerCamelCase :int=1E-5      ,  _lowerCamelCase :Tuple=32      ,  _lowerCamelCase :List[str]=None      ,  _lowerCamelCase :Dict=None      ,  **_lowerCamelCase :List[Any]      ,  ):







      '''simple docstring'''



      super().__init__(**_lowerCamelCase   )

      UpperCamelCase_     :					Any   	=image_size
      UpperCamelCase_     :					int   	=patch_size
      UpperCamelCase_     :					int   	=num_channels
      UpperCamelCase_     :					Union[str, Any]   	=embed_dim
      UpperCamelCase_     :					int   	=use_conv_embed
      UpperCamelCase_     :					Optional[int]   	=hidden_sizes
      UpperCamelCase_     :					str   	=depths
      UpperCamelCase_     :					Any   	=focal_levels
      UpperCamelCase_     :					List[str]   	=focal_windows
      UpperCamelCase_     :					str   	=hidden_act
      UpperCamelCase_     :					Dict   	=mlp_ratio
      UpperCamelCase_     :					List[str]   	=hidden_dropout_prob
      UpperCamelCase_     :					Optional[int]   	=drop_path_rate
      UpperCamelCase_     :					str   	=use_layerscale
      UpperCamelCase_     :					List[Any]   	=layerscale_value
      UpperCamelCase_     :					Optional[int]   	=use_post_layernorm
      UpperCamelCase_     :					Dict   	=use_post_layernorm_in_modulation
      UpperCamelCase_     :					Optional[Any]   	=normalize_modulator
      UpperCamelCase_     :					List[Any]   	=initializer_range
      UpperCamelCase_     :					List[str]   	=layer_norm_eps
      UpperCamelCase_     :					List[Any]   	=encoder_stride
      UpperCamelCase_     :					str   	=['stem'] + [f'''stage{idx}''' for idx in range(1      ,  len(self.depths   ) + 1   )]
      UpperCamelCase_	,     UpperCamelCase_     :					int   	=get_aligned_output_features_output_indices(
          out_features=_lowerCamelCase      ,  out_indices=_lowerCamelCase      ,  stage_names=self.stage_names   )
