





'''simple docstring'''






from __future__ import annotations

import math
import random
from collections.abc import Collection
from typing import overload







class 		UpperCAmelCase   :


  """simple docstring"""







  def __init__(				self    :					List[Any]							,	UpperCamelCase__    :					Collection[float] | None = None  )     ->						None:
    if components is None:
      _UpperCamelCase       			=[]
    _UpperCamelCase       			=list(UpperCamelCase__  )


  def __len__(				self    :					Dict  )     ->						int:
    return len(self.__components  )


  def __str__(				self    :					Union[str, Any]  )     ->						str:
    return "(" + ",".join(map(UpperCamelCase__							,	self.__components  )  ) + ")"


  def __add__(				self    :					int							,	UpperCamelCase__    :					Vector  )     ->						Vector:
    _UpperCamelCase       			=len(self  )
    if size == len(UpperCamelCase__  ):
      _UpperCamelCase       			=[self.__components[i] + other.component(UpperCamelCase__  ) for i in range(UpperCamelCase__  )]
      return Vector(UpperCamelCase__  )
    else:
      raise Exception('''must have the same size'''  )


  def __sub__(				self    :					Dict							,	UpperCamelCase__    :					Vector  )     ->						Vector:
    _UpperCamelCase       			=len(self  )
    if size == len(UpperCamelCase__  ):
      _UpperCamelCase       			=[self.__components[i] - other.component(UpperCamelCase__  ) for i in range(UpperCamelCase__  )]
      return Vector(UpperCamelCase__  )
    else:  # error case
      raise Exception('''must have the same size'''  )


  @overload
  def __mul__(				self    :					Optional[Any]							,	UpperCamelCase__    :					float  )     ->						Vector:
    ...


  @overload
  def __mul__(				self    :					int							,	UpperCamelCase__    :					Vector  )     ->						float:
    ...


  def __mul__(				self    :					Union[str, Any]							,	UpperCamelCase__    :					float | Vector  )     ->						float | Vector:
    if isinstance(UpperCamelCase__							,	(float, int)  ):
      _UpperCamelCase       			=[c * other for c in self.__components]
      return Vector(UpperCamelCase__  )
    elif isinstance(UpperCamelCase__							,	UpperCamelCase__  ) and len(self  ) == len(UpperCamelCase__  ):
      _UpperCamelCase       			=len(self  )
      _UpperCamelCase       			=[self.__components[i] * other.component(UpperCamelCase__  ) for i in range(UpperCamelCase__  )]
      return sum(UpperCamelCase__  )
    else:  # error case
      raise Exception('''invalid operand!'''  )


  def   UpperCamelCase__      (				self    :					List[Any]  )     ->						Vector:
    return Vector(self.__components  )


  def   UpperCamelCase__      (				self    :					int							,	UpperCamelCase__    :					int  )     ->						float:
    if isinstance(UpperCamelCase__							,	UpperCamelCase__  ) and -len(self.__components  ) <= i < len(self.__components  ):
      return self.__components[i]
    else:
      raise Exception('''index out of range'''  )


  def   UpperCamelCase__      (				self    :					Union[str, Any]							,	UpperCamelCase__    :					int							,	UpperCamelCase__    :					float  )     ->						None:
    assert -len(self.__components  ) <= pos < len(self.__components  )
    _UpperCamelCase       			=value


  def   UpperCamelCase__      (				self    :					List[str]  )     ->						float:
    if len(self.__components  ) == 0:
      raise Exception('''Vector is empty'''  )
    _UpperCamelCase       			=[c**2 for c in self.__components]
    return math.sqrt(sum(UpperCamelCase__  )  )




  def   UpperCamelCase__      (				self    :					Any							,	UpperCamelCase__    :					Vector							,	UpperCamelCase__    :					bool = False  )     ->						float:
    _UpperCamelCase       			=self * other
    _UpperCamelCase       			=self.euclidean_length() * other.euclidean_length()
    if deg:
      return math.degrees(math.acos(num / den  )  )
    else:
      return math.acos(num / den  )




def 					_a   (__SCREAMING_SNAKE_CASE   ):


  """simple docstring"""

  assert isinstance(__SCREAMING_SNAKE_CASE  ,      __SCREAMING_SNAKE_CASE   )
  return Vector([0] * dimension   )


