

import math
import sys






class 	__magic_name__				:






     def __init__(							self  )->    Any:
         UpperCamelCase_      =	0
         UpperCamelCase_      =	[]
         UpperCamelCase_      =	{}  # To store the pos of node in array






     def   UpperCAmelCase_							(							self  )->    Optional[Any]:
         return self.cur_size == 0






     def   UpperCAmelCase_							(							self		,	_lowercase  )->    Any:
         UpperCamelCase_      =	self.left(_lowercase  )
         UpperCamelCase_      =	self.right(_lowercase  )
         if lc < self.cur_size and self.array(_lowercase  )[0] < self.array(_lowercase  )[0]:
             UpperCamelCase_      =	lc
         else:
             UpperCamelCase_      =	idx
         if rc < self.cur_size and self.array(_lowercase  )[0] < self.array(_lowercase  )[0]:
             UpperCamelCase_      =	rc
         if smallest != idx:
             self.swap(_lowercase		,	_lowercase  )
             self.min_heapify(_lowercase  )






     def   UpperCAmelCase_							(							self		,	_lowercase  )->    Optional[Any]:
         # Inserts a node into the Priority Queue
         UpperCamelCase_      =	self.cur_size
         self.cur_size += 1
         self.array.append((sys.maxsize, tup[1])  )
         self.decrease_key((sys.maxsize, tup[1])		,	tup[0]  )






     def   UpperCAmelCase_							(							self  )->    Tuple:
         # Removes and returns the min element at top of priority queue
         UpperCamelCase_      =	self.array[0][1]
         UpperCamelCase_      =	self.array[self.cur_size - 1]
         self.cur_size -= 1
         self.min_heapify(1  )
         del self.pos[min_node]
         return min_node






     def   UpperCAmelCase_							(							self		,	_lowercase  )->    Dict:
         # returns the index of left child
         return 2 * i + 1






     def   UpperCAmelCase_							(							self		,	_lowercase  )->    Optional[int]:
         # returns the index of right child
         return 2 * i + 2






     def   UpperCAmelCase_							(							self		,	_lowercase  )->    str:
         # returns the index of parent
         return math.floor(i / 2  )






     def   UpperCAmelCase_							(							self		,	_lowercase		,	_lowercase  )->    Optional[int]:
         # swaps array elements at indices i and j
         # update the pos{}
         UpperCamelCase_      =	j
         UpperCamelCase_      =	i
         UpperCamelCase_      =	self.array[i]
         UpperCamelCase_      =	self.array[j]
         UpperCamelCase_      =	temp






     def   UpperCAmelCase_							(							self		,	_lowercase		,	_lowercase  )->    int:
         UpperCamelCase_      =	self.pos[tup[1]]
         # assuming the new_d is atmost old_d
         UpperCamelCase_      =	(new_d, tup[1])
         while idx > 0 and self.array[self.par(_lowercase  )][0] > self.array[idx][0]:
             self.swap(_lowercase		,	self.par(_lowercase  )  )
             UpperCamelCase_      =	self.par(_lowercase  )






class 	__magic_name__				:






     def __init__(							self		,	_lowercase  )->    Tuple:
         UpperCamelCase_      =	{}  # To store graph: u -> (v,w)
         UpperCamelCase_      =	num  # Number of nodes in graph
         # To store the distance from source vertex
         UpperCamelCase_      =	[0] * self.num_nodes
         UpperCamelCase_      =	[-1] * self.num_nodes  # To store the path






     def   UpperCAmelCase_							(							self		,	_lowercase		,	_lowercase		,	_lowercase  )->    List[str]:
         #  Edge going from node u to v and v to u with weight w
         # u (w)-> v, v (w) -> u
         # Check if u already in graph
         if u in self.adjList:
             self.adjList[u].append((v, w)  )
         else:
             UpperCamelCase_      =	[(v, w)]

         # Assuming undirected graph
         if v in self.adjList:
             self.adjList[v].append((u, w)  )
         else:
             UpperCamelCase_      =	[(u, w)]






     def   UpperCAmelCase_							(							self  )->    Optional[Any]:
         # u -> v(w)
         for u in self.adjList:
             print(_lowercase		,	"->"		,	" -> ".join(str(F"{v}({w})"  ) for v, w in self.adjList[u]  )  )






     def   UpperCAmelCase_							(							self		,	_lowercase  )->    List[str]:
         # Flush old junk values in par[]
         UpperCamelCase_      =	[-1] * self.num_nodes
         # src is the source node
         UpperCamelCase_      =	0
         UpperCamelCase_      =	PriorityQueue()
         q.insert((0, src)  )  # (dist from src, node)
         for u in self.adjList:
             if u != src:
                 UpperCamelCase_      =	sys.maxsize  # Infinity
                 UpperCamelCase_      =	-1

         while not q.is_empty():
             UpperCamelCase_      =	q.extract_min()  # Returns node with the min dist from source
             # Update the distance of all the neighbours of u and
             # if their prev dist was INFINITY then push them in Q
             for v, w in self.adjList[u]:
                 UpperCamelCase_      =	self.dist[u] + w
                 if self.dist[v] > new_dist:
                     if self.dist[v] == sys.maxsize:
                         q.insert((new_dist, v)  )
                     else:
                         q.decrease_key((self.dist[v], v)		,	_lowercase  )
                     UpperCamelCase_      =	new_dist
                     UpperCamelCase_      =	u

        # Show the shortest distances from src
         self.show_distances(_lowercase  )






     def   UpperCAmelCase_							(							self		,	_lowercase  )->    Union[str, Any]:
         print(F"Distance from node: {src}"  )
         for u in range(self.num_nodes  ):
             print(F"Node {u} has distance: {self.dist[u]}"  )






     def   UpperCAmelCase_							(							self		,	_lowercase		,	_lowercase  )->    Any:
         # To show the shortest path from src to dest
         # WARNING: Use it *after* calling dijkstra
         UpperCamelCase_      =	[]
         UpperCamelCase_      =	0
         UpperCamelCase_      =	dest
         # Backtracking from dest to src
         while self.par[temp] != -1:
             path.append(_lowercase  )
             if temp != src:
                 for v, w in self.adjList[temp]:
                     if v == self.par[temp]:
                         cost += w
                         break
             UpperCamelCase_      =	self.par[temp]
         path.append(_lowercase  )
         path.reverse()

         print(F"----Path to reach {dest} from {src}----"  )
         for u in path:
             print(F"{u}"		,	end=" "  )
             if u != dest:
                 print("-> "		,	end=""  )

         print("\nTotal cost of path: "		,	_lowercase  )


