'''simple docstring'''

import argparse
import datetime
def       __UpperCamelCase	(       UpperCAmelCase					):
 lowercase__    :   Optional[int]						= {
     '''0''': '''Sunday''',
     '''1''': '''Monday''',
     '''2''': '''Tuesday''',
     '''3''': '''Wednesday''',
     '''4''': '''Thursday''',
     '''5''': '''Friday''',
     '''6''': '''Saturday''',
 }

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

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

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

 # Get year
 lowercase__    :   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
 lowercase__    :   Any						= datetime.date(int(UpperCAmelCase					)		,					int(UpperCAmelCase					)		,					int(UpperCAmelCase					)					)

 # Start math
 if m <= 2:
  lowercase__    :   Union[str, Any]						= y - 1
  lowercase__    :   Union[str, Any]						= m + 12
 # maths var
 lowercase__    :   int						= int(str(UpperCAmelCase					)[:2]					)
 lowercase__    :   int						= int(str(UpperCAmelCase					)[2:]					)
 lowercase__    :   int						= int(2.6 * m - 5.3_9					)
 lowercase__    :   int						= int(c / 4					)
 lowercase__    :   int						= int(k / 4					)
 lowercase__    :   int						= int(d + k					)
 lowercase__    :   int						= int(t + u + v + x					)
 lowercase__    :   int						= int(z - (2 * c)					)
 lowercase__    :   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
 lowercase__    :   str						= 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)


'''simple docstring'''

class       UpperCAmelCase  :





       '''simple docstring'''



       def __init__(						self			)  ->  List[str]:
        lowercase__    :   Dict						= {}

       def _lowerCAmelCase(						self			)  ->  None:
        print(self.vertex			)
        for i in self.vertex:
         print(__lowerCAmelCase     ,       ''' -> '''     ,       ''' -> '''.join([str(__lowerCAmelCase			) for j in self.vertex[i]]			)			)

       def _lowerCAmelCase(						self     ,       __lowerCAmelCase     ,       __lowerCAmelCase			)  ->  None:
        # check if vertex is already present,
        if from_vertex in self.vertex:
         self.vertex[from_vertex].append(__lowerCAmelCase			)
        else:
         # else make a new vertex
         lowercase__    :   Union[str, Any]						= [to_vertex]

       def _lowerCAmelCase(						self			)  ->  None:
        # visited array for storing already visited nodes
        lowercase__    :   str						= [False] * len(self.vertex			)

        # call the recursive helper function
        for i in range(len(self.vertex			)			):
         if not visited[i]:
          self.dfs_recursive(__lowerCAmelCase     ,       __lowerCAmelCase			)


       def _lowerCAmelCase(						self     ,       __lowerCAmelCase     ,       __lowerCAmelCase			)  ->  None:
        # mark start vertex as visited
        lowercase__    :   List[str]						= True

        print(__lowerCAmelCase     ,       end=''' '''			)

        # Recur for all the vertices that are adjacent to this node
        for i in self.vertex:
         if not visited[i]:
          self.dfs_recursive(__lowerCAmelCase     ,       __lowerCAmelCase			)


if __name__ == "__main__":
  __a:			Optional[Any]	       =       Graph()
  g.add_edge(0, 1)
  g.add_edge(0, 2)
  g.add_edge(1, 2)
  g.add_edge(2, 0)
  g.add_edge(2, 3)
  g.add_edge(3, 3)

  g.print_graph()
  print("""DFS:""")
  g.dfs()

  # OUTPUT:
  # 0  ->  1 -> 2
  # 1  ->  2
  # 2  ->  0 -> 3
  # 3  ->  3
  # DFS:
  #  0 1 2 3

