"""simple docstring"""




from __future__ import annotations

from typing import Any
class     UpperCamelCase__:





						def __init__(       self		,__UpperCAmelCase		,__UpperCAmelCase		,__UpperCAmelCase = 0     )					->				None:
													A__     ,  A__	     =							row, column
													A__	     =							[[default_value for c in range(__UpperCAmelCase     )] for r in range(__UpperCAmelCase     )]





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

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

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

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





						def __repr__(       self     )					->				str:
													return str(self     )





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





						def __getitem__(       self		,__UpperCAmelCase     )					->				Any:
													assert self.validate_indicies(__UpperCAmelCase     )
													return self.array[loc[0]][loc[1]]





						def __setitem__(       self		,__UpperCAmelCase		,__UpperCAmelCase     )					->				None:
													assert self.validate_indicies(__UpperCAmelCase     )
													A__	     =							value





						def __add__(       self		,__UpperCAmelCase     )					->				Matrix:
													assert isinstance(__UpperCAmelCase		,__UpperCAmelCase     )
													assert self.row == another.row and self.column == another.column

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





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





						def __sub__(       self		,__UpperCAmelCase     )					->				Matrix:
													return self + (-another)





						def __mul__(       self		,__UpperCAmelCase     )					->				Matrix:

													if isinstance(__UpperCAmelCase		,(int, float)     ):  # Scalar multiplication
																				A__	     =							Matrix(self.row		,self.column     )
																				for r in range(self.row     ):
																											for c in range(self.column     ):
																																		A__	     =							self[r, c] * another
																				return result
													elif isinstance(__UpperCAmelCase		,__UpperCAmelCase     ):  # Matrix multiplication
																				assert self.column == another.row
																				A__	     =							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:
																				A__	     =							f'''Unsupported type given for another ({type(__UpperCAmelCase     )})'''
																				raise TypeError(__UpperCAmelCase     )





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





						def 				snake_case__	(       self		,__UpperCAmelCase		,__UpperCAmelCase     )					->				Any:
													assert isinstance(__UpperCAmelCase		,__UpperCAmelCase     ) and isinstance(__UpperCAmelCase		,__UpperCAmelCase     )
													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
													A__	     =							v.transpose()
													A__	     =							(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   UpperCAmelCase					(	):






											"""simple docstring"""





											A__	     =							Matrix(3       ,    3       ,    0				)
											for i in range(3				):
																		A__	     =							1
											print(F'''a^(-1) is {ainv}'''				)
											# u, v
											A__	     =							Matrix(3       ,    1       ,    0				)
											A__     ,  A__     ,  A__	     =							1, 2, -3
											A__	     =							Matrix(3       ,    1       ,    0				)
											A__     ,  A__     ,  A__	     =							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(UpperCamelCase__       ,    UpperCamelCase__				)}'''				)






				def   UpperCAmelCase					(	):






											"""simple docstring"""





											import doctest

											doctest.testmod()


				testa()






"""simple docstring"""




def   UpperCAmelCase					(	UpperCamelCase__				):






							"""simple docstring"""





							A__     ,  A__	     =							[], []
							while len(UpperCamelCase__				) > 1:
														A__     ,  A__	     =							min(UpperCamelCase__				), max(UpperCamelCase__				)
														start.append(UpperCamelCase__				)
														end.append(UpperCamelCase__				)
														collection.remove(UpperCamelCase__				)
														collection.remove(UpperCamelCase__				)
							end.reverse()
							return start + collection + end


if __name__ == "__main__":
				__lowerCamelCase											=  input("Enter numbers separated by a comma:\n").strip()
				__lowerCamelCase											=  [int(item) for item in user_input.split(",")]
				print(*merge_sort(unsorted), sep=",")





