




def 			lowerCAmelCase_			(  lowerCamelCase:       int     ,				lowerCamelCase:       int     ,				lowerCamelCase:       int     ,				lowerCamelCase:       int						)					->			int:


      '''simple docstring'''




      return len_board * len_board_column * row + column

def 			lowerCAmelCase_			(  lowerCamelCase:       list[list[str]]     ,				lowerCamelCase:       str     ,				lowerCamelCase:       int     ,				lowerCamelCase:       int     ,				lowerCamelCase:       int     ,				lowerCamelCase:       set[int]     ,				)					->			bool:


      '''simple docstring'''




      if board[row][column] != word[word_index]:
            return False

      if word_index == len(lowerCamelCase						) - 1:
            return True

      lowerCamelCase__        =				[(0, 1), (0, -1), (-1, 0), (1, 0)]
      lowerCamelCase__        =				len(lowerCamelCase						)
      lowerCamelCase__        =				len(board[0]						)
      for direction in traverts_directions:
            lowerCamelCase__        =				row + direction[0]
            lowerCamelCase__        =				column + direction[1]
            if not (0 <= next_i < len_board and 0 <= next_j < len_board_column):
                  continue

            lowerCamelCase__        =				get_point_key(lowerCamelCase     ,				lowerCamelCase     ,				lowerCamelCase     ,				lowerCamelCase						)
            if key in visited_points_set:
                  continue

            visited_points_set.add(lowerCamelCase						)
            if exits_word(lowerCamelCase     ,				lowerCamelCase     ,				lowerCamelCase     ,				lowerCamelCase     ,				word_index + 1     ,				lowerCamelCase						):
                  return True

            visited_points_set.remove(lowerCamelCase						)

      return False

def 			lowerCAmelCase_			(  lowerCamelCase:       list[list[str]]     ,				lowerCamelCase:       str						)					->			bool:


      '''simple docstring'''




      lowerCamelCase__        =				(
          'The board should be a non empty matrix of single chars strings.'
      )

      lowerCamelCase__        =				len(lowerCamelCase						)
      if not isinstance(lowerCamelCase     ,				lowerCamelCase						) or len(lowerCamelCase						) == 0:
            raise ValueError(lowerCamelCase						)

      for row in board:
            if not isinstance(lowerCamelCase     ,				lowerCamelCase						) or len(lowerCamelCase						) == 0:
                  raise ValueError(lowerCamelCase						)

            for item in row:
                  if not isinstance(lowerCamelCase     ,				lowerCamelCase						) or len(lowerCamelCase						) != 1:
                        raise ValueError(lowerCamelCase						)

    # Validate word
      if not isinstance(lowerCamelCase     ,				lowerCamelCase						) or len(lowerCamelCase						) == 0:
            raise ValueError(
                'The word parameter should be a string of length greater than 0.'						)

      lowerCamelCase__        =				len(board[0]						)
      for i in range(lowerCamelCase						):
            for j in range(lowerCamelCase						):
                  if exits_word(
                      lowerCamelCase     ,				lowerCamelCase     ,				lowerCamelCase     ,				lowerCamelCase     ,				0     ,				{get_point_key(lowerCamelCase     ,				lowerCamelCase     ,				lowerCamelCase     ,				lowerCamelCase						)}						):
                        return True

      return False


if __name__ == "__main__":
      import doctest

      doctest.testmod()





import importlib.metadata
import sys

from transformers.testing_utils import TestCasePlus
from transformers.utils.versions import require_version, require_version_core


__SCREAMING_SNAKE_CASE    :   int       =importlib.metadata.version("""numpy""")
__SCREAMING_SNAKE_CASE    :   Optional[int]       =""".""".join([str(x) for x in sys.version_info[:3]])






class 			A			(		_lowerCAmelCase		):
     """simple docstring"""

     def  __snake_case   (    self  :   List[Any]			)				->       Optional[int]:
           # lt + different version strings
           require_version_core('numpy<1000.4.5'			)
           require_version_core('numpy<1000.4'			)
           require_version_core('numpy<1000'			)

           # le
           require_version_core('numpy<=1000.4.5'			)
           require_version_core(F"""numpy<={numpy_ver}"""			)

           # eq
           require_version_core(F"""numpy=={numpy_ver}"""			)

           # ne
           require_version_core('numpy!=1000.4.5'			)

           # ge
           require_version_core('numpy>=1.0'			)
           require_version_core('numpy>=1.0.0'			)
           require_version_core(F"""numpy>={numpy_ver}"""			)

           # gt
           require_version_core('numpy>1.0.0'			)

           # mix
           require_version_core('numpy>1.0.0,<1000'			)

           # requirement w/o version
           require_version_core('numpy'			)

           # unmet requirements due to version conflict
           for req in ["numpy==1.0.0", "numpy>=1000.0.0", F"""numpy<{numpy_ver}"""]:
                 try:
                       require_version_core(A__			)
                 except ImportError as e:
                       self.assertIn(F"""{req} is required"""	,  str(A__			)			)
                       self.assertIn('but found'	,  str(A__			)			)

        # unmet requirements due to missing module
           for req in ["numpipypie>1", "numpipypie2"]:
                 try:
                       require_version_core(A__			)
                 except importlib.metadata.PackageNotFoundError as e:
                       self.assertIn(F"""The '{req}' distribution was not found and is required by this application"""	,  str(A__			)			)
                       self.assertIn('Try: pip install transformers -U'	,  str(A__			)			)

        # bogus requirements formats:
        # 1. whole thing
           for req in ["numpy??1.0.0", "numpy1.0.0"]:
                 try:
                       require_version_core(A__			)
                 except ValueError as e:
                       self.assertIn('requirement needs to be in the pip package format'	,  str(A__			)			)
        # 2. only operators
           for req in ["numpy=1.0.0", "numpy == 1.00", "numpy<>1.0.0", "numpy><1.00", "numpy>>1.0.0"]:
                 try:
                       require_version_core(A__			)
                 except ValueError as e:
                       self.assertIn('need one of '	,  str(A__			)			)




     def  __snake_case   (    self  :   str			)				->       Optional[int]:
           # matching requirement
           require_version('python>=3.6.0'			)

           # not matching requirements
           for req in ["python>9.9.9", "python<3.0.0"]:
                 try:
                       require_version_core(A__			)
                 except ImportError as e:
                       self.assertIn(F"""{req} is required"""	,  str(A__			)			)
                       self.assertIn(F"""but found python=={python_ver}"""	,  str(A__			)			)