


from __future__ import annotations

from typing import Any





class       A    :


							def __init__(self      ,				lowerCAmelCase      ,				lowerCAmelCase      ,				lowerCAmelCase = 0					):
									__lowercase,							__lowercase=			row, column
									__lowercase=			[[default_value for c in range(lowerCAmelCase					)] for r in range(lowerCAmelCase					)]


							def __str__(self					):
									__lowercase=			f'Matrix consist of {self.row} rows and {self.column} columns\n'

									# Make string identifier
									__lowercase=			0
									for row_vector in self.array:
											for obj in row_vector:
													__lowercase=			max(lowerCAmelCase      ,				len(str(lowerCAmelCase					)					)					)
									__lowercase=			f'%{max_element_length}s'

									# Make string and return
									def single_line(lowerCAmelCase					) -> str:
											nonlocal string_format_identifier
											__lowercase=			'['
											line += ", ".join(string_format_identifier % (obj,) for obj in row_vector					)
											line += "]"
											return line

									s += "\n".join(single_line(lowerCAmelCase					) for row_vector in self.array					)
									return s


							def __repr__(self					):
									return str(self					)


							def 			_A       (self      ,				lowerCAmelCase					):
									if not (isinstance(lowerCAmelCase      ,				(list, tuple)					) and len(lowerCAmelCase					) == 2):
											return False
									elif not (0 <= loc[0] < self.row and 0 <= loc[1] < self.column):
											return False
									else:
											return True


							def __getitem__(self      ,				lowerCAmelCase					):
									assert self.validate_indicies(lowerCAmelCase					)
									return self.array[loc[0]][loc[1]]


							def __setitem__(self      ,				lowerCAmelCase      ,				lowerCAmelCase					):
									assert self.validate_indicies(lowerCAmelCase					)
									__lowercase=			value


							def __add__(self      ,				lowerCAmelCase					):
									assert isinstance(lowerCAmelCase      ,				lowerCAmelCase					)
									assert self.row == another.row and self.column == another.column

									# Add
									__lowercase=			Matrix(self.row      ,				self.column					)
									for r in range(self.row					):
											for c in range(self.column					):
													__lowercase=			self[r, c] + another[r, c]
									return result


							def __neg__(self					):
									__lowercase=			Matrix(self.row      ,				self.column					)
									for r in range(self.row					):
											for c in range(self.column					):
													__lowercase=			-self[r, c]
									return result


							def __sub__(self      ,				lowerCAmelCase					):
									return self + (-another)


							def __mul__(self      ,				lowerCAmelCase					):

									if isinstance(lowerCAmelCase      ,				(int, float)					):  # Scalar multiplication
											__lowercase=			Matrix(self.row      ,				self.column					)
											for r in range(self.row					):
													for c in range(self.column					):
															__lowercase=			self[r, c] * another
											return result
									elif isinstance(lowerCAmelCase      ,				lowerCAmelCase					):  # Matrix multiplication
											assert self.column == another.row
											__lowercase=			Matrix(self.row      ,				another.column					)
											for r in range(self.row					):
													for c in range(another.column					):
															for i in range(self.column					):
																	result[r, c] += self[r, i] * another[i, c]
											return result
									else:
											__lowercase=			f'Unsupported type given for another ({type(lowerCAmelCase					)})'
											raise TypeError(lowerCAmelCase					)


							def 			_A       (self					):
									__lowercase=			Matrix(self.column      ,				self.row					)
									for r in range(self.row					):
											for c in range(self.column					):
													__lowercase=			self[r, c]
									return result







							def 			_A       (self      ,				lowerCAmelCase      ,				lowerCAmelCase					):
									assert isinstance(lowerCAmelCase      ,				lowerCAmelCase					) and isinstance(lowerCAmelCase      ,				lowerCAmelCase					)
									assert self.row == self.column == u.row == v.row  # u, v should be column vector
									assert u.column == v.column == 1  # u, v should be column vector

									# Calculate
									__lowercase=			v.transpose()
									__lowercase=			(v_t * self * u)[0, 0] + 1
									if numerator_factor == 0:
											return None  # It's not invertable
									return self - ((self * u) * (v_t * self) * (1.0 / numerator_factor))


# Testing
if __name__ == "__main__":







	def        _lowerCamelCase(	)						->	None:

			'''simple docstring'''







			__lowercase=			Matrix(3   , 3   , 0	)
			for i in range(3	):
					__lowercase=			1
			print(F'a^(-1) is {ainv}'	)
			# u, v
			__lowercase=			Matrix(3   , 1   , 0	)
			__lowercase,							__lowercase,							__lowercase=			1, 2, -3
			__lowercase=			Matrix(3   , 1   , 0	)
			__lowercase,							__lowercase,							__lowercase=			4, -2, 5
			print(F'u is {u}'	)
			print(F'v is {v}'	)
			print(F'uv^T is {u * v.transpose()}'	)
			# Sherman Morrison
			print(F'(a + uv^T)^(-1) is {ainv.sherman_morrison(lowercase__   , lowercase__	)}'	)







	def        _lowerCamelCase(	)						->	None:

			'''simple docstring'''







			import doctest

			doctest.testmod()
	testa()










from __future__ import annotations







def        _lowerCamelCase(	lowercase__   , lowercase__	)						->	Any:

		'''simple docstring'''







		if len(lowercase__	) <= 1 or n <= 1:
				return

		insert_next(lowercase__   , n - 1	)
		rec_insertion_sort(lowercase__   , n - 1	)







def        _lowerCamelCase(	lowercase__   , lowercase__	)						->	Any:

		'''simple docstring'''







		if index >= len(lowercase__	) or collection[index - 1] <= collection[index]:
				return

		# Swaps adjacent elements since they are not in ascending order
		__lowercase,							__lowercase=			(
		    collection[index],
		    collection[index - 1],
		)

		insert_next(lowercase__   , index + 1	)


if __name__ == "__main__":
	lowerCAmelCase           =		input('''Enter integers separated by spaces: ''')
	lowerCAmelCase           =		[int(num) for num in numbers.split()]
	rec_insertion_sort(number_list, len(number_list))
	print(number_list)






