





def 	_SCREAMING_SNAKE_CASE		(      SCREAMING_SNAKE_CASE		:Optional[int]   ,   SCREAMING_SNAKE_CASE		:Tuple   )      ->   int:
 print("""\nThe shortest path matrix using Floyd Warshall algorithm\n"""   )
 for i in range(SCREAMING_SNAKE_CASE   ):
  for j in range(SCREAMING_SNAKE_CASE   ):
   if dist[i][j] != float("""inf"""   ):
    print(int(dist[i][j]   )   ,   end="""\t"""   )
   else:
    print("""INF"""   ,   end="""\t"""   )
  print()






def 	_SCREAMING_SNAKE_CASE		(      SCREAMING_SNAKE_CASE		:Dict   ,   SCREAMING_SNAKE_CASE		:Tuple   )      ->   Optional[int]:
 __lowerCAmelCase					:	Any      =       [[float("""inf"""   ) for _ in range(SCREAMING_SNAKE_CASE   )] for _ in range(SCREAMING_SNAKE_CASE   )]

 for i in range(SCREAMING_SNAKE_CASE   ):
  for j in range(SCREAMING_SNAKE_CASE   ):
   __lowerCAmelCase					:	Union[str, Any]      =       graph[i][j]

   # check vertex k against all other vertices (i, j)
 for k in range(SCREAMING_SNAKE_CASE   ):
  # looping through rows of graph array
  for i in range(SCREAMING_SNAKE_CASE   ):
   # looping through columns of graph array
   for j in range(SCREAMING_SNAKE_CASE   ):
    if (
        dist[i][k] != float("""inf"""   )
        and dist[k][j] != float("""inf"""   )
        and dist[i][k] + dist[k][j] < dist[i][j]
    ):
     __lowerCAmelCase					:	Tuple      =       dist[i][k] + dist[k][j]

 _print_dist(SCREAMING_SNAKE_CASE   ,   SCREAMING_SNAKE_CASE   )
 return dist, v


if __name__ == "__main__":
      _UpperCAmelCase             =							int(input('Enter number of vertices: '))
      _UpperCAmelCase             =							int(input('Enter number of edges: '))

      _UpperCAmelCase             =							[[float('inf') for i in range(v)] for j in range(v)]

      for i in range(v):
            _UpperCAmelCase             =							0.0

            # src and dst are indices that must be within the array size graph[e][v]
            # failure to follow this will result in an error
      for i in range(e):
            print('\nEdge ', i + 1)
            _UpperCAmelCase             =							int(input('Enter source:'))
            _UpperCAmelCase             =							int(input('Enter destination:'))
            _UpperCAmelCase             =							float(input('Enter weight:'))
            _UpperCAmelCase             =							weight

      floyd_warshall(graph, v)

      # Example Input
      # Enter number of vertices: 3
      # Enter number of edges: 2

      # # generated graph from vertex and edge inputs
      # [[inf, inf, inf], [inf, inf, inf], [inf, inf, inf]]
      # [[0.0, inf, inf], [inf, 0.0, inf], [inf, inf, 0.0]]

      # specify source, destination and weight for edge #1
      # Edge  1
      # Enter source:1
      # Enter destination:2
      # Enter weight:2

      # specify source, destination and weight for edge #2
      # Edge  2
      # Enter source:2
      # Enter destination:1
      # Enter weight:1

      # # Expected Output from the vertice, edge and src, dst, weight inputs!!
      # 0		INF	INF
      # INF	0	2
      # INF	1	0






from datetime import datetime

import requests






def 	_SCREAMING_SNAKE_CASE		(      SCREAMING_SNAKE_CASE		:str   )      ->   bytes:
 __lowerCAmelCase					:	List[Any]      =       """https://downloadgram.net/wp-json/wppress/video-downloader/video?url="""
 __lowerCAmelCase					:	Dict      =       requests.get(base_url + url   ).json()[0]["""urls"""][0]["""src"""]
 return requests.get(SCREAMING_SNAKE_CASE   ).content


if __name__ == "__main__":
      _UpperCAmelCase             =							input('Enter Video/IGTV url: ').strip()
      _UpperCAmelCase             =							f'''{datetime.now():%Y-%m-%d_%H:%M:%S}.mp4'''
      with open(file_name, 'wb') as fp:
            fp.write(download_video(url))
      print(f'''Done. Video saved to disk as {file_name}.''')