



import argparse
import datetime



def 					lowercase				(      SCREAMING_SNAKE_CASE__				:		str )     ->   str:
 _snake_case			:     Union[str, Any] 		=    {
     """0""": """Sunday""",
     """1""": """Monday""",
     """2""": """Tuesday""",
     """3""": """Wednesday""",
     """4""": """Thursday""",
     """5""": """Friday""",
     """6""": """Saturday""",
 }

 _snake_case			:     str 		=    {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
 _snake_case			:     int 		=    int(date_input[0] + date_input[1] )
 # Validate
 if not 0 < m < 13:
  raise ValueError("""Month must be between 1 - 12""" )

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

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

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

 # Get year
 _snake_case			:     int 		=    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
 _snake_case			:     Optional[Any] 		=    datetime.date(int(SCREAMING_SNAKE_CASE__ ) ,				int(SCREAMING_SNAKE_CASE__ ) ,				int(SCREAMING_SNAKE_CASE__ ) )

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


if __name__ == "__main__":
  import doctest

  doctest.testmod()
  a__			=		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__			=		parser.parse_args()
  zeller(args.date_input)








def    SCREAMING_SNAKE_CASE_							(							__magic_name__					:  list[list[int]]	,			__magic_name__					:  int	,			__magic_name__					:  int	,			__magic_name__					:  list[int]					)		->			bool:






	"""simple docstring"""



	if graph[path[curr_ind - 1]][next_ver] == 0:
		return False

	# 2. Validate that next vertex is not already in path
	return not any(vertex == next_ver for vertex in path					)

def    SCREAMING_SNAKE_CASE_							(							__magic_name__					:  list[list[int]]	,			__magic_name__					:  list[int]	,			__magic_name__					:  int					)		->			bool:






	"""simple docstring"""



	if curr_ind == len(__magic_name__					):
		# return whether path exists between current and starting vertices
		return graph[path[curr_ind - 1]][path[0]] == 1

	# Recursive Step
	for next_ver in range(0	,			len(__magic_name__					)					):
		if valid_connection(__magic_name__	,			__magic_name__	,			__magic_name__	,			__magic_name__					):
			# Insert current vertex  into path as next transition
			UpperCamelCase     :str          =	next_ver
			# Validate created path
			if util_hamilton_cycle(__magic_name__	,			__magic_name__	,			curr_ind + 1					):
				return True
			# Backtrack
			UpperCamelCase     :Union[str, Any]          =	-1
	return False

def    SCREAMING_SNAKE_CASE_							(							__magic_name__					:  list[list[int]]	,			__magic_name__					:  int = 0					)		->			list[int]:






	"""simple docstring"""



	UpperCamelCase     :Union[str, Any]          =	[-1] * (len(__magic_name__					) + 1)
	# initialize start and end of path with starting index
	UpperCamelCase     :Any          =	start_index
	# evaluate and if we find answer return path either return empty array
	return path if util_hamilton_cycle(__magic_name__	,			__magic_name__	,			1					) else []
