





import argparse
import datetime


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

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

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

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

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

       # Get day
       A__											=						int(date_input[3] + date_input[4]  )
       # Validate
       if not 0 < d < 32:
              raise ValueError('''Date must be between 1 - 31'''  )

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

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

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


if __name__ == "__main__":
       import doctest

       doctest.testmod()
       a__:      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)'
       )
       a__:      Optional[int]									=		parser.parse_args()
       zeller(args.date_input)












import random


def 	UpperCamelCase__(       UpperCamelCase__			:       list ,     UpperCamelCase__			:       List[Any]  )->tuple:
       A__					,	A__					,	A__											=						[], [], []
       for element in data:
              if element < pivot:
                     less.append(UpperCamelCase__  )
              elif element > pivot:
                     greater.append(UpperCamelCase__  )
              else:
                     equal.append(UpperCamelCase__  )
       return less, equal, greater


def 	UpperCamelCase__(       UpperCamelCase__			:       list ,     UpperCamelCase__			:       int  )->Optional[int]:
       # index = len(items) // 2 when trying to find the median
       #   (value of index when items is sorted)

       # invalid input
       if index >= len(UpperCamelCase__  ) or index < 0:
              return None

       A__											=						items[random.randint(0 ,     len(UpperCamelCase__  ) - 1  )]
       A__											=						0
       A__					,	A__					,	A__											=						_partition(UpperCamelCase__ ,     UpperCamelCase__  )
       A__											=						len(UpperCamelCase__  )
       A__											=						len(UpperCamelCase__  )

       # index is the pivot
       if m <= index < m + count:
              return pivot
       # must be in smaller
       elif m > index:
              return quick_select(UpperCamelCase__ ,     UpperCamelCase__  )
       # must be in larger
       else:
              return quick_select(UpperCamelCase__ ,     index - (m + count)  )





