'''simple docstring'''




from __future__ import annotations

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






class 				a__:


			'''simple docstring'''






			def __init__(   self       ,    __lowerCAmelCase = None):




					"""simple docstring"""


					if components is None:
							lowerCAmelCase   					=  []
					lowerCAmelCase   					=  list(__lowerCAmelCase)



			def __len__(   self):




					"""simple docstring"""


					return len(self.__components)



			def __str__(   self):




					"""simple docstring"""


					return "(" + ",".join(map(__lowerCAmelCase       ,    self.__components)) + ")"



			def __add__(   self       ,    __lowerCAmelCase):




					"""simple docstring"""


					lowerCAmelCase   					=  len(self)
					if size == len(__lowerCAmelCase):
							lowerCAmelCase   					=  [self.__components[i] + other.component(__lowerCAmelCase) for i in range(__lowerCAmelCase)]
							return Vector(__lowerCAmelCase)
					else:
							raise Exception("""must have the same size""")



			def __sub__(   self       ,    __lowerCAmelCase):




					"""simple docstring"""


					lowerCAmelCase   					=  len(self)
					if size == len(__lowerCAmelCase):
							lowerCAmelCase   					=  [self.__components[i] - other.component(__lowerCAmelCase) for i in range(__lowerCAmelCase)]
							return Vector(__lowerCAmelCase)
					else:  # error case
							raise Exception("""must have the same size""")



			@overload
			def __mul__(   self       ,    __lowerCAmelCase):




					"""simple docstring"""


					...



			@overload
			def __mul__(   self       ,    __lowerCAmelCase):




					"""simple docstring"""


					...



			def __mul__(   self       ,    __lowerCAmelCase):




					"""simple docstring"""


					if isinstance(__lowerCAmelCase       ,    (float, int)):
							lowerCAmelCase   					=  [c * other for c in self.__components]
							return Vector(__lowerCAmelCase)
					elif isinstance(__lowerCAmelCase       ,    __lowerCAmelCase) and len(self) == len(__lowerCAmelCase):
							lowerCAmelCase   					=  len(self)
							lowerCAmelCase   					=  [self.__components[i] * other.component(__lowerCAmelCase) for i in range(__lowerCAmelCase)]
							return sum(__lowerCAmelCase)
					else:  # error case
							raise Exception("""invalid operand!""")



			def 							a_       (   self):




					"""simple docstring"""


					return Vector(self.__components)



			def 							a_       (   self       ,    __lowerCAmelCase):




					"""simple docstring"""


					if isinstance(__lowerCAmelCase       ,    __lowerCAmelCase) and -len(self.__components) <= i < len(self.__components):
							return self.__components[i]
					else:
							raise Exception("""index out of range""")



			def 							a_       (   self       ,    __lowerCAmelCase       ,    __lowerCAmelCase):




					"""simple docstring"""


					assert -len(self.__components) <= pos < len(self.__components)
					lowerCAmelCase   					=  value



			def 							a_       (   self):




					"""simple docstring"""


					if len(self.__components) == 0:
							raise Exception("""Vector is empty""")
					lowerCAmelCase   					=  [c**2 for c in self.__components]
					return math.sqrt(sum(__lowerCAmelCase))







			def 							a_       (   self       ,    __lowerCAmelCase       ,    __lowerCAmelCase = False):




					"""simple docstring"""


					lowerCAmelCase   					=  self * other
					lowerCAmelCase   					=  self.euclidean_length() * other.euclidean_length()
					if deg:
							return math.degrees(math.acos(num / den))
					else:
							return math.acos(num / den)







def 				snake_case__							(			_A:					int )    ->	Vector:

		'''simple docstring'''


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






def 				snake_case__							(			_A:					int      ,   _A:					int )    ->	Vector:

		'''simple docstring'''


		assert isinstance(_A      ,   _A ) and (isinstance(_A      ,   _A ))
		lowerCAmelCase   					=  [0] * dimension
		lowerCAmelCase   					=  1
		return Vector(_A )






def 				snake_case__							(			_A:					float      ,   _A:					Vector      ,   _A:					Vector )    ->	Vector:

		'''simple docstring'''


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






def 				snake_case__							(			_A:					int      ,   _A:					int      ,   _A:					int )    ->	Vector:

		'''simple docstring'''


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






