import operator

def   SCREAMING_SNAKE_CASE_	(		snake_case__  ,    snake_case__ = False  ,    snake_case__ = None				)	->      Optional[int]:
							lowerCAmelCase      						=						operator.lt if reverse else operator.gt
							lowerCAmelCase      						=						solution or []

							if not arr:
														return solution

							lowerCAmelCase      						=						[arr.pop(0				)]
							for i, item in enumerate(lowercase_				):
														if _operator(lowercase_  ,    sublist[-1]				):
																					sublist.append(lowercase_				)
																					arr.pop(lowercase_				)

    #  merging sublist into solution list
							if not solution:
														solution.extend(lowercase_				)
							else:
														while sublist:
																					lowerCAmelCase      						=						sublist.pop(0				)
																					for i, xx in enumerate(lowercase_				):
																												if not _operator(lowercase_  ,    lowercase_				):
																																			solution.insert(lowercase_  ,    lowercase_				)
																																			break
																					else:
																												solution.append(lowercase_				)

							strand_sort(lowercase_  ,    lowercase_  ,    lowercase_				)
							return solution


if __name__ == "__main__":
	assert strand_sort([4, 3, 5, 1, 2]) == [1, 2, 3, 4, 5]
	assert strand_sort([4, 3, 5, 1, 2], reverse=True) == [5, 4, 3, 2, 1]










import doctest
from collections import deque

import numpy as np







class       __A							:




      """simple docstring"""







      def __init__(		self):



             """simple docstring"""





             _lowerCamelCase				:  Any						=		[2, 1, 2, -1]
             _lowerCamelCase				:  Optional[int]						=		[1, 2, 3, 4]



      def 					__snake_case      (		self):



             """simple docstring"""





             _lowerCamelCase				:  Optional[int]						=		len(self.first_signal)
             _lowerCamelCase				:  str						=		len(self.second_signal)

             _lowerCamelCase				:  str						=		max(a__   ,				a__)

             # create a zero matrix of max_length x max_length
             _lowerCamelCase				:  Optional[Any]						=		[[0] * max_length for i in range(a__)]

             # fills the smaller signal with zeros to make both signals of same length
             if length_first_signal < length_second_signal:
                    self.first_signal += [0] * (max_length - length_first_signal)
             elif length_first_signal > length_second_signal:
                    self.second_signal += [0] * (max_length - length_second_signal)
             for i in range(a__):
                    _lowerCamelCase				:  Optional[Any]						=		deque(self.second_signal)
                    rotated_signal.rotate(a__)
                    for j, item in enumerate(a__):
                           matrix[i][j] += item

        # multiply the matrix with the first signal
             _lowerCamelCase				:  List[Any]						=		np.matmul(np.transpose(a__)   ,				np.transpose(self.first_signal))

             # rounding-off to two decimal places
             return [round(a__   ,				2) for i in final_signal]


if __name__ == "__main__":
       doctest.testmod()

