



"""simple docstring"""






import argparse
import datetime






def      snake_case__   (		__lowerCamelCase				:    str	):
			"""simple docstring"""
			lowerCamelCase__		:		List[str]			={
			    '''0''': '''Sunday''',
			    '''1''': '''Monday''',
			    '''2''': '''Tuesday''',
			    '''3''': '''Wednesday''',
			    '''4''': '''Thursday''',
			    '''5''': '''Friday''',
			    '''6''': '''Saturday''',
			}

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

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

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

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

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


if __name__ == "__main__":
		import doctest

		doctest.testmod()
		_lowercase : 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)"
		)
		_lowercase : Dict      						=						parser.parse_args()
		zeller(args.date_input)









"""simple docstring"""






class        __SCREAMING_SNAKE_CASE	:


					'''simple docstring'''





					def __init__(       self							:  Dict,  lowerCamelCase							:  list     )->					None:
								lowerCamelCase__		:		Tuple			=set_counts
								lowerCamelCase__		:		Dict			=max(lowerCamelCase     )
								lowerCamelCase__		:		Union[str, Any]			=len(lowerCamelCase     )
								lowerCamelCase__		:		List[str]			=[1] * num_sets
								lowerCamelCase__		:		str			=list(range(lowerCamelCase     )     )



					def 		snake_case       (       self							:  Tuple,  lowerCamelCase							:  int,  lowerCamelCase							:  int     )->					bool:
								lowerCamelCase__		:		List[Any]			=self.get_parent(lowerCamelCase     )
								lowerCamelCase__		:		str			=self.get_parent(lowerCamelCase     )

								if src_parent == dst_parent:
											return False

								if self.ranks[dst_parent] >= self.ranks[src_parent]:
											self.set_counts[dst_parent] += self.set_counts[src_parent]
											lowerCamelCase__		:		Tuple			=0
											lowerCamelCase__		:		int			=dst_parent
											if self.ranks[dst_parent] == self.ranks[src_parent]:
														self.ranks[dst_parent] += 1
											lowerCamelCase__		:		str			=self.set_counts[dst_parent]
								else:
											self.set_counts[src_parent] += self.set_counts[dst_parent]
											lowerCamelCase__		:		List[Any]			=0
											lowerCamelCase__		:		List[str]			=src_parent
											lowerCamelCase__		:		Dict			=self.set_counts[src_parent]

								lowerCamelCase__		:		str			=max(self.max_set,  lowerCamelCase     )
								return True




					def 		snake_case       (       self							:  Union[str, Any],  lowerCamelCase							:  int     )->					int:
								if self.parents[disj_set] == disj_set:
											return disj_set
								lowerCamelCase__		:		Tuple			=self.get_parent(self.parents[disj_set]     )
								return self.parents[disj_set]