def 					_a   (__SCREAMING_SNAKE_CASE  ,      __SCREAMING_SNAKE_CASE   ):


  """simple docstring"""

  assert isinstance(__SCREAMING_SNAKE_CASE  ,      __SCREAMING_SNAKE_CASE   ) and (isinstance(__SCREAMING_SNAKE_CASE  ,      __SCREAMING_SNAKE_CASE   ))
  _UpperCamelCase       			=[0] * dimension
  _UpperCamelCase       			=1
  return Vector(__SCREAMING_SNAKE_CASE   )


def 					_a   (__SCREAMING_SNAKE_CASE  ,      __SCREAMING_SNAKE_CASE  ,      __SCREAMING_SNAKE_CASE   ):


  """simple docstring"""

  assert (
      isinstance(__SCREAMING_SNAKE_CASE  ,      __SCREAMING_SNAKE_CASE   )
      and isinstance(__SCREAMING_SNAKE_CASE  ,      __SCREAMING_SNAKE_CASE   )
      and (isinstance(__SCREAMING_SNAKE_CASE  ,      (int, float)   ))
  )
  return x * scalar + y


def 					_a   (__SCREAMING_SNAKE_CASE  ,      __SCREAMING_SNAKE_CASE  ,      __SCREAMING_SNAKE_CASE   ):


  """simple docstring"""

  random.seed(__SCREAMING_SNAKE_CASE   )
  _UpperCamelCase       			=[random.randint(__SCREAMING_SNAKE_CASE  ,      __SCREAMING_SNAKE_CASE   ) for _ in range(__SCREAMING_SNAKE_CASE   )]
  return Vector(__SCREAMING_SNAKE_CASE   )







class 		UpperCAmelCase   :


  """simple docstring"""







  def __init__(				self    :					Optional[int]							,	UpperCamelCase__    :					list[list[float]]							,	UpperCamelCase__    :					int							,	UpperCamelCase__    :					int  )     ->						None:
    _UpperCamelCase       			=matrix
    _UpperCamelCase       			=w
    _UpperCamelCase       			=h


  def __str__(				self    :					Optional[Any]  )     ->						str:
    _UpperCamelCase       			=''''''
    for i in range(self.__height  ):
      ans += "|"
      for j in range(self.__width  ):
        if j < self.__width - 1:
          ans += str(self.__matrix[i][j]  ) + ","
        else:
          ans += str(self.__matrix[i][j]  ) + "|\n"
    return ans


  def __add__(				self    :					Optional[Any]							,	UpperCamelCase__    :					Matrix  )     ->						Matrix:
    if self.__width == other.width() and self.__height == other.height():
      _UpperCamelCase       			=[]
      for i in range(self.__height  ):
        _UpperCamelCase       			=[
            self.__matrix[i][j] + other.component(UpperCamelCase__							,	UpperCamelCase__  )
            for j in range(self.__width  )
        ]
        matrix.append(UpperCamelCase__  )
      return Matrix(UpperCamelCase__							,	self.__width							,	self.__height  )
    else:
      raise Exception('''matrix must have the same dimension!'''  )


  def __sub__(				self    :					List[Any]							,	UpperCamelCase__    :					Matrix  )     ->						Matrix:
    if self.__width == other.width() and self.__height == other.height():
      _UpperCamelCase       			=[]
      for i in range(self.__height  ):
        _UpperCamelCase       			=[
            self.__matrix[i][j] - other.component(UpperCamelCase__							,	UpperCamelCase__  )
            for j in range(self.__width  )
        ]
        matrix.append(UpperCamelCase__  )
      return Matrix(UpperCamelCase__							,	self.__width							,	self.__height  )
    else:
      raise Exception('''matrices must have the same dimension!'''  )


  @overload
  def __mul__(				self    :					List[Any]							,	UpperCamelCase__    :					float  )     ->						Matrix:
    ...


  @overload
  def __mul__(				self    :					List[Any]							,	UpperCamelCase__    :					Vector  )     ->						Vector:
    ...


  def __mul__(				self    :					int							,	UpperCamelCase__    :					float | Vector  )     ->						Vector | Matrix:
    if isinstance(UpperCamelCase__							,	UpperCamelCase__  ):  # matrix-vector
      if len(UpperCamelCase__  ) == self.__width:
        _UpperCamelCase       			=zero_vector(self.__height  )
        for i in range(self.__height  ):
          _UpperCamelCase       			=[
              self.__matrix[i][j] * other.component(UpperCamelCase__  )
              for j in range(self.__width  )
          ]
          ans.change_component(UpperCamelCase__							,	sum(UpperCamelCase__  )  )
        return ans
      else:
        raise Exception(
            '''vector must have the same size as the '''
            '''number of columns of the matrix!'''  )
    elif isinstance(UpperCamelCase__							,	(int, float)  ):  # matrix-scalar
      _UpperCamelCase       			=[
          [self.__matrix[i][j] * other for j in range(self.__width  )]
          for i in range(self.__height  )
      ]
      return Matrix(UpperCamelCase__							,	self.__width							,	self.__height  )
    return None


  def   UpperCamelCase__      (				self    :					Optional[Any]  )     ->						int:
    return self.__height


  def   UpperCamelCase__      (				self    :					int  )     ->						int:
    return self.__width


  def   UpperCamelCase__      (				self    :					int							,	UpperCamelCase__    :					int							,	UpperCamelCase__    :					int  )     ->						float:
    if 0 <= x < self.__height and 0 <= y < self.__width:
      return self.__matrix[x][y]
    else:
      raise Exception('''change_component: indices out of bounds'''  )


  def   UpperCamelCase__      (				self    :					List[Any]							,	UpperCamelCase__    :					int							,	UpperCamelCase__    :					int							,	UpperCamelCase__    :					float  )     ->						None:
    if 0 <= x < self.__height and 0 <= y < self.__width:
      _UpperCamelCase       			=value
    else:
      raise Exception('''change_component: indices out of bounds'''  )


  def   UpperCamelCase__      (				self    :					List[str]							,	UpperCamelCase__    :					int							,	UpperCamelCase__    :					int  )     ->						float:
    if self.__height != self.__width:
      raise Exception('''Matrix is not square'''  )
    _UpperCamelCase       			=self.__matrix[:x] + self.__matrix[x + 1 :]
    for i in range(len(UpperCamelCase__  )  ):
      _UpperCamelCase       			=minor[i][:y] + minor[i][y + 1 :]
    return Matrix(UpperCamelCase__							,	self.__width - 1							,	self.__height - 1  ).determinant()


  def   UpperCamelCase__      (				self    :					Optional[int]							,	UpperCamelCase__    :					int							,	UpperCamelCase__    :					int  )     ->						float:
    if self.__height != self.__width:
      raise Exception('''Matrix is not square'''  )
    if 0 <= x < self.__height and 0 <= y < self.__width:
      return (-1) ** (x + y) * self.minor(UpperCamelCase__							,	UpperCamelCase__  )
    else:
      raise Exception('''Indices out of bounds'''  )




  def   UpperCamelCase__      (				self    :					int  )     ->						float:
    if self.__height != self.__width:
      raise Exception('''Matrix is not square'''  )
    if self.__height < 1:
      raise Exception('''Matrix has no element'''  )
    elif self.__height == 1:
      return self.__matrix[0][0]
    elif self.__height == 2:
      return (
          self.__matrix[0][0] * self.__matrix[1][1]
          - self.__matrix[0][1] * self.__matrix[1][0]
      )
    else:
      _UpperCamelCase       			=[
          self.__matrix[0][y] * self.cofactor(0							,	UpperCamelCase__  ) for y in range(self.__width  )
      ]
      return sum(UpperCamelCase__  )




