

def        SCREAMING_SNAKE_CASE__	(  lowerCamelCase__     ,			lowerCamelCase__      )  ->					list[int]:
	__lowerCamelCase    :    Optional[Any] 	=			int(lowerCamelCase__      )

	# Initialize Result
	__lowerCamelCase    :    List[str] 	=			[]

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

	return answer


# Driver Code
if __name__ == "__main__":
					a		=[]
					a		="""0"""

					if (
					    input("""Do you want to enter your denominations ? (yY/n): """).strip().lower()
					    == "y"
					):
										a		=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()))
										a		=input("""Enter the change you want to make in Indian Currency: """).strip()
					else:
										# All denominations of Indian Currency if user does not enter
										a		=[1, 2, 5, 10, 20, 50, 100, 500, 2000]
										a		=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}: """)
										a		=find_minimum_change(denominations, value)
										# Print result
										for i in range(len(answer)):
															print(answer[i], end=""" """)







from __future__ import annotations

from collections.abc import Callable
from typing import Generic, TypeVar

a		=TypeVar("""T""")
a		=TypeVar("""U""")






class 	A_		(	Generic[T, U]    ):
							def __init__(		self		:      Tuple       ,SCREAMING_SNAKE_CASE__		:      T | None       ,SCREAMING_SNAKE_CASE__		:      U | None):
								__lowerCamelCase    :    Optional[Any] 	=			key
								__lowerCamelCase    :    Tuple 	=			val
								__lowerCamelCase    :    DoubleLinkedListNode[T, U] | None 	=			None
								__lowerCamelCase    :    DoubleLinkedListNode[T, U] | None 	=			None


							def __repr__(		self		:      Optional[int]):
								return (
								    F"Node: key: {self.key}, val: {self.val}, "
								    F"has next: {bool(self.next)}, has prev: {bool(self.prev)}"
								)






class 	A_		(	Generic[T, U]    ):
							def __init__(		self		:      List[Any]):
								__lowerCamelCase    :    DoubleLinkedListNode[T, U] 	=			DoubleLinkedListNode(SCREAMING_SNAKE_CASE__       ,SCREAMING_SNAKE_CASE__)
								__lowerCamelCase    :    DoubleLinkedListNode[T, U] 	=			DoubleLinkedListNode(SCREAMING_SNAKE_CASE__       ,SCREAMING_SNAKE_CASE__)
								__lowerCamelCase	,			__lowerCamelCase    :    List[Any] 	=			self.rear, self.head
							def __repr__(		self		:      Optional[int]):
								__lowerCamelCase    :    int 	=			['DoubleLinkedList']
								__lowerCamelCase    :    Tuple 	=			self.head
								while node.next is not None:
									rep.append(str(SCREAMING_SNAKE_CASE__))
									__lowerCamelCase    :    Union[str, Any] 	=			node.next
								rep.append(str(self.rear))
								return ",\n    ".join(SCREAMING_SNAKE_CASE__)
							def    lowerCAmelCase					(		self		:      Optional[Any]       ,SCREAMING_SNAKE_CASE__		:      DoubleLinkedListNode[T, U]):
								__lowerCamelCase    :    str 	=			self.rear.prev

								# All nodes other than self.head are guaranteed to have non-None previous
								assert previous is not None

								__lowerCamelCase    :    Any 	=			node
								__lowerCamelCase    :    str 	=			previous
								__lowerCamelCase    :    str 	=			node
								__lowerCamelCase    :    List[str] 	=			self.rear


							def    lowerCAmelCase					(		self		:      int       ,SCREAMING_SNAKE_CASE__		:      DoubleLinkedListNode[T, U]):

								if node.prev is None or node.next is None:
									return None

								__lowerCamelCase    :    Union[str, Any] 	=			node.next
								__lowerCamelCase    :    Dict 	=			node.prev
								__lowerCamelCase    :    Optional[int] 	=			None
								__lowerCamelCase    :    List[str] 	=			None
								return node






class 	A_		(	Generic[T, U]    ):
							_UpperCAmelCase   :  dict[Callable[[T], U], LRUCache[T, U]]										=				{}
							def __init__(		self		:      str       ,SCREAMING_SNAKE_CASE__		:      int):
								__lowerCamelCase    :    DoubleLinkedList[T, U] 	=			DoubleLinkedList()
								__lowerCamelCase    :    List[Any] 	=			capacity
								__lowerCamelCase    :    Optional[int] 	=			0
								__lowerCamelCase    :    int 	=			0
								__lowerCamelCase    :    Optional[Any] 	=			0
								__lowerCamelCase    :    dict[T, DoubleLinkedListNode[T, U]] 	=			{}
							def __repr__(		self		:      Optional[Any]):
								return (
								    F"CacheInfo(hits={self.hits}, misses={self.miss}, "
								    F"capacity={self.capacity}, current size={self.num_keys})"
								)
							def __contains__(		self		:      List[str]       ,SCREAMING_SNAKE_CASE__		:      T):
								return key in self.cache
							def    lowerCAmelCase					(		self		:      Union[str, Any]       ,SCREAMING_SNAKE_CASE__		:      T):
								# Note: pythonic interface would throw KeyError rather than return None

								if key in self.cache:
									self.hits += 1
									__lowerCamelCase    :    DoubleLinkedListNode[T, U] 	=			self.cache[key]
									__lowerCamelCase    :    List[str] 	=			self.list.remove(self.cache[key])
									assert node == value_node

									# node is guaranteed not None because it is in self.cache
									assert node is not None
									self.list.add(SCREAMING_SNAKE_CASE__)
									return node.val
								self.miss += 1
								return None
							def    lowerCAmelCase					(		self		:      Dict       ,SCREAMING_SNAKE_CASE__		:      T       ,SCREAMING_SNAKE_CASE__		:      U):

								if key not in self.cache:
									if self.num_keys >= self.capacity:
										# delete first node (oldest) when over capacity
										__lowerCamelCase    :    Optional[Any] 	=			self.list.head.next

										# guaranteed to have a non-None first node when num_keys > 0
										# explain to type checker via assertions
										assert first_node is not None
										assert first_node.key is not None
										assert (
										    self.list.remove(SCREAMING_SNAKE_CASE__) is not None
										)  # node guaranteed to be in list assert node.key is not None

										del self.cache[first_node.key]
										self.num_keys -= 1
									__lowerCamelCase    :    List[Any] 	=			DoubleLinkedListNode(SCREAMING_SNAKE_CASE__       ,SCREAMING_SNAKE_CASE__)
									self.list.add(self.cache[key])
									self.num_keys += 1

								else:
									# bump node to the end of the list, update value
									__lowerCamelCase    :    List[str] 	=			self.list.remove(self.cache[key])
									assert node is not None  # node guaranteed to be in list
									__lowerCamelCase    :    List[Any] 	=			value
									self.list.add(SCREAMING_SNAKE_CASE__)


							@classmethod
							def    lowerCAmelCase					(		cls		:      Optional[int]       ,SCREAMING_SNAKE_CASE__		:      int = 1_2_8):

								def cache_decorator_inner(SCREAMING_SNAKE_CASE__		:      Callable[[T], U]) -> Callable[..., U]:
									def cache_decorator_wrapper(*SCREAMING_SNAKE_CASE__		:      T) -> U:
										if func not in cls.decorator_function_to_instance_map:
											__lowerCamelCase    :    str 	=			LRUCache(SCREAMING_SNAKE_CASE__)

										__lowerCamelCase    :    Dict 	=			cls.decorator_function_to_instance_map[func].get(args[0])
										if result is None:
											__lowerCamelCase    :    str 	=			func(*SCREAMING_SNAKE_CASE__)
											cls.decorator_function_to_instance_map[func].put(args[0]       ,SCREAMING_SNAKE_CASE__)
										return result

									def cache_info() -> LRUCache[T, U]:
										return cls.decorator_function_to_instance_map[func]

									setattr(SCREAMING_SNAKE_CASE__       ,'cache_info'       ,SCREAMING_SNAKE_CASE__)  # noqa: B010

									return cache_decorator_wrapper

								return cache_decorator_inner


if __name__ == "__main__":
					import doctest

					doctest.testmod()




