






"""simple docstring"""
from copy import deepcopy



class   SCREAMING_SNAKE_CASE	:





	"""simple docstring"""




	def __init__(self  ,  lowerCAmelCase_ = None  ,  lowerCAmelCase_ = None				):

		if arr is None and size is not None:
			A_		:    int						     = size
			A_		:    Union[str, Any]						     = [0] * size
		elif arr is not None:
			self.init(lowerCAmelCase_				)
		else:
			raise ValueError("""Either arr or size must be specified"""				)





	def  lowerCamelCase(self  ,  lowerCAmelCase_				):
		A_		:    List[str]						     = len(lowerCAmelCase_				)
		A_		:    str						     = deepcopy(lowerCAmelCase_				)
		for i in range(1  ,  self.size				):
			A_		:    Optional[int]						     = self.next_(lowerCAmelCase_				)
			if j < self.size:
				self.tree[j] += self.tree[i]





	def  lowerCamelCase(self				):
		A_		:    List[Any]						     = self.tree[:]
		for i in range(self.size - 1  ,  0  ,  -1				):
			A_		:    str						     = self.next_(lowerCAmelCase_				)
			if j < self.size:
				arr[j] -= arr[i]
		return arr





	@staticmethod
	def  lowerCamelCase(lowerCAmelCase_				):
		return index + (index & (-index))





	@staticmethod
	def  lowerCamelCase(lowerCAmelCase_				):
		return index - (index & (-index))





	def  lowerCamelCase(self  ,  lowerCAmelCase_  ,  lowerCAmelCase_				):
		if index == 0:
			self.tree[0] += value
			return
		while index < self.size:
			self.tree[index] += value
			A_		:    Union[str, Any]						     = self.next_(lowerCAmelCase_				)





	def  lowerCamelCase(self  ,  lowerCAmelCase_  ,  lowerCAmelCase_				):
		self.add(lowerCAmelCase_  ,  value - self.get(lowerCAmelCase_				)				)





	def  lowerCamelCase(self  ,  lowerCAmelCase_				):
		if right == 0:
			return 0
		A_		:    List[Any]						     = self.tree[0]
		right -= 1  # make right inclusive
		while right > 0:
			result += self.tree[right]
			A_		:    List[Any]						     = self.prev(lowerCAmelCase_				)
		return result





	def  lowerCamelCase(self  ,  lowerCAmelCase_  ,  lowerCAmelCase_				):
		return self.prefix(lowerCAmelCase_				) - self.prefix(lowerCAmelCase_				)





	def  lowerCamelCase(self  ,  lowerCAmelCase_				):
		return self.query(lowerCAmelCase_  ,  index + 1				)





	def  lowerCamelCase(self  ,  lowerCAmelCase_				):
		value -= self.tree[0]
		if value < 0:
			return -1

		A_		:    int						     = 1  # Largest power of 2 <= size
		while j * 2 < self.size:
			j *= 2

		A_		:    Optional[Any]						     = 0

		while j > 0:
			if i + j < self.size and self.tree[i + j] <= value:
				value -= self.tree[i + j]
				i += j
			j //= 2
		return i


if __name__ == "__main__":
							import doctest

							doctest.testmod()









"""simple docstring"""
def       __UpperCamelCase						(		snake_case__ = 200       ):
	A_		:    Union[str, Any]						     = [1, 2, 5, 10, 20, 50, 100, 200]
	A_		:    int						     = [0] * (pence + 1)
	A_		:    Tuple						     = 1  # base case: 1 way to make 0 pence

	for coin in coins:
		for i in range(snake_case__ , pence + 1 , 1       ):
			number_of_ways[i] += number_of_ways[i - coin]
	return number_of_ways[pence]


if __name__ == "__main__":
							assert solution(200) == 73_682

