





import argparse
import datetime





def 				__lowerCAmelCase(       _SCREAMING_SNAKE_CASE				)							-> str:




    """simple docstring"""




    _A     =							{
        '0': 'Sunday',
        '1': 'Monday',
        '2': 'Tuesday',
        '3': 'Wednesday',
        '4': 'Thursday',
        '5': 'Friday',
        '6': 'Saturday',
    }

    _A     =							{0: 1, 1: 2, 2: 3, 3: 4, 4: 5, 5: 6, 6: 0}

    # Validate
    if not 0 < len(_SCREAMING_SNAKE_CASE				) < 11:
        raise ValueError('Must be 10 characters long'				)

    # Get month
    _A     =							int(date_input[0] + date_input[1]				)
    # Validate
    if not 0 < m < 13:
        raise ValueError('Month must be between 1 - 12'				)

    _A     =							date_input[2]
    # Validate
    if sep_a not in ["-", "/"]:
        raise ValueError('Date separator must be \'-\' or \'/\''				)

    # Get day
    _A     =							int(date_input[3] + date_input[4]				)
    # Validate
    if not 0 < d < 32:
        raise ValueError('Date must be between 1 - 31'				)

    # Get second separator
    _A     =							date_input[5]
    # Validate
    if sep_a not in ["-", "/"]:
        raise ValueError('Date separator must be \'-\' or \'/\''				)

    # Get year
    _A     =							int(date_input[6] + date_input[7] + date_input[8] + date_input[9]				)
    # Arbitrary year range
    if not 45 < y < 8_500:
        raise ValueError(
            'Year out of range. There has to be some sort of limit...right?'				)

    # Get datetime obj for validation
    _A     =							datetime.date(int(_SCREAMING_SNAKE_CASE				)							,     int(_SCREAMING_SNAKE_CASE				)							,     int(_SCREAMING_SNAKE_CASE				)				)

    # Start math
    if m <= 2:
        _A     =							y - 1
        _A     =							m + 12
    # maths var
    _A     =							int(str(_SCREAMING_SNAKE_CASE				)[:2]				)
    _A     =							int(str(_SCREAMING_SNAKE_CASE				)[2:]				)
    _A     =							int(2.6 * m - 5.39				)
    _A     =							int(c / 4				)
    _A     =							int(k / 4				)
    _A     =							int(d + k				)
    _A     =							int(t + u + v + x				)
    _A     =							int(z - (2 * c)				)
    _A     =							round(w % 7				)
    # End math

    # Validate math
    if f != convert_datetime_days[dt_ck.weekday()]:
        raise AssertionError('The date was evaluated incorrectly. Contact developer.'				)

    # Response
    _A     =							F"Your date {date_input}, is a {days[str(_SCREAMING_SNAKE_CASE				)]}!"
    return response


if __name__ == "__main__":
 import doctest

 doctest.testmod()
 __A							:			Tuple         =			argparse.ArgumentParser(
     description=(
         "Find out what day of the week nearly any date is or was. Enter "
         "date as a string in the mm-dd-yyyy or mm/dd/yyyy format"
     )
 )
 parser.add_argument(
     "date_input", type=str, help="Date as a string (mm-dd-yyyy or mm/dd/yyyy)"
 )
 __A							:			Tuple         =			parser.parse_args()
 zeller(args.date_input)












def 				__lowerCAmelCase(       _SCREAMING_SNAKE_CASE							,     _SCREAMING_SNAKE_CASE				)							-> int:




    """simple docstring"""




    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 				__lowerCAmelCase(       _SCREAMING_SNAKE_CASE							,     _SCREAMING_SNAKE_CASE				)							-> str:




    """simple docstring"""




    _A     =							[[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				):
            _A     =							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]
                ):
                    _A     =							dist[i][k] + dist[k][j]

    _print_dist(_SCREAMING_SNAKE_CASE							,     _SCREAMING_SNAKE_CASE				)
    return dist, v


if __name__ == "__main__":
 __A							:			Dict         =			int(input("Enter number of vertices: "))
 __A							:			Union[str, Any]         =			int(input("Enter number of edges: "))

 __A							:			List[str]         =			[[float("inf") for i in range(v)] for j in range(v)]

 for i in range(v):
  __A							:			List[Any]         =			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)
  __A							:			Union[str, Any]         =			int(input("Enter source:"))
  __A							:			List[str]         =			int(input("Enter destination:"))
  __A							:			Union[str, Any]         =			float(input("Enter weight:"))
  __A							:			Any         =			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





