
import argparse
import datetime







def 							A__       (    lowerCamelCase    )	->						str:
				UpperCamelCase_:				Dict						=    {
				    """0""": """Sunday""",
				    """1""": """Monday""",
				    """2""": """Tuesday""",
				    """3""": """Wednesday""",
				    """4""": """Thursday""",
				    """5""": """Friday""",
				    """6""": """Saturday""",
				}

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

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

				# Get day
				UpperCamelCase_:				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
				UpperCamelCase_:				str						=    date_input[5]
				# Validate
				if sep_a not in ["-", "/"]:
								raise ValueError("""Date separator must be '-' or '/'"""    )

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

				# Get datetime obj for validation
				UpperCamelCase_:				Optional[int]						=    datetime.date(int(lowerCamelCase    )  ,     int(lowerCamelCase    )  ,     int(lowerCamelCase    )    )

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


if __name__ == "__main__":
							import doctest

							doctest.testmod()
							lowerCamelCase_    :			Dict    =	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)"""
							)
							lowerCamelCase_    :			List[Any]    =	parser.parse_args()
							zeller(args.date_input)








from __future__ import annotations







def 							A__       (    lowerCamelCase    )	->						bool:
				UpperCamelCase_:				Optional[int]						=    len(lowerCamelCase    )
				# We need to create solution object to save path.
				UpperCamelCase_:				List[str]						=    [[0 for _ in range(lowerCamelCase    )] for _ in range(lowerCamelCase    )]
				UpperCamelCase_:				Dict						=    run_maze(lowerCamelCase  ,     0  ,     0  ,     lowerCamelCase    )
				if solved:
								print("""\n""".join(str(lowerCamelCase    ) for row in solutions    )    )
				else:
								print("""No solution exists!"""    )
				return solved







def 							A__       (    lowerCamelCase  ,     lowerCamelCase  ,     lowerCamelCase  ,     lowerCamelCase    )	->						bool:
				UpperCamelCase_:				Dict						=    len(lowerCamelCase    )
				# Final check point.
				if i == j == (size - 1):
								UpperCamelCase_:				Union[str, Any]						=    1
								return True

				UpperCamelCase_:				List[str]						=    (not i < 0) and (not j < 0)  # Check lower bounds
				UpperCamelCase_:				List[str]						=    (i < size) and (j < size)  # Check upper bounds

				if lower_flag and upper_flag:
								# check for already visited and block points.
								UpperCamelCase_:				Dict						=    (not solutions[i][j]) and (not maze[i][j])
								if block_flag:
												# check visited
												UpperCamelCase_:				Optional[Any]						=    1

												# check for directions
												if (
												    run_maze(lowerCamelCase  ,     i + 1  ,     lowerCamelCase  ,     lowerCamelCase    )
												    or run_maze(lowerCamelCase  ,     lowerCamelCase  ,     j + 1  ,     lowerCamelCase    )
												    or run_maze(lowerCamelCase  ,     i - 1  ,     lowerCamelCase  ,     lowerCamelCase    )
												    or run_maze(lowerCamelCase  ,     lowerCamelCase  ,     j - 1  ,     lowerCamelCase    )
												):
																return True

												UpperCamelCase_:				Optional[Any]						=    0
												return False
				return False


if __name__ == "__main__":
							import doctest

							doctest.testmod()






