






from __future__ import annotations

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

class        lowerCAmelCase_				:







				"""simple docstring"""




				def __init__( self     :Dict  ,     lowerCamelCase__     :Collection[float] | None = None     ):
					if components is None:
						UpperCamelCase__ :Tuple						=      []
					UpperCamelCase__ :Optional[Any]						=      list(lowerCamelCase__     )







				def __len__( self     :List[Any]     ):
					return len(self.__components     )







				def __str__( self     :List[Any]     ):
					return "(" + ",".join(map(lowerCamelCase__  ,     self.__components     )     ) + ")"







				def __add__( self     :List[Any]  ,     lowerCamelCase__     :Vector     ):
					UpperCamelCase__ :Optional[int]						=      len(self     )
					if size == len(lowerCamelCase__     ):
						UpperCamelCase__ :List[Any]						=      [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     :Any  ,     lowerCamelCase__     :Vector     ):
					UpperCamelCase__ :List[Any]						=      len(self     )
					if size == len(lowerCamelCase__     ):
						UpperCamelCase__ :Dict						=      [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     :str  ,     lowerCamelCase__     :float     ):
					...







				@overload
				def __mul__( self     :Union[str, Any]  ,     lowerCamelCase__     :Vector     ):
					...







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







				def 				__a   ( self     :Dict     ):
					return Vector(self.__components     )







				def 				__a   ( self     :Optional[Any]  ,     lowerCamelCase__     :int     ):
					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     :Optional[Any]  ,     lowerCamelCase__     :int  ,     lowerCamelCase__     :float     ):
					assert -len(self.__components     ) <= pos < len(self.__components     )
					UpperCamelCase__ :List[Any]						=      value







				def 				__a   ( self     :Optional[Any]     ):
					if len(self.__components     ) == 0:
						raise Exception("""Vector is empty"""     )
					UpperCamelCase__ :List[Any]						=      [c**2 for c in self.__components]
					return math.sqrt(sum(lowerCamelCase__     )     )







				def 				__a   ( self     :Any  ,     lowerCamelCase__     :Vector  ,     lowerCamelCase__     :bool = False     ):
					UpperCamelCase__ :Tuple						=      self * other
					UpperCamelCase__ :Tuple						=      self.euclidean_length() * other.euclidean_length()
					if deg:
						return math.degrees(math.acos(num / den     )     )
					else:
						return math.acos(num / den     )




def 				A		(					lowercase__  :  int  )		-> Vector:
	assert isinstance(lowercase__ ,		lowercase__  )
	return Vector([0] * dimension  )




def 				A		(					lowercase__  :  int ,		lowercase__  :  int  )		-> Vector:
	assert isinstance(lowercase__ ,		lowercase__  ) and (isinstance(lowercase__ ,		lowercase__  ))
	UpperCamelCase__ :List[Any]						=      [0] * dimension
	UpperCamelCase__ :int						=      1
	return Vector(lowercase__  )




def 				A		(					lowercase__  :  float ,		lowercase__  :  Vector ,		lowercase__  :  Vector  )		-> Vector:
	assert (
	    isinstance(lowercase__ ,		lowercase__  )
	    and isinstance(lowercase__ ,		lowercase__  )
	    and (isinstance(lowercase__ ,		(int, float)  ))
	)
	return x * scalar + y




def 				A		(					lowercase__  :  int ,		lowercase__  :  int ,		lowercase__  :  int  )		-> Vector:
	random.seed(lowercase__  )
	UpperCamelCase__ :Tuple						=      [random.randint(lowercase__ ,		lowercase__  ) for _ in range(lowercase__  )]
	return Vector(lowercase__  )

