code: 
  from typing import Optional, Union
  
  from ...file_utils import TensorType
  from ...processing_utils import ProcessorMixin
  from ...tokenization_utils_base import BatchEncoding, PaddingStrategy, TruncationStrategy
  
  
  
  
  class 					_UpperCamelCase (      __SCREAMING_SNAKE_CASE	):
  
  
  
  
  
  
  
  							'''simple docstring'''
  							_A  				=  "MarkupLMFeatureExtractor"
  							_A  				=  ("MarkupLMTokenizer", "MarkupLMTokenizerFast")
  							_A  				=  True
  
  
  
  
  
  
  
  							def __call__(		self  :				int		,				SCREAMING_SNAKE_CASE_  :				Tuple=None		,				SCREAMING_SNAKE_CASE_  :				Optional[Any]=None		,				SCREAMING_SNAKE_CASE_  :				Optional[Any]=None		,				SCREAMING_SNAKE_CASE_  :				List[Any]=None		,				SCREAMING_SNAKE_CASE_  :				str=None		,				SCREAMING_SNAKE_CASE_  :				bool = True		,				SCREAMING_SNAKE_CASE_  :				Union[bool, str, PaddingStrategy] = False		,				SCREAMING_SNAKE_CASE_  :				Union[bool, str, TruncationStrategy] = None		,				SCREAMING_SNAKE_CASE_  :				Optional[int] = None		,				SCREAMING_SNAKE_CASE_  :				int = 0		,				SCREAMING_SNAKE_CASE_  :				Optional[int] = None		,				SCREAMING_SNAKE_CASE_  :				Optional[bool] = None		,				SCREAMING_SNAKE_CASE_  :				Optional[bool] = None		,				SCREAMING_SNAKE_CASE_  :				bool = False		,				SCREAMING_SNAKE_CASE_  :				bool = False		,				SCREAMING_SNAKE_CASE_  :				bool = False		,				SCREAMING_SNAKE_CASE_  :				bool = False		,				SCREAMING_SNAKE_CASE_  :				bool = True		,				SCREAMING_SNAKE_CASE_  :				Optional[Union[str, TensorType]] = None		,				**SCREAMING_SNAKE_CASE_  :				List[Any]		,				):
  
  
  
  
  
  
  
  													if self.parse_html:
  																			if html_strings is None:
  																									raise ValueError('Make sure to pass HTML strings in case `parse_html` is set to `True`'		)
  
  																			if nodes is not None or xpaths is not None or node_labels is not None:
  																									raise ValueError(
  																									    'Please don\'t pass nodes, xpaths nor node labels in case `parse_html` is set to `True`'		)
  
  																			_a     =			self.feature_extractor(UpperCamelCase__		)
  																			_a     =			features['''nodes''']
  																			_a     =			features['''xpaths''']
  													else:
  																			if html_strings is not None:
  																									raise ValueError('You have passed HTML strings but `parse_html` is set to `False`.'		)
  																			if nodes is None or xpaths is None:
  																									raise ValueError('Make sure to pass nodes and xpaths in case `parse_html` is set to `False`'		)
  
          # # second, apply the tokenizer
  													if questions is not None and self.parse_html:
  																			if isinstance(UpperCamelCase__		,				UpperCamelCase__		):
  																									_a     =			[questions]  # add batch dimension (as the feature extractor always adds a batch dimension)
  
  													_a     =			self.tokenizer(
  													    text=questions if questions is not None else nodes		,				text_pair=nodes if questions is not None else None		,				xpaths=UpperCamelCase__		,				node_labels=UpperCamelCase__		,				add_special_tokens=UpperCamelCase__		,				padding=UpperCamelCase__		,				truncation=UpperCamelCase__		,				max_length=UpperCamelCase__		,				stride=UpperCamelCase__		,				pad_to_multiple_of=UpperCamelCase__		,				return_token_type_ids=UpperCamelCase__		,				return_attention_mask=UpperCamelCase__		,				return_overflowing_tokens=UpperCamelCase__		,				return_special_tokens_mask=UpperCamelCase__		,				return_offsets_mapping=UpperCamelCase__		,				return_length=UpperCamelCase__		,				verbose=UpperCamelCase__		,				return_tensors=UpperCamelCase__		,				**UpperCamelCase__		,				)
  
  													return encoded_inputs
  
  
  
  
  
  
  
  							def 		_UpperCAmelCase	(		self  :				Union[str, Any]		,				*SCREAMING_SNAKE_CASE_  :				List[str]		,				**SCREAMING_SNAKE_CASE_  :				List[Any]		):
  													return self.tokenizer.batch_decode(*UpperCamelCase__		,				**UpperCamelCase__		)
  
  
  
  
  
  
  
  							def 		_UpperCAmelCase	(		self  :				Dict		,				*SCREAMING_SNAKE_CASE_  :				int		,				**SCREAMING_SNAKE_CASE_  :				Union[str, Any]		):
  													return self.tokenizer.decode(*UpperCamelCase__		,				**UpperCamelCase__		)
  
  
  
  
  
  
  
  							@property
  							def 		_UpperCAmelCase	(		self  :				Optional[int]		):
  													_a     =			self.tokenizer.model_input_names
  													return tokenizer_input_names
  
  
  
style_context: 
  
  
  def 							SCREAMING_SNAKE_CASE					(  _UpperCAmelCase				)    ->  bool:
  						# must be
  						_a     =			[list(_UpperCAmelCase				) for row in matrix]
  						if matrix and isinstance(_UpperCAmelCase							,     _UpperCAmelCase				):
  												if isinstance(matrix[0]							,     _UpperCAmelCase				):
  																		_a     =			0
  																		for row in matrix:
  																								if prev_len == 0:
  																														_a     =			len(_UpperCAmelCase				)
  																														_a     =			True
  																								else:
  																														_a     =			prev_len == len(_UpperCAmelCase				)
  												else:
  																		_a     =			True
  						else:
  												_a     =			False
  
  						return result
  
  
  def 							SCREAMING_SNAKE_CASE					(  _UpperCAmelCase				)    ->  None:
  						if check_matrix(_UpperCAmelCase				) and len(_UpperCAmelCase				) > 0:
  												_a     =			[list(_UpperCAmelCase				) for row in a]
  												_a     =			len(_UpperCAmelCase				)
  												if isinstance(a[0]							,     _UpperCAmelCase				):
  																		_a     =			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]				)
  												_a     =			[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 							SCREAMING_SNAKE_CASE					(  _UpperCAmelCase				)    ->  list[int]:
  						if matrix:
  												return list(matrix.pop(0				)				) + spiral_traversal(list(zip(*_UpperCAmelCase				)				)[::-1]				)
  						else:
  												return []
  
  
  # driver code
  if __name__ == "__main__":
  		import doctest
  
  		doctest.testmod()
  
  		lowercase_								=    [[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]
  		spiral_print_clockwise(a)
  
  
  