






def 	SCREAMING_SNAKE_CASE							(      __lowerCAmelCase      ,					__lowerCAmelCase    )				->			Any:
     print("\nVertex Distance"    )
     for i in range(__lowerCAmelCase    ):
          if dist[i] != float("inf"    ):
               print(__lowerCAmelCase      ,					"\t"      ,					int(dist[i]    )      ,					end="\t"    )
          else:
               print(__lowerCAmelCase      ,					"\t"      ,					"INF"      ,					end="\t"    )
          print()







def 	SCREAMING_SNAKE_CASE							(      __lowerCAmelCase      ,					__lowerCAmelCase      ,					__lowerCAmelCase    )				->			List[str]:
     UpperCamelCase__    :     List[Any]        =						float("inf"    )
     UpperCamelCase__    :     Union[str, Any]        =						-1
     for i in range(__lowerCAmelCase    ):
          if (not vset[i]) and mdist[i] < min_val:
               UpperCamelCase__    :     Any        =						i
               UpperCamelCase__    :     str        =						mdist[i]
     return min_ind







def 	SCREAMING_SNAKE_CASE							(      __lowerCAmelCase      ,					__lowerCAmelCase      ,					__lowerCAmelCase    )				->			List[Any]:
     UpperCamelCase__    :     List[Any]        =						[float("inf"    ) for _ in range(__lowerCAmelCase    )]
     UpperCamelCase__    :     Any        =						[False for _ in range(__lowerCAmelCase    )]
     UpperCamelCase__    :     Any        =						0.0

     for _ in range(v - 1    ):
          UpperCamelCase__    :     Optional[int]        =						min_dist(__lowerCAmelCase      ,					__lowerCAmelCase      ,					__lowerCAmelCase    )
          UpperCamelCase__    :     str        =						True

          for i in range(__lowerCAmelCase    ):
               if (
                   (not vset[i])
                   and graph[u][i] != float("inf"    )
                   and mdist[u] + graph[u][i] < mdist[i]
               ):
                    UpperCamelCase__    :     Dict        =						mdist[u] + graph[u][i]

     print_dist(__lowerCAmelCase      ,					__lowerCAmelCase    )


if __name__ == "__main__":
 lowerCamelCase			:							str       =int(input('''Enter number of vertices: ''').strip())
 lowerCamelCase			:							Tuple       =int(input('''Enter number of edges: ''').strip())

 lowerCamelCase			:							Any       =[[float('''inf''') for i in range(V)] for j in range(V)]

 for i in range(V):
  lowerCamelCase			:							Optional[Any]       =0.0

 for i in range(E):
  print('''\nEdge ''', i + 1)
  lowerCamelCase			:							Union[str, Any]       =int(input('''Enter source:''').strip())
  lowerCamelCase			:							Optional[int]       =int(input('''Enter destination:''').strip())
  lowerCamelCase			:							List[str]       =float(input('''Enter weight:''').strip())
  lowerCamelCase			:							Union[str, Any]       =weight

 lowerCamelCase			:							List[str]       =int(input('''\nEnter shortest path source:''').strip())
 dijkstra(graph, V, gsrc)







import os
import unittest

from transformers import MPNetTokenizerFast
from transformers.models.mpnet.tokenization_mpnet import VOCAB_FILES_NAMES, MPNetTokenizer
from transformers.testing_utils import require_tokenizers, slow

from ...test_tokenization_common import TokenizerTesterMixin





@require_tokenizers
class     __a						(					A__ ,     unittest.TestCase ):
 _lowerCAmelCase : str 				=				MPNetTokenizer
 _lowerCAmelCase : List[str] 				=				MPNetTokenizerFast
 _lowerCAmelCase : List[Any] 				=				True
 _lowerCAmelCase : Union[str, Any] 				=				True







 def       __lowercase      (	self      :     List[Any]		):


      '''simple docstring'''






      super().setUp()

      UpperCamelCase__    :     List[Any]        =						[
          "[UNK]",
          "[CLS]",
          "[SEP]",
          "[PAD]",
          "[MASK]",
          "want",
          "##want",
          "##ed",
          "wa",
          "un",
          "runn",
          "##ing",
          ",",
          "low",
          "lowest",
      ]
      UpperCamelCase__    :     int        =						os.path.join(self.tmpdirname							,     VOCAB_FILES_NAMES["vocab_file"]		)
      with open(self.vocab_file							,     "w"							,     encoding="utf-8"		) as vocab_writer:
           vocab_writer.write("".join([x + "\n" for x in vocab_tokens]		)		)







 def       __lowercase      (	self      :     Tuple							,     SCREAMING_SNAKE_CASE      :     List[str]		):


      '''simple docstring'''






      UpperCamelCase__    :     List[str]        =						"UNwant\u00E9d,running"
      UpperCamelCase__    :     List[str]        =						"unwanted, running"
      return input_text, output_text







 def       __lowercase      (	self      :     Any		):


      '''simple docstring'''






      UpperCamelCase__    :     str        =						self.tokenizer_class(self.vocab_file		)

      UpperCamelCase__    :     Any        =						tokenizer.tokenize("UNwant\u00E9d,running"		)
      self.assertListEqual(SCREAMING_SNAKE_CASE							,     ["un", "##want", "##ed", ",", "runn", "##ing"]		)
      self.assertListEqual(tokenizer.convert_tokens_to_ids(SCREAMING_SNAKE_CASE		)							,     [9, 6, 7, 12, 10, 11]		)







 @slow
 def       __lowercase      (	self      :     str		):


      '''simple docstring'''






      UpperCamelCase__    :     Union[str, Any]        =						self.tokenizer_class.from_pretrained("microsoft/mpnet-base"		)

      UpperCamelCase__    :     Optional[int]        =						tokenizer.encode("sequence builders"							,     add_special_tokens=SCREAMING_SNAKE_CASE		)
      UpperCamelCase__    :     Optional[int]        =						tokenizer.encode("multi-sequence build"							,     add_special_tokens=SCREAMING_SNAKE_CASE		)

      UpperCamelCase__    :     Tuple        =						tokenizer.build_inputs_with_special_tokens(SCREAMING_SNAKE_CASE		)
      UpperCamelCase__    :     Optional[int]        =						tokenizer.build_inputs_with_special_tokens(SCREAMING_SNAKE_CASE							,     SCREAMING_SNAKE_CASE		)

      assert encoded_sentence == [0] + text + [2]
      assert encoded_pair == [0] + text + [2] + [2] + text_a + [2]