


"""simple docstring"""



import argparse
import datetime







def 						__lowerCAmelCase		(		lowercase						:						str				)			->		Dict:


    """simple docstring"""





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

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

    # Validate
    if not 0 < len(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 < 8500:
        raise ValueError(
            "Year out of range. There has to be some sort of limit...right?"				)

    # Get datetime obj for validation
    snake_case					:   Dict         =					datetime.date(int(snake_case_				)		,							int(snake_case_				)		,							int(snake_case_				)				)

    # Start math
    if m <= 2:
        snake_case					:   str         =					y - 1
        snake_case					:   Optional[Any]         =					m + 12
    # maths var
    snake_case					:   int         =					int(str(snake_case_				)[:2]				)
    snake_case					:   int         =					int(str(snake_case_				)[2:]				)
    snake_case					:   int         =					int(2.6 * m - 5.39				)
    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(snake_case_				)]}!'
    return response


if __name__ == "__main__":
  import doctest

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









"""simple docstring"""



from __future__ import annotations

from cmath import sqrt







def 						__lowerCAmelCase		(		lowercase						:						int		,							lowercase						:						int		,							lowercase						:						int				)			->		tuple[complex, complex]:


    """simple docstring"""





    if a == 0:
        raise ValueError("Coefficient 'a' must not be zero."				)
    snake_case					:   Dict         =					b * b - 4 * a * c

    snake_case					:   Tuple         =					(-b + sqrt(lowercase				)) / (2 * a)
    snake_case					:   Optional[int]         =					(-b - sqrt(lowercase				)) / (2 * a)

    return (
        root_a.real if not root_a.imag else root_a,
        root_a.real if not root_a.imag else root_a,
    )







def 						__lowerCAmelCase		(		)			->		List[Any]:


    """simple docstring"""





    snake_case      ,snake_case					:   Optional[Any]         =					quadratic_roots(a=5		,							b=6		,							c=1				)
    print(F'The solutions are: {solutiona} and {solutiona}'				)


if __name__ == "__main__":
  main()





