'''simple docstring'''

import argparse
import datetime







def __UpperCamelCase(   _A					:				str    ):
   '''simple docstring'''
   UpperCAmelCase__							:				str   				=  {
       """0""": """Sunday""",
       """1""": """Monday""",
       """2""": """Tuesday""",
       """3""": """Wednesday""",
       """4""": """Thursday""",
       """5""": """Friday""",
       """6""": """Saturday""",
   }

   UpperCAmelCase__							:				Optional[int]   				=  {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
   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__							:				Union[str, Any]   				=  datetime.date(int(_A    )  ,			int(_A    )  ,			int(_A    )    )

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


if __name__ == "__main__":
  import doctest

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





'''simple docstring'''

import math







def __UpperCamelCase(   _A					:				float  ,			_A					:				float    ):
   '''simple docstring'''
   return math.pow(_A  ,			2    ) - a







def __UpperCamelCase(   _A					:				float    ):
   '''simple docstring'''
   return 2 * x







def __UpperCamelCase(   _A					:				float    ):
   '''simple docstring'''
   UpperCAmelCase__							:				int   				=  2.0

   while start <= a:
      UpperCAmelCase__							:				int   				=  math.pow(_A  ,			2    )

   return start







def __UpperCamelCase(   _A					:				float  ,			_A					:				int = 99_99  ,			_A					:				float = 0.0_0_0_0_0_0_0_0_0_0_0_0_0_1    ):
   '''simple docstring'''

   if a < 0:
      raise ValueError('''math domain error'''    )

   UpperCAmelCase__							:				Any   				=  get_initial_point(_A    )

   for _ in range(_A    ):
      UpperCAmelCase__							:				Optional[Any]   				=  value
      UpperCAmelCase__							:				Tuple   				=  value - fx(_A  ,			_A    ) / fx_derivative(_A    )
      if abs(prev_value - value    ) < tolerance:
         return value

   return value


if __name__ == "__main__":
  from doctest import testmod

  testmod()




