from __future__ import annotations




class 			UpperCAmelCase_      :




							'''simple docstring'''



							def __init__(					self       :	str       ,     a       :	Any			)			->					List[Any]:
										SCREAMING_SNAKE_CASE           =					TypeError(
										    """Matrices must be formed from a list of zero or more lists containing at """
										    """least one and the same number of values, each of which must be of type """
										    """int or float."""			)
										if len(UpperCamelCase_			) != 0:
													SCREAMING_SNAKE_CASE           =					len(rows[0]			)
													if cols == 0:
																raise error
													for row in rows:
																if len(UpperCamelCase_			) != cols:
																			raise error
																for value in row:
																			if not isinstance(UpperCamelCase_       ,     (int, float)			):
																						raise error
													SCREAMING_SNAKE_CASE           =					rows
										else:
													SCREAMING_SNAKE_CASE           =					[]





							def    _UpperCAmelCase     (					self       :	Optional[Any]			)			->					str:
										return [[row[i] for row in self.rows] for i in range(len(self.rows[0]			)			)]





							@property
							def    _UpperCAmelCase     (					self       :	Optional[int]			)			->					Any:
										return len(self.rows			)





							@property
							def    _UpperCAmelCase     (					self       :	Tuple			)			->					int:
										return len(self.rows[0]			)





							@property
							def    _UpperCAmelCase     (					self       :	Any			)			->					Union[str, Any]:
										return (self.num_rows, self.num_columns)





							@property
							def    _UpperCAmelCase     (					self       :	List[str]			)			->					Optional[int]:
										return self.order[0] == self.order[1]





							def    _UpperCAmelCase     (					self       :	Dict			)			->					Optional[int]:
										SCREAMING_SNAKE_CASE           =					[
										    [0 if column_num != row_num else 1 for column_num in range(self.num_rows			)]
										    for row_num in range(self.num_rows			)
										]
										return Matrix(UpperCamelCase_			)





							def    _UpperCAmelCase     (					self       :	List[str]			)			->					Optional[int]:
										if not self.is_square:
													return 0
										if self.order == (0, 0):
													return 1
										if self.order == (1, 1):
													return int(self.rows[0][0]			)
										if self.order == (2, 2):
													return int(
													    (self.rows[0][0] * self.rows[1][1])
													    - (self.rows[0][1] * self.rows[1][0])			)
										else:
													return sum(
													    self.rows[0][column] * self.cofactors().rows[0][column]
													    for column in range(self.num_columns			)			)





							def    _UpperCAmelCase     (					self       :	Optional[int]			)			->					Optional[Any]:
										return bool(self.determinant()			)





							def    _UpperCAmelCase     (					self       :	Optional[int]       ,     a       :	List[str]       ,     a       :	Dict			)			->					Any:
										SCREAMING_SNAKE_CASE           =					[
										    [
										        self.rows[other_row][other_column]
										        for other_column in range(self.num_columns			)
										        if other_column != column
										    ]
										    for other_row in range(self.num_rows			)
										    if other_row != row
										]
										return Matrix(UpperCamelCase_			).determinant()





							def    _UpperCAmelCase     (					self       :	Union[str, Any]       ,     a       :	Any       ,     a       :	Optional[Any]			)			->					List[str]:
										if (row + column) % 2 == 0:
													return self.get_minor(UpperCamelCase_       ,     UpperCamelCase_			)
										return -1 * self.get_minor(UpperCamelCase_       ,     UpperCamelCase_			)





							def    _UpperCAmelCase     (					self       :	List[Any]			)			->					int:
										return Matrix(
										    [
										        [self.get_minor(UpperCamelCase_       ,     UpperCamelCase_			) for column in range(self.num_columns			)]
										        for row in range(self.num_rows			)
										    ]			)





							def    _UpperCAmelCase     (					self       :	int			)			->					Any:
										return Matrix(
										    [
										        [
										            self.minors().rows[row][column]
										            if (row + column) % 2 == 0
										            else self.minors().rows[row][column] * -1
										            for column in range(self.minors().num_columns			)
										        ]
										        for row in range(self.minors().num_rows			)
										    ]			)





							def    _UpperCAmelCase     (					self       :	int			)			->					Union[str, Any]:
										SCREAMING_SNAKE_CASE           =					[
										    [self.cofactors().rows[column][row] for column in range(self.num_columns			)]
										    for row in range(self.num_rows			)
										]
										return Matrix(UpperCamelCase_			)





							def    _UpperCAmelCase     (					self       :	str			)			->					Union[str, Any]:
										SCREAMING_SNAKE_CASE           =					self.determinant()
										if not determinant:
													raise TypeError("""Only matrices with a non-zero determinant have an inverse"""			)
										return self.adjugate() * (1 / determinant)





							def __repr__(					self       :	Optional[Any]			)			->					List[Any]:
										return str(self.rows			)





							def __str__(					self       :	Any			)			->					int:
										if self.num_rows == 0:
													return "[]"
										if self.num_rows == 1:
													return "[[" + ". ".join(str(self.rows[0]			)			) + "]]"
										return (
										    "["
										    + "\n ".join(
										        [
										            """[""" + """. """.join([str(UpperCamelCase_			) for value in row]			) + """.]"""
										            for row in self.rows
										        ]			)
										    + "]"
										)





							def    _UpperCAmelCase     (					self       :	Union[str, Any]       ,     a       :	str       ,     a       :	Union[str, Any] = None			)			->					Tuple:
										SCREAMING_SNAKE_CASE           =					TypeError("""Row must be a list containing all ints and/or floats"""			)
										if not isinstance(UpperCamelCase_       ,     UpperCamelCase_			):
													raise type_error
										for value in row:
													if not isinstance(UpperCamelCase_       ,     (int, float)			):
																raise type_error
										if len(UpperCamelCase_			) != self.num_columns:
													raise ValueError(
													    """Row must be equal in length to the other rows in the matrix"""			)
										if position is None:
													self.rows.append(UpperCamelCase_			)
										else:
													SCREAMING_SNAKE_CASE           =					self.rows[0:position] + [row] + self.rows[position:]





							def    _UpperCAmelCase     (					self       :	Optional[Any]       ,     a       :	Optional[int]       ,     a       :	List[str] = None			)			->					List[Any]:
										SCREAMING_SNAKE_CASE           =					TypeError(
										    """Column must be a list containing all ints and/or floats"""			)
										if not isinstance(UpperCamelCase_       ,     UpperCamelCase_			):
													raise type_error
										for value in column:
													if not isinstance(UpperCamelCase_       ,     (int, float)			):
																raise type_error
										if len(UpperCamelCase_			) != self.num_rows:
													raise ValueError(
													    """Column must be equal in length to the other columns in the matrix"""			)
										if position is None:
													SCREAMING_SNAKE_CASE           =					[self.rows[i] + [column[i]] for i in range(self.num_rows			)]
										else:
													SCREAMING_SNAKE_CASE           =					[
													    self.rows[i][0:position] + [column[i]] + self.rows[i][position:]
													    for i in range(self.num_rows			)
													]





							def __eq__(					self       :	List[str]       ,     a       :	Optional[Any]			)			->					Any:
										if not isinstance(UpperCamelCase_       ,     UpperCamelCase_			):
													return NotImplemented
										return self.rows == other.rows





							def __ne__(					self       :	Dict       ,     a       :	List[str]			)			->					Optional[int]:
										return not self == other





							def __neg__(					self       :	Tuple			)			->					Any:
										return self * -1





							def __add__(					self       :	Union[str, Any]       ,     a       :	Any			)			->					int:
										if self.order != other.order:
													raise ValueError("""Addition requires matrices of the same order"""			)
										return Matrix(
										    [
										        [self.rows[i][j] + other.rows[i][j] for j in range(self.num_columns			)]
										        for i in range(self.num_rows			)
										    ]			)





							def __sub__(					self       :	str       ,     a       :	Optional[int]			)			->					Optional[Any]:
										if self.order != other.order:
													raise ValueError("""Subtraction requires matrices of the same order"""			)
										return Matrix(
										    [
										        [self.rows[i][j] - other.rows[i][j] for j in range(self.num_columns			)]
										        for i in range(self.num_rows			)
										    ]			)





							def __mul__(					self       :	str       ,     a       :	Optional[Any]			)			->					Union[str, Any]:
										if isinstance(UpperCamelCase_       ,     (int, float)			):
													return Matrix(
													    [[int(element * other			) for element in row] for row in self.rows]			)
										elif isinstance(UpperCamelCase_       ,     UpperCamelCase_			):
													if self.num_columns != other.num_rows:
																raise ValueError(
																    """The number of columns in the first matrix must """
																    """be equal to the number of rows in the second"""			)
													return Matrix(
													    [
													        [Matrix.dot_product(UpperCamelCase_       ,     UpperCamelCase_			) for column in other.columns()]
													        for row in self.rows
													    ]			)
										else:
													raise TypeError(
													    """A Matrix can only be multiplied by an int, float, or another matrix"""			)





							def __pow__(					self       :	Union[str, Any]       ,     a       :	Optional[Any]			)			->					Optional[Any]:
										if not isinstance(UpperCamelCase_       ,     UpperCamelCase_			):
													raise TypeError("""A Matrix can only be raised to the power of an int"""			)
										if not self.is_square:
													raise ValueError("""Only square matrices can be raised to a power"""			)
										if other == 0:
													return self.identity()
										if other < 0:
													if self.is_invertable():
																return self.inverse() ** (-other)
													raise ValueError(
													    """Only invertable matrices can be raised to a negative power"""			)
										SCREAMING_SNAKE_CASE           =					self
										for _ in range(other - 1			):
													result *= self
										return result







							@classmethod
							def    _UpperCAmelCase     (					cls       :	Union[str, Any]       ,     a       :	List[Any]       ,     a       :	Union[str, Any]			)			->					Optional[int]:
										return sum(row[i] * column[i] for i in range(len(UpperCamelCase_			)			)			)


