





import argparse
import datetime
def 		__magic_name__				( lowercase_				)		->					Union[str, Any]:


						'''simple docstring'''


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

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

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

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

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

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

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

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

						# Get datetime obj for validation
						UpperCamelCase  							= datetime.date(int(lowerCamelCase_				)						,		int(lowerCamelCase_				)						,		int(lowerCamelCase_				)				)

						# Start math
						if m <= 2:
												UpperCamelCase  							= y - 1
												UpperCamelCase  							= m + 12
						# maths var
						UpperCamelCase  							= int(str(lowerCamelCase_				)[:2]				)
						UpperCamelCase  							= int(str(lowerCamelCase_				)[2:]				)
						UpperCamelCase  							= int(2.6 * m - 5.39				)
						UpperCamelCase  							= int(c / 4				)
						UpperCamelCase  							= int(k / 4				)
						UpperCamelCase  							= int(d + k				)
						UpperCamelCase  							= int(t + u + v + x				)
						UpperCamelCase  							= int(z - (2 * c)				)
						UpperCamelCase  							= 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
						UpperCamelCase  							= f'''Your date {date_input}, is a {days[str(lowerCamelCase_				)]}!'''
						return response


if __name__ == "__main__":
		import doctest

		doctest.testmod()
		__a      : List[Any] 				=				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      : Union[str, Any] 				=				parser.parse_args()
		zeller(args.date_input)












import heapq as hq
import math
from collections.abc import Iterator
class  _UpperCAmelCase   :

				"""simple docstring"""




				def __init__(	self		:       str,    lowerCamelCase		:       List[Any]    ):

								'''simple docstring'''
								lowercase__  					=     str(id_    )
								lowercase__  					=     None
								lowercase__  					=     None
								lowercase__  					=     []
								lowercase__  					=     {}  # {vertex:distance}




				def __lt__(	self		:       Dict,    lowerCamelCase		:       Tuple    ):

								'''simple docstring'''
								return self.key < other.key




				def __repr__(	self		:       Dict    ):

								'''simple docstring'''
								return self.id




				def 							lowercase__  (	self		:       str,    lowerCamelCase		:       List[str]    ):

								'''simple docstring'''
								self.neighbors.append(lowerCamelCase    )




				def 							lowercase__  (	self		:       Any,    lowerCamelCase		:       Dict,    lowerCamelCase		:       Optional[Any]    ):

								'''simple docstring'''
								lowercase__  					=     weight






def     a     (		lowerCamelCase_						,  lowerCamelCase_						,  lowerCamelCase_						,  lowerCamelCase_							):






				'''simple docstring'''
				# add the neighbors:
				graph[a - 1].add_neighbor(graph[b - 1]							)
				graph[b - 1].add_neighbor(graph[a - 1]							)
				# add the edges:
				graph[a - 1].add_edge(graph[b - 1]						,  lowerCamelCase_							)
				graph[b - 1].add_edge(graph[a - 1]						,  lowerCamelCase_							)






def     a     (		lowerCamelCase_						,  lowerCamelCase_							):






				'''simple docstring'''
				lowercase__  					=     []
				for u in graph:
								lowercase__  					=     math.inf
								lowercase__  					=     None
				lowercase__  					=     0
				lowercase__  					=     graph[:]
				while q:
								lowercase__  					=     min(lowerCamelCase_							)
								q.remove(lowerCamelCase_							)
								for v in u.neighbors:
												if (v in q) and (u.edges[v.id] < v.key):
																lowercase__  					=     u
																lowercase__  					=     u.edges[v.id]
				for i in range(1						,  len(lowerCamelCase_							)							):
								a.append((int(graph[i].id							) + 1, int(graph[i].pi.id							) + 1)							)
				return a






def     a     (		lowerCamelCase_						,  lowerCamelCase_							):






				'''simple docstring'''
				for u in graph:
								lowercase__  					=     math.inf
								lowercase__  					=     None
				lowercase__  					=     0

				lowercase__  					=     list(lowerCamelCase_							)
				hq.heapify(lowerCamelCase_							)

				while h:
								lowercase__  					=     hq.heappop(lowerCamelCase_							)
								for v in u.neighbors:
												if (v in h) and (u.edges[v.id] < v.key):
																lowercase__  					=     u
																lowercase__  					=     u.edges[v.id]
																hq.heapify(lowerCamelCase_							)

				for i in range(1						,  len(lowerCamelCase_							)							):
								yield (int(graph[i].id							) + 1, int(graph[i].pi.id							) + 1)






def     a     (		):






				'''simple docstring'''


if __name__ == "__main__":
							import doctest

							doctest.testmod()




