from __future__ import annotations




def       __magic_name__(  __UpperCAmelCase		)						->    Tuple:



      '''simple docstring'''

      _lowerCamelCase			    =				len(__UpperCAmelCase		)
      # We need to create solution object to save path.
      _lowerCamelCase			    =				[[0 for _ in range(__UpperCAmelCase		)] for _ in range(__UpperCAmelCase		)]
      _lowerCamelCase			    =				run_maze(__UpperCAmelCase ,						0 ,						0 ,						__UpperCAmelCase		)
      if solved:
            print('''\n'''.join(str(__UpperCAmelCase		) for row in solutions		)		)
      else:
            print('''No solution exists!'''		)
      return solved




def       __magic_name__(  __UpperCAmelCase ,						__UpperCAmelCase ,						__UpperCAmelCase ,						__UpperCAmelCase		)						->    List[Any]:



      '''simple docstring'''

      _lowerCamelCase			    =				len(__UpperCAmelCase		)
      # Final check point.
      if i == j == (size - 1):
            _lowerCamelCase			    =				1
            return True

      _lowerCamelCase			    =				(not i < 0) and (not j < 0)  # Check lower bounds
      _lowerCamelCase			    =				(i < size) and (j < size)  # Check upper bounds

      if lower_flag and upper_flag:
            # check for already visited and block points.
            _lowerCamelCase			    =				(not solutions[i][j]) and (not maze[i][j])
            if block_flag:
                  # check visited
                  _lowerCamelCase			    =				1

                  # check for directions
                  if (
                      run_maze(__UpperCAmelCase ,						i + 1 ,						__UpperCAmelCase ,						__UpperCAmelCase		)
                      or run_maze(__UpperCAmelCase ,						__UpperCAmelCase ,						j + 1 ,						__UpperCAmelCase		)
                      or run_maze(__UpperCAmelCase ,						i - 1 ,						__UpperCAmelCase ,						__UpperCAmelCase		)
                      or run_maze(__UpperCAmelCase ,						__UpperCAmelCase ,						j - 1 ,						__UpperCAmelCase		)
                  ):
                        return True

                  _lowerCamelCase			    =				0
                  return False
      return False


if __name__ == "__main__":
     import doctest

     doctest.testmod()
from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_flax_available,
    is_tf_available,
    is_tokenizers_available,
    is_torch_available,
)


snake_case__				= {
    'configuration_whisper': ['WHISPER_PRETRAINED_CONFIG_ARCHIVE_MAP', 'WhisperConfig', 'WhisperOnnxConfig'],
    'feature_extraction_whisper': ['WhisperFeatureExtractor'],
    'processing_whisper': ['WhisperProcessor'],
    'tokenization_whisper': ['WhisperTokenizer'],
}

try:
     if not is_tokenizers_available():
          raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
     pass
else:
     snake_case__				= ['WhisperTokenizerFast']

try:
     if not is_torch_available():
          raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
     pass
else:
     snake_case__				= [
         'WHISPER_PRETRAINED_MODEL_ARCHIVE_LIST',
         'WhisperForConditionalGeneration',
         'WhisperModel',
         'WhisperPreTrainedModel',
         'WhisperForAudioClassification',
     ]

try:
     if not is_tf_available():
          raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
     pass
else:
     snake_case__				= [
         'TF_WHISPER_PRETRAINED_MODEL_ARCHIVE_LIST',
         'TFWhisperForConditionalGeneration',
         'TFWhisperModel',
         'TFWhisperPreTrainedModel',
     ]

try:
     if not is_flax_available():
          raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
     pass
else:
     snake_case__				= [
         'FlaxWhisperForConditionalGeneration',
         'FlaxWhisperModel',
         'FlaxWhisperPreTrainedModel',
         'FlaxWhisperForAudioClassification',
     ]


if TYPE_CHECKING:
     from .configuration_whisper import WHISPER_PRETRAINED_CONFIG_ARCHIVE_MAP, WhisperConfig, WhisperOnnxConfig
     from .feature_extraction_whisper import WhisperFeatureExtractor
     from .processing_whisper import WhisperProcessor
     from .tokenization_whisper import WhisperTokenizer

     try:
          if not is_tokenizers_available():
               raise OptionalDependencyNotAvailable()
     except OptionalDependencyNotAvailable:
          pass
     else:
          from .tokenization_whisper_fast import WhisperTokenizerFast

     try:
          if not is_torch_available():
               raise OptionalDependencyNotAvailable()
     except OptionalDependencyNotAvailable:
          pass
     else:
          from .modeling_whisper import (
              WHISPER_PRETRAINED_MODEL_ARCHIVE_LIST,
              WhisperForAudioClassification,
              WhisperForConditionalGeneration,
              WhisperModel,
              WhisperPreTrainedModel,
          )

     try:
          if not is_tf_available():
               raise OptionalDependencyNotAvailable()
     except OptionalDependencyNotAvailable:
          pass
     else:
          from .modeling_tf_whisper import (
              TF_WHISPER_PRETRAINED_MODEL_ARCHIVE_LIST,
              TFWhisperForConditionalGeneration,
              TFWhisperModel,
              TFWhisperPreTrainedModel,
          )

     try:
          if not is_flax_available():
               raise OptionalDependencyNotAvailable()
     except OptionalDependencyNotAvailable:
          pass
     else:
          from .modeling_flax_whisper import (
              FlaxWhisperForAudioClassification,
              FlaxWhisperForConditionalGeneration,
              FlaxWhisperModel,
              FlaxWhisperPreTrainedModel,
          )

else:
     import sys

     snake_case__				= _LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)