code: 
  
  
  
  
  
  
  def    _lowerCamelCase	(	__lowerCamelCase   ,       __lowerCamelCase   ,       __lowerCamelCase   ,       __lowerCamelCase					)   -> Optional[Any]:
  
  					'''simple docstring'''
  					return len_board * len_board_column * row + column
  
  
  
  
  
  def    _lowerCamelCase	(	__lowerCamelCase   ,       __lowerCamelCase   ,       __lowerCamelCase   ,       __lowerCamelCase   ,       __lowerCamelCase   ,       __lowerCamelCase   ,       )   -> List[Any]:
  
  					'''simple docstring'''
  
  					if board[row][column] != word[word_index]:
  										return False
  
  					if word_index == len(lowercase_					) - 1:
  										return True
  
  					UpperCAmelCase__			:     List[Any]										= [(0, 1), (0, -1), (-1, 0), (1, 0)]
  					UpperCAmelCase__			:     List[Any]										= len(lowercase_					)
  					UpperCAmelCase__			:     Union[str, Any]										= len(board[0]					)
  					for direction in traverts_directions:
  										UpperCAmelCase__			:     Optional[Any]										= row + direction[0]
  										UpperCAmelCase__			:     Union[str, Any]										= column + direction[1]
  										if not (0 <= next_i < len_board and 0 <= next_j < len_board_column):
  															continue
  
  										UpperCAmelCase__			:     int										= get_point_key(lowercase_   ,       lowercase_   ,       lowercase_   ,       lowercase_					)
  										if key in visited_points_set:
  															continue
  
  										visited_points_set.add(lowercase_					)
  										if exits_word(lowercase_   ,       lowercase_   ,       lowercase_   ,       lowercase_   ,       word_index + 1   ,       lowercase_					):
  															return True
  
  										visited_points_set.remove(lowercase_					)
  
  					return False
  
  
  
  
  
  def    _lowerCamelCase	(	__lowerCamelCase   ,       __lowerCamelCase					)   -> int:
  
  					'''simple docstring'''
  					UpperCAmelCase__			:     Dict										= (
  					    'The board should be a non empty matrix of single chars strings.'
  					)
  
  					UpperCAmelCase__			:     int										= len(lowercase_					)
  					if not isinstance(lowercase_   ,       lowercase_					) or len(lowercase_					) == 0:
  										raise ValueError(lowercase_					)
  
  					for row in board:
  										if not isinstance(lowercase_   ,       lowercase_					) or len(lowercase_					) == 0:
  															raise ValueError(lowercase_					)
  
  										for item in row:
  															if not isinstance(lowercase_   ,       lowercase_					) or len(lowercase_					) != 1:
  																				raise ValueError(lowercase_					)
  
      # Validate word
  					if not isinstance(lowercase_   ,       lowercase_					) or len(lowercase_					) == 0:
  										raise ValueError(
  										    """The word parameter should be a string of length greater than 0."""					)
  
  					UpperCAmelCase__			:     Any										= len(board[0]					)
  					for i in range(lowercase_					):
  										for j in range(lowercase_					):
  															if exits_word(
  															    lowercase_   ,       lowercase_   ,       lowercase_   ,       lowercase_   ,       0   ,       {get_point_key(lowercase_   ,       lowercase_   ,       lowercase_   ,       lowercase_					)}					):
  																				return True
  
  					return False
  
  
  if __name__ == "__main__":
  						import doctest
  
  						doctest.testmod()
  
  
  
  
  
  
  
style_context: 
  
  
  
  
  
  
  from typing import TYPE_CHECKING
  
  from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available
  
  
  SCREAMING_SNAKE_CASE__		:       Any   							=							{"""configuration_dinat""": ["""DINAT_PRETRAINED_CONFIG_ARCHIVE_MAP""", """DinatConfig"""]}
  
  
  try:
        if not is_torch_available():
              raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
        pass
  else:
        SCREAMING_SNAKE_CASE__		:       str   							=							[
            """DINAT_PRETRAINED_MODEL_ARCHIVE_LIST""",
            """DinatForImageClassification""",
            """DinatModel""",
            """DinatPreTrainedModel""",
            """DinatBackbone""",
        ]
  
  if TYPE_CHECKING:
        from .configuration_dinat import DINAT_PRETRAINED_CONFIG_ARCHIVE_MAP, DinatConfig
  
        try:
              if not is_torch_available():
                    raise OptionalDependencyNotAvailable()
        except OptionalDependencyNotAvailable:
              pass
        else:
              from .modeling_dinat import (
                  DINAT_PRETRAINED_MODEL_ARCHIVE_LIST,
                  DinatBackbone,
                  DinatForImageClassification,
                  DinatModel,
                  DinatPreTrainedModel,
              )
  
  else:
        import sys
  
        SCREAMING_SNAKE_CASE__		:       Dict   							=							_LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)
  
  
  
  
  
  
  