if __name__ == "__main__":
		import doctest

		doctest.testmod()












from __future__ import annotations




class 			UpperCAmelCase_      :




							'''simple docstring'''



							def __init__(					self       :	Optional[int]       ,     a       :	int = 0			)			->					str:
										SCREAMING_SNAKE_CASE           =					key





							def    _UpperCAmelCase     (					self       :	Tuple       ,     a       :	str       ,     a       :	int			)			->					list[str]:
										assert isinstance(a       ,     a			) and isinstance(a       ,     a			)

										SCREAMING_SNAKE_CASE           =					key or self.__key or 1

										# make sure key is an appropriate size
										key %= 255

										return [chr(ord(a			) ^ key			) for ch in content]





							def    _UpperCAmelCase     (					self       :	Union[str, Any]       ,     a       :	str       ,     a       :	int			)			->					list[str]:
										assert isinstance(a       ,     a			) and isinstance(a       ,     a			)

										SCREAMING_SNAKE_CASE           =					key or self.__key or 1

										# make sure key is an appropriate size
										key %= 255

										return [chr(ord(a			) ^ key			) for ch in content]





							def    _UpperCAmelCase     (					self       :	Union[str, Any]       ,     a       :	str       ,     a       :	int = 0			)			->					str:
										assert isinstance(a       ,     a			) and isinstance(a       ,     a			)

										SCREAMING_SNAKE_CASE           =					key or self.__key or 1

										# make sure key can be any size
										while key > 255:
													key -= 255

										# This will be returned
										SCREAMING_SNAKE_CASE           =					""""""

										for ch in content:
													ans += chr(ord(a			) ^ key			)

										return ans





							def    _UpperCAmelCase     (					self       :	Dict       ,     a       :	str       ,     a       :	int = 0			)			->					str:
										assert isinstance(a       ,     a			) and isinstance(a       ,     a			)

										SCREAMING_SNAKE_CASE           =					key or self.__key or 1

										# make sure key can be any size
										while key > 255:
													key -= 255

										# This will be returned
										SCREAMING_SNAKE_CASE           =					""""""

										for ch in content:
													ans += chr(ord(a			) ^ key			)

										return ans





							def    _UpperCAmelCase     (					self       :	Optional[int]       ,     a       :	str       ,     a       :	int = 0			)			->					bool:
										assert isinstance(a       ,     a			) and isinstance(a       ,     a			)

										try:
													with open(a			) as fin, open("""encrypt.out"""       ,     """w+"""			) as fout:
																# actual encrypt-process
																for line in fin:
																			fout.write(self.encrypt_string(a       ,     a			)			)

										except OSError:
													return False

										return True







							def    _UpperCAmelCase     (					self       :	Dict       ,     a       :	str       ,     a       :	int			)			->					bool:
										assert isinstance(a       ,     a			) and isinstance(a       ,     a			)

										try:
													with open(a			) as fin, open("""decrypt.out"""       ,     """w+"""			) as fout:
																# actual encrypt-process
																for line in fin:
																			fout.write(self.decrypt_string(a       ,     a			)			)

										except OSError:
													return False

										return True


# Tests
# crypt = XORCipher()
# key = 67

# # test encrypt
# print(crypt.encrypt("hallo welt",key))
# # test decrypt
# print(crypt.decrypt(crypt.encrypt("hallo welt",key), key))

# # test encrypt_string
# print(crypt.encrypt_string("hallo welt",key))

# # test decrypt_string
# print(crypt.decrypt_string(crypt.encrypt_string("hallo welt",key),key))

# if (crypt.encrypt_file("test.txt",key)):
#       print("encrypt successful")
# else:
#       print("encrypt unsuccessful")

# if (crypt.decrypt_file("encrypt.out",key)):
#       print("decrypt successful")
# else:
#       print("decrypt unsuccessful")