class 				a__:


			'''simple docstring'''






			def __init__(   self       ,    __lowerCAmelCase       ,    __lowerCAmelCase       ,    __lowerCAmelCase):




					"""simple docstring"""


					lowerCAmelCase   					=  matrix
					lowerCAmelCase   					=  w
					lowerCAmelCase   					=  h



			def __str__(   self):




					"""simple docstring"""


					lowerCAmelCase   					=  """"""
					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       ,    __lowerCAmelCase):




					"""simple docstring"""


					if self.__width == other.width() and self.__height == other.height():
							lowerCAmelCase   					=  []
							for i in range(self.__height):
									lowerCAmelCase   					=  [
									    self.__matrix[i][j] + other.component(__lowerCAmelCase       ,    __lowerCAmelCase)
									    for j in range(self.__width)
									]
									matrix.append(__lowerCAmelCase)
							return Matrix(__lowerCAmelCase       ,    self.__width       ,    self.__height)
					else:
							raise Exception("""matrix must have the same dimension!""")



			def __sub__(   self       ,    __lowerCAmelCase):




					"""simple docstring"""


					if self.__width == other.width() and self.__height == other.height():
							lowerCAmelCase   					=  []
							for i in range(self.__height):
									lowerCAmelCase   					=  [
									    self.__matrix[i][j] - other.component(__lowerCAmelCase       ,    __lowerCAmelCase)
									    for j in range(self.__width)
									]
									matrix.append(__lowerCAmelCase)
							return Matrix(__lowerCAmelCase       ,    self.__width       ,    self.__height)
					else:
							raise Exception("""matrices must have the same dimension!""")



			@overload
			def __mul__(   self       ,    __lowerCAmelCase):




					"""simple docstring"""


					...



			@overload
			def __mul__(   self       ,    __lowerCAmelCase):




					"""simple docstring"""


					...



			def __mul__(   self       ,    __lowerCAmelCase):




					"""simple docstring"""


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



			def 							a_       (   self):




					"""simple docstring"""


					return self.__height



			def 							a_       (   self):




					"""simple docstring"""


					return self.__width



			def 							a_       (   self       ,    __lowerCAmelCase       ,    __lowerCAmelCase):




					"""simple docstring"""


					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 							a_       (   self       ,    __lowerCAmelCase       ,    __lowerCAmelCase       ,    __lowerCAmelCase):




					"""simple docstring"""


					if 0 <= x < self.__height and 0 <= y < self.__width:
							lowerCAmelCase   					=  value
					else:
							raise Exception("""change_component: indices out of bounds""")



			def 							a_       (   self       ,    __lowerCAmelCase       ,    __lowerCAmelCase):




					"""simple docstring"""


					if self.__height != self.__width:
							raise Exception("""Matrix is not square""")
					lowerCAmelCase   					=  self.__matrix[:x] + self.__matrix[x + 1 :]
					for i in range(len(__lowerCAmelCase)):
							lowerCAmelCase   					=  minor[i][:y] + minor[i][y + 1 :]
					return Matrix(__lowerCAmelCase       ,    self.__width - 1       ,    self.__height - 1).determinant()



			def 							a_       (   self       ,    __lowerCAmelCase       ,    __lowerCAmelCase):




					"""simple docstring"""


					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(__lowerCAmelCase       ,    __lowerCAmelCase)
					else:
							raise Exception("""Indices out of bounds""")







			def 							a_       (   self):




					"""simple docstring"""


					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:
							lowerCAmelCase   					=  [
							    self.__matrix[0][y] * self.cofactor(0       ,    __lowerCAmelCase) for y in range(self.__width)
							]
							return sum(__lowerCAmelCase)







def 				snake_case__							(			_A:					int )    ->	Matrix:

		'''simple docstring'''


		lowerCAmelCase   					=  [[0] * n for _ in range(_A )]
		return Matrix(_A      ,   _A      ,   _A )






def 				snake_case__							(			_A:					int      ,   _A:					int      ,   _A:					int      ,   _A:					int )    ->	Matrix:

		'''simple docstring'''


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





'''simple docstring'''




from string import ascii_lowercase, ascii_uppercase






def 				snake_case__							(			_A:					str )    ->	str:

		'''simple docstring'''


		if not sentence:
				return ""
		lowerCAmelCase   					=  dict(zip(_A      ,   _A ) )
		return lower_to_upper.get(sentence[0]      ,   sentence[0] ) + sentence[1:]


if __name__ == "__main__":
						from doctest import testmod

						testmod()




