def   SCREAMING_SNAKE_CASE_	(		snake_case__  ,    snake_case__				)	->      Dict:
							lowerCAmelCase      						=						int(lowercase_				)

							# Initialize Result
							lowerCAmelCase      						=						[]

							# Traverse through all denomination
							for denomination in reversed(lowercase_				):
														# Find denominations
														while int(lowercase_				) >= int(lowercase_				):
																					total_value -= int(lowercase_				)
																					answer.append(lowercase_				)  # Append the "answers" array

							return answer


# Driver Code
if __name__ == "__main__":
	lowercase__     :							List[Any]            =      []
	lowercase__     :							Union[str, Any]            =      '''0'''

	if (
	    input('''Do you want to enter your denominations ? (yY/n): ''').strip().lower()
	    == "y"
	):
		lowercase__     :							int            =      int(input('''Enter the number of denominations you want to add: ''').strip())

		for i in range(0, n):
			denominations.append(int(input(f'Denomination {i}: ').strip()))
		lowercase__     :							List[str]            =      input('''Enter the change you want to make in Indian Currency: ''').strip()
	else:
		# All denominations of Indian Currency if user does not enter
		lowercase__     :							List[Any]            =      [1, 2, 5, 1_0, 2_0, 5_0, 1_0_0, 5_0_0, 2_0_0_0]
		lowercase__     :							List[Any]            =      input('''Enter the change you want to make: ''').strip()

	if int(value) == 0 or int(value) < 0:
		print('''The total value cannot be zero or negative.''')

	else:
		print(f'Following is minimal change for {value}: ')
		lowercase__     :							Tuple            =      find_minimum_change(denominations, value)
		# Print result
		for i in range(len(answer)):
			print(answer[i], end=''' ''')










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()

