



import argparse
import datetime






def lowerCamelCase__   (							snake_case_     :  Union[str, Any]	)				->    Any:
   __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(snake_case_	) < 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(snake_case_	)	,				int(snake_case_	)	,				int(snake_case_	)	)

   # Start math
   if m <= 2:
      __snake_case								=       y - 1
      __snake_case								=       m + 12
   # maths var
   __snake_case								=       int(str(snake_case_	)[:2]	)
   __snake_case								=       int(str(snake_case_	)[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(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)








class 		SCREAMING_SNAKE_CASE__    :


      def __init__(self	:				str    ,      a__	:				list				):





         """simple docstring"""



         __snake_case								=       set_counts
         __snake_case								=       max(a__				)
         __snake_case								=       len(a__				)
         __snake_case								=       [1] * num_sets
         __snake_case								=       list(range(a__				)				)


      def        a			(self	:				str    ,      a__	:				int    ,      a__	:				int				):





         """simple docstring"""



         __snake_case								=       self.get_parent(a__				)
         __snake_case								=       self.get_parent(a__				)

         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]
            __snake_case								=       0
            __snake_case								=       dst_parent
            if self.ranks[dst_parent] == self.ranks[src_parent]:
               self.ranks[dst_parent] += 1
            __snake_case								=       self.set_counts[dst_parent]
         else:
            self.set_counts[src_parent] += self.set_counts[dst_parent]
            __snake_case								=       0
            __snake_case								=       src_parent
            __snake_case								=       self.set_counts[src_parent]

         __snake_case								=       max(self.max_set    ,      a__				)
         return True


      def        a			(self	:				Union[str, Any]    ,      a__	:				int				):





         """simple docstring"""



         if self.parents[disj_set] == disj_set:
            return disj_set
         __snake_case								=       self.get_parent(self.parents[disj_set]				)
         return self.parents[disj_set]

