






import argparse
import datetime
def      a_ (      _A  )			->			str:







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

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

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

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

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

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

				# Get year
				snake_case__									=     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
				snake_case__									=     datetime.date(int(_A  )      ,   int(_A  )      ,   int(_A  )  )

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


if __name__ == "__main__":
							import doctest

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












from __future__ import annotations

from collections.abc import Iterator
from typing import Any


class   __SCREAMING_SNAKE_CASE:
							def __init__(     self:      int       ,	UpperCamelCase:      Any						)		->		List[Any]:
											snake_case__									=     data
											snake_case__									=     None


class   __SCREAMING_SNAKE_CASE:
							def __init__(     self:      Dict						)		->		Optional[Any]:
											snake_case__									=     None
											snake_case__									=     None
							def __iter__(     self:      Optional[int]						)		->		Iterator[Any]:
											snake_case__									=     self.head
											while self.head:
															yield node.data
															snake_case__									=     node.next
															if node == self.head:
																			break
							def __len__(     self:      int						)		->		int:
											return sum(1 for _ in self						)
							def __repr__(     self:      int						)		->		Optional[int]:
											return "->".join(str(UpperCamelCase						) for item in iter(self						)						)
							def lowerCAmelCase_ (     self:      Union[str, Any]       ,	UpperCamelCase:      Any						)		->		None:
											self.insert_nth(len(self						)       ,	UpperCamelCase						)
							def lowerCAmelCase_ (     self:      Tuple       ,	UpperCamelCase:      Any						)		->		None:
											self.insert_nth(0       ,	UpperCamelCase						)
							def lowerCAmelCase_ (     self:      int       ,	UpperCamelCase:      int       ,	UpperCamelCase:      Any						)		->		None:
											if index < 0 or index > len(self						):
															raise IndexError('list index out of range.'						)
											snake_case__									=     Node(UpperCamelCase						)
											if self.head is None:
															snake_case__									=     new_node  # first node points itself
															snake_case__									=     snake_case__									=     new_node
											elif index == 0:  # insert at head
															snake_case__									=     self.head
															snake_case__									=     snake_case__									=     new_node
											else:
															snake_case__									=     self.head
															for _ in range(index - 1						):
																			snake_case__									=     temp.next
															snake_case__									=     temp.next
															snake_case__									=     new_node
															if index == len(self						) - 1:  # insert at tail
																			snake_case__									=     new_node
							def lowerCAmelCase_ (     self:      Optional[int]						)		->		Union[str, Any]:
											return self.delete_nth(0						)
							def lowerCAmelCase_ (     self:      Union[str, Any]						)		->		Any:
											return self.delete_nth(len(self						) - 1						)
							def lowerCAmelCase_ (     self:      str       ,	UpperCamelCase:      int = 0						)		->		Any:
											if not 0 <= index < len(self						):
															raise IndexError('list index out of range.'						)
											snake_case__									=     self.head
											if self.head == self.tail:  # just one node
															snake_case__									=     snake_case__									=     None
											elif index == 0:  # delete head node
															snake_case__									=     self.tail.next.next
															snake_case__									=     self.head.next
											else:
															snake_case__									=     self.head
															for _ in range(index - 1						):
																			snake_case__									=     temp.next
															snake_case__									=     temp.next
															snake_case__									=     temp.next.next
															if index == len(self						) - 1:  # delete at tail
																			snake_case__									=     temp
											return delete_node.data


							def lowerCAmelCase_ (     self:      Union[str, Any]						)		->		bool:
											return len(self						) == 0


def      a_ (      )			->			None:







				"""simple docstring"""
				snake_case__									=     CircularLinkedList()
				assert len(_A  ) == 0
				assert circular_linked_list.is_empty() is True
				assert str(_A  ) == ""

				try:
								circular_linked_list.delete_front()
								raise AssertionError  # This should not happen
				except IndexError:
								assert True  # This should happen

				try:
								circular_linked_list.delete_tail()
								raise AssertionError  # This should not happen
				except IndexError:
								assert True  # This should happen

				try:
								circular_linked_list.delete_nth(-1  )
								raise AssertionError
				except IndexError:
								assert True

				try:
								circular_linked_list.delete_nth(0  )
								raise AssertionError
				except IndexError:
								assert True

				assert circular_linked_list.is_empty() is True
				for i in range(5  ):
								assert len(_A  ) == i
								circular_linked_list.insert_nth(_A      ,   i + 1  )
				assert str(_A  ) == "->".join(str(_A  ) for i in range(1      ,   6  )  )

				circular_linked_list.insert_tail(6  )
				assert str(_A  ) == "->".join(str(_A  ) for i in range(1      ,   7  )  )
				circular_linked_list.insert_head(0  )
				assert str(_A  ) == "->".join(str(_A  ) for i in range(0      ,   7  )  )

				assert circular_linked_list.delete_front() == 0
				assert circular_linked_list.delete_tail() == 6
				assert str(_A  ) == "->".join(str(_A  ) for i in range(1      ,   6  )  )
				assert circular_linked_list.delete_nth(2  ) == 3

				circular_linked_list.insert_nth(2      ,   3  )
				assert str(_A  ) == "->".join(str(_A  ) for i in range(1      ,   6  )  )

				assert circular_linked_list.is_empty() is False


if __name__ == "__main__":
							import doctest

							doctest.testmod()