def 					_a   (__SCREAMING_SNAKE_CASE   ):


  """simple docstring"""

  _UpperCamelCase       			=[[0] * n for _ in range(__SCREAMING_SNAKE_CASE   )]
  return Matrix(__SCREAMING_SNAKE_CASE  ,      __SCREAMING_SNAKE_CASE  ,      __SCREAMING_SNAKE_CASE   )


def 					_a   (__SCREAMING_SNAKE_CASE  ,      __SCREAMING_SNAKE_CASE  ,      __SCREAMING_SNAKE_CASE  ,      __SCREAMING_SNAKE_CASE   ):


  """simple docstring"""

  random.seed(__SCREAMING_SNAKE_CASE   )
  _UpperCamelCase       			=[
      [random.randint(__SCREAMING_SNAKE_CASE  ,      __SCREAMING_SNAKE_CASE   ) for _ in range(__SCREAMING_SNAKE_CASE   )] for _ in range(__SCREAMING_SNAKE_CASE   )
  ]
  return Matrix(__SCREAMING_SNAKE_CASE  ,      __SCREAMING_SNAKE_CASE  ,      __SCREAMING_SNAKE_CASE   )













'''simple docstring'''






import argparse
import datetime


def 					_a   (__SCREAMING_SNAKE_CASE   ):


  """simple docstring"""

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

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

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

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

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

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

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


if __name__ == "__main__":
      import doctest

      doctest.testmod()
      __lowerCamelCase						: List[Any]		=   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)'
      )
      __lowerCamelCase						: Union[str, Any]		=   parser.parse_args()
      zeller(args.date_input)






