code: 
  
  
  def   UpperCamelCase__   (    UpperCAmelCase_			)						->							bool:
  
  
  
  
         '''simple docstring'''
  
  
  
  
  
  
         _lowercase					:				List[Any]           =			[list(UpperCAmelCase_			) for row in matrix]
         if matrix and isinstance(UpperCAmelCase_    ,     UpperCAmelCase_			):
                if isinstance(matrix[0]    ,     UpperCAmelCase_			):
                       _lowercase					:				Optional[Any]           =			0
                       for row in matrix:
                              if prev_len == 0:
                                     _lowercase					:				Tuple           =			len(UpperCAmelCase_			)
                                     _lowercase					:				Dict           =			True
                              else:
                                     _lowercase					:				int           =			prev_len == len(UpperCAmelCase_			)
                else:
                       _lowercase					:				int           =			True
         else:
                _lowercase					:				Any           =			False
  
         return result
  
  def   UpperCamelCase__   (    UpperCAmelCase_			)						->							None:
  
  
  
  
         '''simple docstring'''
  
  
  
  
  
  
         if check_matrix(UpperCAmelCase_			) and len(UpperCAmelCase_			) > 0:
                _lowercase					:				Dict           =			[list(UpperCAmelCase_			) for row in a]
                _lowercase					:				List[Any]           =			len(UpperCAmelCase_			)
                if isinstance(a[0]    ,     UpperCAmelCase_			):
                       _lowercase					:				Dict           =			len(a[0]			)
                else:
                       for dat in a:
                              print(UpperCAmelCase_			)
                       return
  
                # horizotal printing increasing
                for i in range(0    ,     UpperCAmelCase_			):
                       print(a[0][i]			)
                # vertical printing down
                for i in range(1    ,     UpperCAmelCase_			):
                       print(a[i][mat_col - 1]			)
                # horizotal printing decreasing
                if mat_row > 1:
                       for i in range(mat_col - 2    ,     -1    ,     -1			):
                              print(a[mat_row - 1][i]			)
          # vertical printing up
                for i in range(mat_row - 2    ,     0    ,     -1			):
                       print(a[i][0]			)
                _lowercase					:				int           =			[row[1 : mat_col - 1] for row in a[1 : mat_row - 1]]
                if len(UpperCAmelCase_			) > 0:
                       spiral_print_clockwise(UpperCAmelCase_			)
                else:
                       return
         else:
                print('''Not a valid matrix'''			)
                return
  
  def   UpperCamelCase__   (    UpperCAmelCase_			)						->							list[int]:
  
  
  
  
         '''simple docstring'''
  
  
  
  
  
  
         if matrix:
                return list(matrix.pop(0			)			) + spiral_traversal(list(zip(*UpperCAmelCase_			)			)[::-1]			)
         else:
                return []
  
  
  # driver code
  if __name__ == "__main__":
     import doctest
  
     doctest.testmod()
  
     UpperCamelCase__				       =			[[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]
     spiral_print_clockwise(a)
style_context: 
  
  
  from typing import TYPE_CHECKING
  
  from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available
  
  
  UpperCamelCase__				       =			{
      'configuration_wav2vec2_conformer': [
          'WAV2VEC2_CONFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP',
          'Wav2Vec2ConformerConfig',
      ],
  }
  
  
  try:
     if not is_torch_available():
        raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
     pass
  else:
     UpperCamelCase__				       =			[
         'WAV2VEC2_CONFORMER_PRETRAINED_MODEL_ARCHIVE_LIST',
         'Wav2Vec2ConformerForAudioFrameClassification',
         'Wav2Vec2ConformerForCTC',
         'Wav2Vec2ConformerForPreTraining',
         'Wav2Vec2ConformerForSequenceClassification',
         'Wav2Vec2ConformerForXVector',
         'Wav2Vec2ConformerModel',
         'Wav2Vec2ConformerPreTrainedModel',
     ]
  
  if TYPE_CHECKING:
     from .configuration_wavaveca_conformer import (
         WAV2VEC2_CONFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP,
         WavaVecaConformerConfig,
     )
  
     try:
        if not is_torch_available():
           raise OptionalDependencyNotAvailable()
     except OptionalDependencyNotAvailable:
        pass
     else:
        from .modeling_wavaveca_conformer import (
            WAV2VEC2_CONFORMER_PRETRAINED_MODEL_ARCHIVE_LIST,
            WavaVecaConformerForAudioFrameClassification,
            WavaVecaConformerForCTC,
            WavaVecaConformerForPreTraining,
            WavaVecaConformerForSequenceClassification,
            WavaVecaConformerForXVector,
            WavaVecaConformerModel,
            WavaVecaConformerPreTrainedModel,
        )
  
  else:
     import sys
  
     UpperCamelCase__				       =			_LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)