code: 
  import os
  import unittest
  
  from transformers.models.bertweet.tokenization_bertweet import VOCAB_FILES_NAMES, BertweetTokenizer
  
  from ...test_tokenization_common import TokenizerTesterMixin
  
  
  
  
  
  class    _snake_case      (  lowerCAmelCase__       ,		unittest.TestCase       ):
     UpperCamelCase__					   =					BertweetTokenizer
     UpperCamelCase__					   =					False
  
  
  
  
  
  
  
     def     SCREAMING_SNAKE_CASE					(       self	):
      super().setUp()
  
      # Adapted from Sennrich et al. 2015 and https://github.com/rsennrich/subword-nmt
      __magic_name__	:	Optional[int]			     =  ["""I""", """m""", """V@@""", """R@@""", """r""", """e@@"""]
      __magic_name__	:	Any			     =  dict(zip(_lowerCamelCase		,     range(len(_lowerCamelCase	)	)	)	)
      __magic_name__	:	int			     =  ["""#version: 0.2""", """a m</w>"""]
      __magic_name__	:	Optional[Any]			     =  {"""unk_token""": """<unk>"""}
  
      __magic_name__	:	Optional[Any]			     =  os.path.join(self.tmpdirname		,     VOCAB_FILES_NAMES["vocab_file"]	)
      __magic_name__	:	List[Any]			     =  os.path.join(self.tmpdirname		,     VOCAB_FILES_NAMES["merges_file"]	)
      with open(self.vocab_file		,     "w"		,     encoding="utf-8"	) as fp:
       for token in vocab_tokens:
        fp.write(f'''{token} {vocab_tokens[token]}\n'''	)
      with open(self.merges_file		,     "w"		,     encoding="utf-8"	) as fp:
       fp.write("\n".join(_lowerCamelCase	)	)
  
  
  
  
  
  
  
     def     SCREAMING_SNAKE_CASE					(       self		,     **_a	):
      kwargs.update(self.special_tokens_map	)
      return BertweetTokenizer.from_pretrained(self.tmpdirname		,     **_lowerCamelCase	)
  
  
  
  
  
  
  
     def     SCREAMING_SNAKE_CASE					(       self		,     _a	):
      __magic_name__	:	Tuple			     =  """I am VinAI Research"""
      __magic_name__	:	Union[str, Any]			     =  """I <unk> m V<unk> <unk> <unk> I Re<unk> e<unk> <unk> <unk> <unk>"""
      return input_text, output_text
  
  
  
  
  
  
  
     def     SCREAMING_SNAKE_CASE					(       self	):
      __magic_name__	:	Any			     =  BertweetTokenizer(self.vocab_file		,     self.merges_file		,     **self.special_tokens_map	)
      __magic_name__	:	Any			     =  """I am VinAI Research"""
      __magic_name__	:	Dict			     =  """I a@@ m V@@ i@@ n@@ A@@ I R@@ e@@ s@@ e@@ a@@ r@@ c@@ h""".split()
      __magic_name__	:	Optional[Any]			     =  tokenizer.tokenize(_lowerCamelCase	)
      self.assertListEqual(_lowerCamelCase		,     _lowerCamelCase	)
  
      __magic_name__	:	Union[str, Any]			     =  tokens + [tokenizer.unk_token]
  
      __magic_name__	:	List[str]			     =  [4, 3, 5, 6, 3, 3, 3, 4, 7, 9, 3, 9, 3, 3, 3, 3, 3]
      self.assertListEqual(tokenizer.convert_tokens_to_ids(_lowerCamelCase	)		,     _lowerCamelCase	)
  
style_context: 
  def 						lowerCAmelCase_		(      _snake_case   :						int   ,     _snake_case   :						list[tuple[int, int, int]]     )       ->	list[tuple[int, int, int]]:
  
  
  
  
  
  
  
  	'''simple docstring'''
  
  
  	__magic_name__	:	Union[str, Any]			     =  sorted(_snake_case   ,     key=lambda _snake_case     : edge[2]     )
  
  	__magic_name__	:	Union[str, Any]			     =  list(range(_snake_case     )     )
  
  	def find_parent(_snake_case   :						Dict     ):
  		if i != parent[i]:
  			__magic_name__	:	Any			     =  find_parent(parent[i]     )
  		return parent[i]
  
  	__magic_name__	:	List[str]			     =  0
  	__magic_name__	:	int			     =  []
  
  	for edge in edges:
  		__magic_name__	:	Any			     =  find_parent(edge[0]     )
  		__magic_name__	:	int			     =  find_parent(edge[1]     )
  		if parent_a != parent_b:
  			minimum_spanning_tree_cost += edge[2]
  			minimum_spanning_tree.append(_snake_case     )
  			__magic_name__	:	Optional[int]			     =  parent_b
  
  	return minimum_spanning_tree
  
  
  if __name__ == "__main__":  # pragma: no cover
  				snake_case   ,snake_case				:	int							   =						list(map(int, input().strip().split()))
  				snake_case				:	int							   =						[]
  
  				for _ in range(num_edges):
  								snake_case   ,snake_case   ,snake_case				:	Dict							   =						(int(x) for x in input().strip().split())
  								edges.append((nodea, nodea, cost))
  
  				kruskal(num_nodes, edges)
  