if __name__ == "__main__":
 SCREAMING_SNAKE_CASE		:List[Any]				  =    Graph(9)
 graph.add_edge(0, 1, 4)
 graph.add_edge(0, 7, 8)
 graph.add_edge(1, 2, 8)
 graph.add_edge(1, 7, 11)
 graph.add_edge(2, 3, 7)
 graph.add_edge(2, 8, 2)
 graph.add_edge(2, 5, 4)
 graph.add_edge(3, 4, 9)
 graph.add_edge(3, 5, 14)
 graph.add_edge(4, 5, 10)
 graph.add_edge(5, 6, 2)
 graph.add_edge(6, 7, 1)
 graph.add_edge(6, 8, 6)
 graph.add_edge(7, 8, 7)
 graph.show_graph()
 graph.dijkstra(0)
 graph.show_path(0, 4)

# OUTPUT
# 0 -> 1(4) -> 7(8)
# 1 -> 0(4) -> 2(8) -> 7(11)
# 7 -> 0(8) -> 1(11) -> 6(1) -> 8(7)
# 2 -> 1(8) -> 3(7) -> 8(2) -> 5(4)
# 3 -> 2(7) -> 4(9) -> 5(14)
# 8 -> 2(2) -> 6(6) -> 7(7)
# 5 -> 2(4) -> 3(14) -> 4(10) -> 6(2)
# 4 -> 3(9) -> 5(10)
# 6 -> 5(2) -> 7(1) -> 8(6)
# Distance from node: 0
# Node 0 has distance: 0
# Node 1 has distance: 4
# Node 2 has distance: 12
# Node 3 has distance: 19
# Node 4 has distance: 21
# Node 5 has distance: 11
# Node 6 has distance: 9
# Node 7 has distance: 8
# Node 8 has distance: 14
# ----Path to reach 4 from 0----
# 0 -> 7 -> 6 -> 5 -> 4
# Total cost of path:  21



from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_flax_available,
    is_sentencepiece_available,
    is_tf_available,
    is_tokenizers_available,
    is_torch_available,
)


SCREAMING_SNAKE_CASE		:Optional[Any]				  =    {"""configuration_t5""": ["""T5_PRETRAINED_CONFIG_ARCHIVE_MAP""", """T5Config""", """T5OnnxConfig"""]}

try:
 if not is_sentencepiece_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 SCREAMING_SNAKE_CASE		:Dict				  =    ["""T5Tokenizer"""]

try:
 if not is_tokenizers_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 SCREAMING_SNAKE_CASE		:str				  =    ["""T5TokenizerFast"""]

try:
 if not is_torch_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 SCREAMING_SNAKE_CASE		:List[Any]				  =    [
     """T5_PRETRAINED_MODEL_ARCHIVE_LIST""",
     """T5EncoderModel""",
     """T5ForConditionalGeneration""",
     """T5Model""",
     """T5PreTrainedModel""",
     """load_tf_weights_in_t5""",
     """T5ForQuestionAnswering""",
 ]

try:
 if not is_tf_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 SCREAMING_SNAKE_CASE		:int				  =    [
     """TF_T5_PRETRAINED_MODEL_ARCHIVE_LIST""",
     """TFT5EncoderModel""",
     """TFT5ForConditionalGeneration""",
     """TFT5Model""",
     """TFT5PreTrainedModel""",
 ]

try:
 if not is_flax_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 SCREAMING_SNAKE_CASE		:List[str]				  =    [
     """FlaxT5EncoderModel""",
     """FlaxT5ForConditionalGeneration""",
     """FlaxT5Model""",
     """FlaxT5PreTrainedModel""",
 ]


if TYPE_CHECKING:
 from .configuration_ta import T5_PRETRAINED_CONFIG_ARCHIVE_MAP, TaConfig, TaOnnxConfig

 try:
  if not is_sentencepiece_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .tokenization_ta import TaTokenizer

 try:
  if not is_tokenizers_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .tokenization_ta_fast import TaTokenizerFast

 try:
  if not is_torch_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .modeling_ta import (
      T5_PRETRAINED_MODEL_ARCHIVE_LIST,
      TaEncoderModel,
      TaForConditionalGeneration,
      TaForQuestionAnswering,
      TaModel,
      TaPreTrainedModel,
      load_tf_weights_in_ta,
  )

 try:
  if not is_tf_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .modeling_tf_ta import (
      TF_T5_PRETRAINED_MODEL_ARCHIVE_LIST,
      TFTaEncoderModel,
      TFTaForConditionalGeneration,
      TFTaModel,
      TFTaPreTrainedModel,
  )

 try:
  if not is_flax_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .modeling_flax_ta import (
      FlaxTaEncoderModel,
      FlaxTaForConditionalGeneration,
      FlaxTaModel,
      FlaxTaPreTrainedModel,
  )


else:
 import sys

 SCREAMING_SNAKE_CASE		:List[Any]				  =    _LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)
