code: 
  
  import json
  from typing import List, Optional, Tuple
  
  from tokenizers import normalizers
  
  from ...tokenization_utils_fast import PreTrainedTokenizerFast
  from ...utils import logging
  from .tokenization_splinter import SplinterTokenizer
  
  
  _lowerCAmelCase     :			Dict    =logging.get_logger(__name__)
  
  _lowerCAmelCase     :			Optional[int]    ={"""vocab_file""": """vocab.txt"""}
  
  _lowerCAmelCase     :			Dict    ={
      """vocab_file""": {
          """tau/splinter-base""": """https://huggingface.co/tau/splinter-base/resolve/main/vocab.txt""",
          """tau/splinter-base-qass""": """https://huggingface.co/tau/splinter-base-qass/resolve/main/vocab.txt""",
          """tau/splinter-large""": """https://huggingface.co/tau/splinter-large/resolve/main/vocab.txt""",
          """tau/splinter-large-qass""": """https://huggingface.co/tau/splinter-large-qass/resolve/main/vocab.txt""",
      }
  }
  
  _lowerCAmelCase     :			Dict    ={
      """tau/splinter-base""": 5_12,
      """tau/splinter-base-qass""": 5_12,
      """tau/splinter-large""": 5_12,
      """tau/splinter-large-qass""": 5_12,
  }
  
  _lowerCAmelCase     :			Union[str, Any]    ={
      """tau/splinter-base""": {"""do_lower_case""": False},
      """tau/splinter-base-qass""": {"""do_lower_case""": False},
      """tau/splinter-large""": {"""do_lower_case""": False},
      """tau/splinter-large-qass""": {"""do_lower_case""": False},
  }
  
  class __UpperCamelCase    (							_a		):
  
  
  
  
  
  
  					'''simple docstring'''
  
  
  
  					__magic_name__     			=      VOCAB_FILES_NAMES
  					__magic_name__     			=      PRETRAINED_VOCAB_FILES_MAP
  					__magic_name__     			=      PRETRAINED_INIT_CONFIGURATION
  					__magic_name__     			=      PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
  					__magic_name__     			=      SplinterTokenizer
  
  
  
  
  
  					def __init__(							self							,			lowerCamelCase__=None							,			lowerCamelCase__=None							,			lowerCamelCase__=True							,			lowerCamelCase__="[UNK]"							,			lowerCamelCase__="[SEP]"							,			lowerCamelCase__="[PAD]"							,			lowerCamelCase__="[CLS]"							,			lowerCamelCase__="[MASK]"							,			lowerCamelCase__="[QUESTION]"							,			lowerCamelCase__=True							,			lowerCamelCase__=None							,			**lowerCamelCase__							,			):
  						super().__init__(
  						    lowerCamelCase__							,			tokenizer_file=lowerCamelCase__							,			do_lower_case=lowerCamelCase__							,			unk_token=lowerCamelCase__							,			sep_token=lowerCamelCase__							,			pad_token=lowerCamelCase__							,			cls_token=lowerCamelCase__							,			mask_token=lowerCamelCase__							,			tokenize_chinese_chars=lowerCamelCase__							,			strip_accents=lowerCamelCase__							,			additional_special_tokens=(question_token,)							,			**lowerCamelCase__							,			)
  
  						UpperCAmelCase__:  Union[str, Any]		       =   json.loads(self.backend_tokenizer.normalizer.__getstate__()	)
  						if (
  						    pre_tok_state.get("lowercase"							,			lowerCamelCase__	) != do_lower_case
  						    or pre_tok_state.get("strip_accents"							,			lowerCamelCase__	) != strip_accents
  						):
  							UpperCAmelCase__:  Optional[Any]		       =   getattr(lowerCamelCase__							,			pre_tok_state.pop("type"	)	)
  							UpperCAmelCase__:  List[Any]		       =   do_lower_case
  							UpperCAmelCase__:  str		       =   strip_accents
  							UpperCAmelCase__:  int		       =   pre_tok_class(**lowerCamelCase__	)
  
  						UpperCAmelCase__:  Dict		       =   do_lower_case
  
  
  
  
  
  					@property
  					def       _UpperCAmelCase						(							self	):
  						return self.convert_tokens_to_ids(self.question_token	)
  
  
  
  
  
  					def       _UpperCAmelCase						(							self							,			lowerCamelCase__							,			lowerCamelCase__ = None	):
  						if token_ids_a is None:
  							return [self.cls_token_id] + token_ids_a + [self.sep_token_id]
  
  						UpperCAmelCase__:  Any		       =   [self.cls_token_id]
  						UpperCAmelCase__:  Tuple		       =   [self.sep_token_id]
  						UpperCAmelCase__:  List[Any]		       =   [self.question_token_id] + [self.convert_tokens_to_ids("."	)]
  						if self.padding_side == "right":
  							# Input is question-then-context
  							return cls + token_ids_a + question_suffix + sep + token_ids_a + sep
  						else:
  							# Input is context-then-question
  							return cls + token_ids_a + sep + token_ids_a + question_suffix + sep
  
  
  
  
  
  					def       _UpperCAmelCase						(							self							,			lowerCamelCase__							,			lowerCamelCase__ = None	):
  						UpperCAmelCase__:  int		       =   [self.sep_token_id]
  						UpperCAmelCase__:  List[Any]		       =   [self.cls_token_id]
  						UpperCAmelCase__:  List[Any]		       =   [self.question_token_id] + [self.convert_tokens_to_ids("."	)]
  						if token_ids_a is None:
  							return len(cls + token_ids_a + sep	) * [0]
  
  						if self.padding_side == "right":
  							# Input is question-then-context
  							return len(cls + token_ids_a + question_suffix + sep	) * [0] + len(token_ids_a + sep	) * [1]
  						else:
  							# Input is context-then-question
  							return len(cls + token_ids_a + sep	) * [0] + len(token_ids_a + question_suffix + sep	) * [1]
  
  
  
  
  
  					def       _UpperCAmelCase						(							self							,			lowerCamelCase__							,			lowerCamelCase__ = None	):
  						UpperCAmelCase__:  List[Any]		       =   self._tokenizer.model.save(lowerCamelCase__							,			name=lowerCamelCase__	)
  						return tuple(lowerCamelCase__	)
