





import argparse
import datetime



def        __lowercase       (				_SCREAMING_SNAKE_CASE     )			->       str:


      '''simple docstring'''


      SCREAMING_SNAKE_CASE		=						{
          """0""": """Sunday""",
          """1""": """Monday""",
          """2""": """Tuesday""",
          """3""": """Wednesday""",
          """4""": """Thursday""",
          """5""": """Friday""",
          """6""": """Saturday""",
      }

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

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

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

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

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

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

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


if __name__ == "__main__":
      import doctest

      doctest.testmod()
      SCREAMING_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)"""
      )
      SCREAMING_SNAKE_CASE_						       =	parser.parse_args()
      zeller(args.date_input)









class 		UpperCamelCase__			:



     '''simple docstring'''

     def __init__(							self						:   int	)					->		str:




           '''simple docstring'''


           SCREAMING_SNAKE_CASE		=						{}






     def     SCREAMING_SNAKE_CASE__  (							self						:   List[Any]	)					->		None:




           '''simple docstring'''


           print(self.vertex	)
           for i in self.vertex:
                 print(lowerCamelCase__						,""" -> """						,""" -> """.join([str(lowerCamelCase__	) for j in self.vertex[i]]	)	)






     def     SCREAMING_SNAKE_CASE__  (							self						:   List[Any]						,lowerCamelCase__						:   int						,lowerCamelCase__						:   int	)					->		None:




           '''simple docstring'''


           if from_vertex in self.vertex:
                 self.vertex[from_vertex].append(lowerCamelCase__	)
           else:
                 # else make a new vertex
                 SCREAMING_SNAKE_CASE		=						[to_vertex]






     def     SCREAMING_SNAKE_CASE__  (							self						:   str	)					->		None:




           '''simple docstring'''


           SCREAMING_SNAKE_CASE		=						[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     SCREAMING_SNAKE_CASE__  (							self						:   Any						,lowerCamelCase__						:   int						,lowerCamelCase__						:   list	)					->		None:




           '''simple docstring'''


           SCREAMING_SNAKE_CASE		=						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__":
      SCREAMING_SNAKE_CASE_						       =	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


