


'''simple docstring'''


import argparse
import datetime




def      lowerCamelCase					(      lowerCamelCase  :      str):
      A_						:  str          =				{
          """0""": """Sunday""",
          """1""": """Monday""",
          """2""": """Tuesday""",
          """3""": """Wednesday""",
          """4""": """Thursday""",
          """5""": """Friday""",
          """6""": """Saturday""",
      }

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

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

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

      # Get year
      A_						:  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
      A_						:  Union[str, Any]          =				datetime.date(int(lowerCamelCase)							,						int(lowerCamelCase)							,						int(lowerCamelCase))

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


if __name__ == "__main__":
     import doctest

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




'''simple docstring'''


from __future__ import annotations




def      lowerCamelCase					(      lowerCamelCase  :      dict							,						lowerCamelCase  :      str):
      A_   ,					A_						:  List[Any]          =				set(lowerCamelCase), [start]

      while stack:
            A_						:  Optional[Any]          =				stack.pop()
            explored.add(lowerCamelCase)
            # Differences from BFS:
            # 1) pop last element instead of first one
            # 2) add adjacent elements to stack without exploring them
            for adj in reversed(graph[v]):
                  if adj not in explored:
                        stack.append(lowerCamelCase)
      return explored


__magic_name__			=      {
    'A': ['B', 'C', 'D'],
    'B': ['A', 'D', 'E'],
    'C': ['A', 'F'],
    'D': ['B', 'D'],
    'E': ['B', 'F'],
    'F': ['C', 'E', 'G'],
    'G': ['F'],
}

if __name__ == "__main__":
     import doctest

     doctest.testmod()
     print(depth_first_search(G, 'A'))