class        lowerCAmelCase_				:







				"""simple docstring"""




				def __init__( self     :List[str]  ,     lowerCamelCase__     :list[list[float]]  ,     lowerCamelCase__     :int  ,     lowerCamelCase__     :int     ):
					UpperCamelCase__ :List[Any]						=      matrix
					UpperCamelCase__ :Dict						=      w
					UpperCamelCase__ :int						=      h







				def __str__( self     :Tuple     ):
					UpperCamelCase__ :Tuple						=      """"""
					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     :List[str]  ,     lowerCamelCase__     :Matrix     ):
					if self.__width == other.width() and self.__height == other.height():
						UpperCamelCase__ :Any						=      []
						for i in range(self.__height     ):
							UpperCamelCase__ :Dict						=      [
							    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     :List[Any]  ,     lowerCamelCase__     :Matrix     ):
					if self.__width == other.width() and self.__height == other.height():
						UpperCamelCase__ :List[Any]						=      []
						for i in range(self.__height     ):
							UpperCamelCase__ :Optional[int]						=      [
							    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     :Dict  ,     lowerCamelCase__     :float     ):
					...







				@overload
				def __mul__( self     :Optional[int]  ,     lowerCamelCase__     :Vector     ):
					...







				def __mul__( self     :Optional[Any]  ,     lowerCamelCase__     :float | Vector     ):
					if isinstance(lowerCamelCase__  ,     lowerCamelCase__     ):  # matrix-vector
						if len(lowerCamelCase__     ) == self.__width:
							UpperCamelCase__ :List[Any]						=      zero_vector(self.__height     )
							for i in range(self.__height     ):
								UpperCamelCase__ :Union[str, Any]						=      [
								    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
						UpperCamelCase__ :str						=      [
						    [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     :Dict     ):
					return self.__height







				def 				__a   ( self     :int     ):
					return self.__width







				def 				__a   ( self     :List[str]  ,     lowerCamelCase__     :int  ,     lowerCamelCase__     :int     ):
					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     :Optional[Any]  ,     lowerCamelCase__     :int  ,     lowerCamelCase__     :int  ,     lowerCamelCase__     :float     ):
					if 0 <= x < self.__height and 0 <= y < self.__width:
						UpperCamelCase__ :List[str]						=      value
					else:
						raise Exception("""change_component: indices out of bounds"""     )







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







				def 				__a   ( self     :str  ,     lowerCamelCase__     :int  ,     lowerCamelCase__     :int     ):
					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     :int     ):
					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__ :str						=      [
						    self.__matrix[0][y] * self.cofactor(0  ,     lowerCamelCase__     ) for y in range(self.__width     )
						]
						return sum(lowerCamelCase__     )




def 				A		(					lowercase__  :  int  )		-> Matrix:
	UpperCamelCase__ :list[list[float]]						=      [[0] * n for _ in range(lowercase__  )]
	return Matrix(lowercase__ ,		lowercase__ ,		lowercase__  )




def 				A		(					lowercase__  :  int ,		lowercase__  :  int ,		lowercase__  :  int ,		lowercase__  :  int  )		-> Matrix:
	random.seed(lowercase__  )
	UpperCamelCase__ :list[list[float]]						=      [
	    [random.randint(lowercase__ ,		lowercase__  ) for _ in range(lowercase__  )] for _ in range(lowercase__  )
	]
	return Matrix(lowercase__ ,		lowercase__ ,		lowercase__  )
from __future__ import annotations