style_context: 
  
  def  _A  (			SCREAMING_SNAKE_CASE  ,SCREAMING_SNAKE_CASE  ,SCREAMING_SNAKE_CASE  ,SCREAMING_SNAKE_CASE  ,SCREAMING_SNAKE_CASE  ,SCREAMING_SNAKE_CASE  ,):
  	UpperCAmelCase__:  Tuple		       =   list(SCREAMING_SNAKE_CASE			)
  	UpperCAmelCase__:  int		       =   list(SCREAMING_SNAKE_CASE			)
  	UpperCAmelCase__:  Dict		       =   len(SCREAMING_SNAKE_CASE			)
  	UpperCAmelCase__:  int		       =   len(SCREAMING_SNAKE_CASE			)
  
  	UpperCAmelCase__:  Any		       =   [
  	    [0 for _ in range(len_destination_seq + 1			)] for _ in range(len_source_seq + 1			)
  	]
  	UpperCAmelCase__:  List[Any]		       =   [
  	    ["0" for _ in range(len_destination_seq + 1			)] for _ in range(len_source_seq + 1			)
  	]
  
  	for i in range(1  ,len_source_seq + 1			):
  		UpperCAmelCase__:  List[Any]		       =   i * delete_cost
  		UpperCAmelCase__:  str		       =   f"D{source_seq[i - 1]:c}"
  
  	for i in range(1  ,len_destination_seq + 1			):
  		UpperCAmelCase__:  Union[str, Any]		       =   i * insert_cost
  		UpperCAmelCase__:  Optional[Any]		       =   f"I{destination_seq[i - 1]:c}"
  
  	for i in range(1  ,len_source_seq + 1			):
  		for j in range(1  ,len_destination_seq + 1			):
  			if source_seq[i - 1] == destination_seq[j - 1]:
  				UpperCAmelCase__:  Any		       =   costs[i - 1][j - 1] + copy_cost
  				UpperCAmelCase__:  Tuple		       =   f"C{source_seq[i - 1]:c}"
  			else:
  				UpperCAmelCase__:  Union[str, Any]		       =   costs[i - 1][j - 1] + replace_cost
  				UpperCAmelCase__:  Optional[int]		       =   f"R{source_seq[i - 1]:c}" + str(destination_seq[j - 1]			)
  
  			if costs[i - 1][j] + delete_cost < costs[i][j]:
  				UpperCAmelCase__:  Optional[int]		       =   costs[i - 1][j] + delete_cost
  				UpperCAmelCase__:  int		       =   f"D{source_seq[i - 1]:c}"
  
  			if costs[i][j - 1] + insert_cost < costs[i][j]:
  				UpperCAmelCase__:  Any		       =   costs[i][j - 1] + insert_cost
  				UpperCAmelCase__:  Tuple		       =   f"I{destination_seq[j - 1]:c}"
  
  	return costs, ops
  
  
  
  def  _A  (			SCREAMING_SNAKE_CASE  ,SCREAMING_SNAKE_CASE  ,SCREAMING_SNAKE_CASE			):
  	if i == 0 and j == 0:
  		return []
  	else:
  		if ops[i][j][0] == "C" or ops[i][j][0] == "R":
  			UpperCAmelCase__:  Union[str, Any]		       =   assemble_transformation(SCREAMING_SNAKE_CASE  ,i - 1  ,j - 1			)
  			seq.append(ops[i][j]			)
  			return seq
  		elif ops[i][j][0] == "D":
  			UpperCAmelCase__:  Optional[Any]		       =   assemble_transformation(SCREAMING_SNAKE_CASE  ,i - 1  ,SCREAMING_SNAKE_CASE			)
  			seq.append(ops[i][j]			)
  			return seq
  		else:
  			UpperCAmelCase__:  Dict		       =   assemble_transformation(SCREAMING_SNAKE_CASE  ,SCREAMING_SNAKE_CASE  ,j - 1			)
  			seq.append(ops[i][j]			)
  			return seq
  
  
  if __name__ == "__main__":
  					_lowerCAmelCase   ,  _lowerCAmelCase     :			Dict    =compute_transform_tables("""Python""", """Algorithms""", -1, 1, 2, 2)
  
  					_lowerCAmelCase     :			List[Any]    =len(operations)
  					_lowerCAmelCase     :			Optional[int]    =len(operations[0])
  					_lowerCAmelCase     :			Dict    =assemble_transformation(operations, m - 1, n - 1)
  
  					_lowerCAmelCase     :			int    =list("""Python""")
  					_lowerCAmelCase     :			Optional[int]    =0
  					_lowerCAmelCase     :			List[Any]    =0
  
  					with open("""min_cost.txt""", """w""") as file:
  										for op in sequence:
  															print("""""".join(string))
  
  															if op[0] == "C":
  																				file.write("""%-16s""" % """Copy %c""" % op[1])
  																				file.write("""\t\t\t""" + """""".join(string))
  																				file.write("""\r\n""")
  
  																				cost -= 1
  															elif op[0] == "R":
  																				_lowerCAmelCase     :			Tuple    =op[2]
  
  																				file.write("""%-16s""" % ("""Replace %c""" % op[1] + """ with """ + str(op[2])))
  																				file.write("""\t\t""" + """""".join(string))
  																				file.write("""\r\n""")
  
  																				cost += 1
  															elif op[0] == "D":
  																				string.pop(i)
  
  																				file.write("""%-16s""" % """Delete %c""" % op[1])
  																				file.write("""\t\t\t""" + """""".join(string))
  																				file.write("""\r\n""")
  
  																				cost += 2
  															else:
  																				string.insert(i, op[1])
  
  																				file.write("""%-16s""" % """Insert %c""" % op[1])
  																				file.write("""\t\t\t""" + """""".join(string))
  																				file.write("""\r\n""")
  
  																				cost += 2
  
  															i += 1
  
  										print("""""".join(string))
  										print("""Cost: """, cost)
  
  										file.write("""\r\nMinimum cost: """ + str(cost))