



"""simple docstring"""






from __future__ import annotations






def 					snake_case__       (		__lowerCamelCase    :   list							,		__lowerCamelCase    :   int							,		__lowerCamelCase    :   int							,		__lowerCamelCase    :   int     ):
			"""simple docstring"""
			lowerCamelCase__		:		Optional[int]		     =[]
			lowerCamelCase__     ,       lowerCamelCase__		:		Union[str, Any]		     =input_list[low:mid], input_list[mid : high + 1]
			while left and right:
						result.append((left if left[0] <= right[0] else right).pop(0     )     )
			lowerCamelCase__		:		str		     =result + left + right
			return input_list






def 					snake_case__       (		__lowerCamelCase    :   list     ):
			"""simple docstring"""
			if len(__lowerCamelCase     ) <= 1:
						return input_list
			lowerCamelCase__		:		Optional[Any]		     =list(__lowerCamelCase     )

			# iteration for two-way merging
			lowerCamelCase__		:		Union[str, Any]		     =2
			while p <= len(__lowerCamelCase     ):
						# getting low, high and middle value for merge-sort of single list
						for i in range(0							,		len(__lowerCamelCase     )							,		__lowerCamelCase     ):
									lowerCamelCase__		:		str		     =i
									lowerCamelCase__		:		Dict		     =i + p - 1
									lowerCamelCase__		:		Optional[Any]		     =(low + high + 1) // 2
									lowerCamelCase__		:		Any		     =merge(__lowerCamelCase							,		__lowerCamelCase							,		__lowerCamelCase							,		__lowerCamelCase     )
						# final merge of last two parts
						if p * 2 >= len(__lowerCamelCase     ):
									lowerCamelCase__		:		Optional[Any]		     =i
									lowerCamelCase__		:		Optional[int]		     =merge(__lowerCamelCase							,		0							,		__lowerCamelCase							,		len(__lowerCamelCase     ) - 1     )
									break
						p *= 2

			return input_list


if __name__ == "__main__":
		_lowercase			:			List[str]										=						input("Enter numbers separated by a comma:\n").strip()
		if user_input == "":
				_lowercase			:			Optional[Any]										=						[]
		else:
				_lowercase			:			Tuple										=						[int(item.strip()) for item in user_input.split(",")]
		print(iter_merge_sort(unsorted))









"""simple docstring"""






import numpy as np
from PIL import Image






def 					snake_case__       (		__lowerCamelCase    :   np.ndarray							,		__lowerCamelCase    :   int							,		__lowerCamelCase    :   int     ):
			"""simple docstring"""
			lowerCamelCase__		:		List[Any]		     =np.array(__lowerCamelCase     )
			if arr.shape[0] != arr.shape[1]:
						raise ValueError('''The input array is not a square matrix'''     )
			lowerCamelCase__		:		int		     =0
			lowerCamelCase__		:		int		     =0
			lowerCamelCase__		:		Optional[int]		     =0
			lowerCamelCase__		:		List[Any]		     =0

			# compute the shape of the output matrix
			lowerCamelCase__		:		Union[str, Any]		     =(arr.shape[0] - size) // stride + 1
			# initialize the output matrix with zeros of shape maxpool_shape
			lowerCamelCase__		:		Union[str, Any]		     =np.zeros((maxpool_shape, maxpool_shape)     )

			while i < arr.shape[0]:
						if i + size > arr.shape[0]:
									# if the end of the matrix is reached, break
									break
						while j < arr.shape[1]:
									# if the end of the matrix is reached, break
									if j + size > arr.shape[1]:
												break
									# compute the maximum of the pooling matrix
									lowerCamelCase__		:		str		     =np.max(arr[i : i + size, j : j + size]     )
									# shift the pooling matrix by stride of column pixels
									j += stride
									mat_j += 1

						# shift the pooling matrix by stride of row pixels
						i += stride
						mat_i += 1

						# reset the column index to 0
						lowerCamelCase__		:		Optional[int]		     =0
						lowerCamelCase__		:		Optional[int]		     =0

			return updated_arr






def 					snake_case__       (		__lowerCamelCase    :   np.ndarray							,		__lowerCamelCase    :   int							,		__lowerCamelCase    :   int     ):
			"""simple docstring"""
			lowerCamelCase__		:		List[Any]		     =np.array(__lowerCamelCase     )
			if arr.shape[0] != arr.shape[1]:
						raise ValueError('''The input array is not a square matrix'''     )
			lowerCamelCase__		:		str		     =0
			lowerCamelCase__		:		List[Any]		     =0
			lowerCamelCase__		:		Optional[int]		     =0
			lowerCamelCase__		:		List[Any]		     =0

			# compute the shape of the output matrix
			lowerCamelCase__		:		Dict		     =(arr.shape[0] - size) // stride + 1
			# initialize the output matrix with zeros of shape avgpool_shape
			lowerCamelCase__		:		Optional[Any]		     =np.zeros((avgpool_shape, avgpool_shape)     )

			while i < arr.shape[0]:
						# if the end of the matrix is reached, break
						if i + size > arr.shape[0]:
									break
						while j < arr.shape[1]:
									# if the end of the matrix is reached, break
									if j + size > arr.shape[1]:
												break
									# compute the average of the pooling matrix
									lowerCamelCase__		:		Optional[int]		     =int(np.average(arr[i : i + size, j : j + size]     )     )
									# shift the pooling matrix by stride of column pixels
									j += stride
									mat_j += 1

						# shift the pooling matrix by stride of row pixels
						i += stride
						mat_i += 1
						# reset the column index to 0
						lowerCamelCase__		:		Optional[Any]		     =0
						lowerCamelCase__		:		int		     =0

			return updated_arr


# Main Function
if __name__ == "__main__":
		from doctest import testmod

		testmod(name="avgpooling", verbose=True)

		# Loading the image
		_lowercase			:			int										=						Image.open("path_to_image")

		# Converting the image to numpy array and maxpooling, displaying the result
		# Ensure that the image is a square matrix

		Image.fromarray(maxpooling(np.array(image), size=3, stride=2)).show()

		# Converting the image to numpy array and averagepooling, displaying the result
		# Ensure that the image is a square matrix

		Image.fromarray(avgpooling(np.array(image), size=3, stride=2)).show()