def    lowerCAmelCase_  (		lowercase:				str	,       lowercase:				list[str] | None = None	,       lowercase:				dict[str, float] | None = None	,       lowercase:				bool = False	,       )     ->					tuple[int, float, str]:







 '''simple docstring'''
 _UpperCamelCase:  Any    						=			cipher_alphabet or [chr(lowercase		) for i in range(97	,       123		)]

 # If the argument is None or the user provided an empty dictionary
 if not frequencies_dict:
  # Frequencies of letters in the english language (how much they show up)
  _UpperCamelCase:  Any    						=			{
      '''a''': 0.08497,
      '''b''': 0.01492,
      '''c''': 0.02202,
      '''d''': 0.04253,
      '''e''': 0.11162,
      '''f''': 0.02228,
      '''g''': 0.02015,
      '''h''': 0.06094,
      '''i''': 0.07546,
      '''j''': 0.00153,
      '''k''': 0.01292,
      '''l''': 0.04025,
      '''m''': 0.02406,
      '''n''': 0.06749,
      '''o''': 0.07507,
      '''p''': 0.01929,
      '''q''': 0.00095,
      '''r''': 0.07587,
      '''s''': 0.06327,
      '''t''': 0.09356,
      '''u''': 0.02758,
      '''v''': 0.00978,
      '''w''': 0.02560,
      '''x''': 0.00150,
      '''y''': 0.01994,
      '''z''': 0.00077,
  }
 else:
  # Custom frequencies dictionary
  _UpperCamelCase:  str    						=			frequencies_dict

 if not case_sensitive:
  _UpperCamelCase:  Union[str, Any]    						=			ciphertext.lower()

 # Chi squared statistic values
 _UpperCamelCase:  dict[int, tuple[float, str]]    						=			{}

 # cycle through all of the shifts
 for shift in range(len(lowercase		)		):
  _UpperCamelCase:  Tuple    						=			''''''

  # decrypt the message with the shift
  for letter in ciphertext:
   try:
    # Try to index the letter in the alphabet
    _UpperCamelCase:  Optional[int]    						=			(alphabet_letters.index(letter.lower()		) - shift) % len(
        lowercase		)
    decrypted_with_shift += (
        alphabet_letters[new_key].upper()
        if case_sensitive and letter.isupper()
        else alphabet_letters[new_key]
    )
   except ValueError:
    # Append the character if it isn't in the alphabet
    decrypted_with_shift += letter

  _UpperCamelCase:  Optional[int]    						=			0.0

  # Loop through each letter in the decoded message with the shift
  for letter in decrypted_with_shift:
   if case_sensitive:
    _UpperCamelCase:  Optional[int]    						=			letter.lower()
    if letter in frequencies:
     # Get the amount of times the letter occurs in the message
     _UpperCamelCase:  Any    						=			decrypted_with_shift.lower().count(lowercase		)

     # Get the excepcted amount of times the letter should appear based
     # on letter frequencies
     _UpperCamelCase:  int    						=			frequencies[letter] * occurrences

     # Complete the chi squared statistic formula
     _UpperCamelCase:  int    						=			((occurrences - expected) ** 2) / expected

     # Add the margin of error to the total chi squared statistic
     chi_squared_statistic += chi_letter_value
   else:
    if letter.lower() in frequencies:
     # Get the amount of times the letter occurs in the message
     _UpperCamelCase:  List[Any]    						=			decrypted_with_shift.count(lowercase		)

     # Get the excepcted amount of times the letter should appear based
     # on letter frequencies
     _UpperCamelCase:  Union[str, Any]    						=			frequencies[letter] * occurrences

     # Complete the chi squared statistic formula
     _UpperCamelCase:  List[str]    						=			((occurrences - expected) ** 2) / expected

     # Add the margin of error to the total chi squared statistic
     chi_squared_statistic += chi_letter_value

        # Add the data to the chi_squared_statistic_values dictionary
  _UpperCamelCase:  List[Any]    						=			(
      chi_squared_statistic,
      decrypted_with_shift,
  )

 # Get the most likely cipher by finding the cipher with the smallest chi squared
 # statistic
 def chi_squared_statistic_values_sorting_key(lowercase:				int		) -> tuple[float, str]:
  return chi_squared_statistic_values[key]

 _UpperCamelCase:  int    						=			min(
     lowercase	,       key=lowercase	,       )

 # Get all the data from the most likely cipher (key, decoded message)
 (
     (
     _UpperCamelCase
 )						,				(
     _UpperCamelCase
 )						,				
 ):  str    						=			chi_squared_statistic_values[most_likely_cipher]

 # Return the data on the most likely shift
 return (
     most_likely_cipher,
     most_likely_cipher_chi_squared_value,
     decoded_most_likely_cipher,
 )