code: 
  
  
  """simple docstring"""
  
  
  
  
  from typing import Optional, Union
  
  from ...file_utils import TensorType
  from ...processing_utils import ProcessorMixin
  from ...tokenization_utils_base import BatchEncoding, PaddingStrategy, TruncationStrategy
  
  
  
  
  class  __snake_case      (lowerCamelCase     ):
  							__a				   =					'''MarkupLMFeatureExtractor'''
  							__a				   =					('''MarkupLMTokenizer''', '''MarkupLMTokenizerFast''')
  							__a				   =					True
  
  
  
  
  							def __call__(    self:						Optional[Any]    ,       A_:						List[Any]=None    ,       A_:						Union[str, Any]=None    ,       A_:						int=None    ,       A_:						Union[str, Any]=None    ,       A_:						str=None    ,       A_:						bool = True    ,       A_:						Union[bool, str, PaddingStrategy] = False    ,       A_:						Union[bool, str, TruncationStrategy] = None    ,       A_:						Optional[int] = None    ,       A_:						int = 0    ,       A_:						Optional[int] = None    ,       A_:						Optional[bool] = None    ,       A_:						Optional[bool] = None    ,       A_:						bool = False    ,       A_:						bool = False    ,       A_:						bool = False    ,       A_:						bool = False    ,       A_:						bool = True    ,       A_:						Optional[Union[str, TensorType]] = None    ,       **A_:						List[Any]    ,       ):
  										# first, create nodes and xpaths
  										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`"""      )
  
  													__lowerCamelCase        =			self.feature_extractor(A_      )
  													__lowerCamelCase        =			features["""nodes"""]
  													__lowerCamelCase        =			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(A_    ,       A_      ):
  																__lowerCamelCase        =			[questions]  # add batch dimension (as the feature extractor always adds a batch dimension)
  
  										__lowerCamelCase        =			self.tokenizer(
  										    text=questions if questions is not None else nodes    ,       text_pair=nodes if questions is not None else None    ,       xpaths=A_    ,       node_labels=A_    ,       add_special_tokens=A_    ,       padding=A_    ,       truncation=A_    ,       max_length=A_    ,       stride=A_    ,       pad_to_multiple_of=A_    ,       return_token_type_ids=A_    ,       return_attention_mask=A_    ,       return_overflowing_tokens=A_    ,       return_special_tokens_mask=A_    ,       return_offsets_mapping=A_    ,       return_length=A_    ,       verbose=A_    ,       return_tensors=A_    ,       **A_    ,       )
  
  										return encoded_inputs
  
  
  
  
  							def      __a      (    self:						int    ,       *A_:						str    ,       **A_:						Union[str, Any]      ):
  										return self.tokenizer.batch_decode(*A_    ,       **A_      )
  
  
  
  
  							def      __a      (    self:						Any    ,       *A_:						Optional[int]    ,       **A_:						Any      ):
  										return self.tokenizer.decode(*A_    ,       **A_      )
  
  
  
  
  							@property
  							def      __a      (    self:						int      ):
  										__lowerCamelCase        =			self.tokenizer.model_input_names
  										return tokenizer_input_names
  
  
  
  
  
style_context: 
  
  
  """simple docstring"""
  
  
  
  
  def 			a_   (  lowercase__   :str, lowercase__   :int = 13    ):
  			__lowerCamelCase        =			""""""
  			for c in s:
  						if "A" <= c <= "Z":
  									out += chr(ord("""A"""    ) + (ord(lowercase__    ) - ord("""A"""    ) + n) % 26    )
  						elif "a" <= c <= "z":
  									out += chr(ord("""a"""    ) + (ord(lowercase__    ) - ord("""a"""    ) + n) % 26    )
  						else:
  									out += c
  			return out
  
  
  
  
  
  def 			a_   (  ):
  			__lowerCamelCase        =			input("""Enter message: """    )
  
  			__lowerCamelCase        =			dencrypt(lowercase__, 13    )
  			print("""Encryption:""", lowercase__    )
  
  			__lowerCamelCase        =			dencrypt(lowercase__, 13    )
  			print("""Decryption: """, lowercase__    )
  
  
  if __name__ == "__main__":
  					import doctest
  
  					doctest.testmod()
  					main()
  
  
  
  
  