






"""simple docstring"""





def 							A(    snake_case_		,  snake_case_						):
       """simple docstring"""





       print("\nVertex Distance"						)
       for i in range(snake_case_						):
              if dist[i] != float("inf"						):
                     print(snake_case_		,  "\t"		,  int(dist[i]						)		,  end="\t"						)
              else:
                     print(snake_case_		,  "\t"		,  "INF"		,  end="\t"						)
              print()






def 							A(    snake_case_		,  snake_case_		,  snake_case_						):
       """simple docstring"""





       lowercase__:							List[str]         =     float("inf"						)
       lowercase__:							Any         =     -1
       for i in range(snake_case_						):
              if (not vset[i]) and mdist[i] < min_val:
                     lowercase__:							List[Any]         =     i
                     lowercase__:							int         =     mdist[i]
       return min_ind






def 							A(    snake_case_		,  snake_case_		,  snake_case_						):
       """simple docstring"""





       lowercase__:							Dict         =     [float("inf"						) for _ in range(snake_case_						)]
       lowercase__:							Tuple         =     [False for _ in range(snake_case_						)]
       lowercase__:							Union[str, Any]         =     0.0

       for _ in range(v - 1						):
              lowercase__:							Tuple         =     min_dist(snake_case_		,  snake_case_		,  snake_case_						)
              lowercase__:							int         =     True

              for i in range(snake_case_						):
                     if (
                         (not vset[i])
                         and graph[u][i] != float("inf"						)
                         and mdist[u] + graph[u][i] < mdist[i]
                     ):
                            lowercase__:							Optional[int]         =     mdist[u] + graph[u][i]

       print_dist(snake_case_		,  snake_case_						)


if __name__ == "__main__":
  UpperCamelCase					=     int(input("""Enter number of vertices: """).strip())
  UpperCamelCase					=     int(input("""Enter number of edges: """).strip())

  UpperCamelCase					=     [[float("""inf""") for i in range(V)] for j in range(V)]

  for i in range(V):
    UpperCamelCase					=     0.0

  for i in range(E):
    print("""\nEdge """, i + 1)
    UpperCamelCase					=     int(input("""Enter source:""").strip())
    UpperCamelCase					=     int(input("""Enter destination:""").strip())
    UpperCamelCase					=     float(input("""Enter weight:""").strip())
    UpperCamelCase					=     weight

  UpperCamelCase					=     int(input("""\nEnter shortest path source:""").strip())
  dijkstra(graph, V, gsrc)














"""simple docstring"""





UpperCamelCase					=     [chr(i) for i in range(32, 1_26)]
UpperCamelCase					=     list(range(len(alphabets)))
UpperCamelCase					=     list(range(len(alphabets)))
UpperCamelCase					=     list(range(len(alphabets)))
UpperCamelCase					=     list(reversed(range(len(alphabets))))
UpperCamelCase					=     []
UpperCamelCase					=     UpperCamelCase					=     UpperCamelCase					=     0






def 							A(    ):
       """simple docstring"""





       global gear_one_pos
       global gear_two_pos
       global gear_three_pos
       lowercase__:							int         =     gear_one[0]
       gear_one.append(snake_case_						)
       del gear_one[0]
       gear_one_pos += 1
       if gear_one_pos % int(len(snake_case_						)						) == 0:
              lowercase__:							List[str]         =     gear_two[0]
              gear_two.append(snake_case_						)
              del gear_two[0]
              gear_two_pos += 1
              if gear_two_pos % int(len(snake_case_						)						) == 0:
                     lowercase__:							Dict         =     gear_three[0]
                     gear_three.append(snake_case_						)
                     del gear_three[0]
                     gear_three_pos += 1






def 							A(    snake_case_						):
       """simple docstring"""





       lowercase__:							List[Any]         =     alphabets.index(snake_case_						)
       lowercase__:							Dict         =     gear_one[target]
       lowercase__:							Tuple         =     gear_two[target]
       lowercase__:							str         =     gear_three[target]
       lowercase__:							Any         =     reflector[target]
       lowercase__:							Any         =     gear_three.index(snake_case_						)
       lowercase__:							Tuple         =     gear_two.index(snake_case_						)
       lowercase__:							Union[str, Any]         =     gear_one.index(snake_case_						)
       code.append(alphabets[target]						)
       rotator()


if __name__ == "__main__":
  UpperCamelCase					=     list(input("""Type your message:\n"""))
  while True:
    try:
      UpperCamelCase					=     int(input("""Please set token:(must be only digits)\n"""))
      break
    except Exception as error:
      print(error)
  for _ in range(token):
    rotator()
  for j in decode:
    engine(j)
  print("""\n""" + """""".join(code))
  print(
      F"\nYour Token is {token} please write it down.\nIf you want to decode "
      """this message again you should input same digits as token!"""
  )






