



"""simple docstring"""
from __future__ import annotations

from typing import Generic, TypeVar

__SCREAMING_SNAKE_CASE     :  Optional[int]										=					TypeVar('''T''')


class 							lowerCamelCase_(      Generic[T]			):





					'''simple docstring'''



					def __init__(			self ,				lowerCamelCase__      ):
									_lowerCamelCase					     = data  # Assign data
									_lowerCamelCase					     = None  # Initialize next as null
									_lowerCamelCase					     = None  # Initialize prev as null


class 							lowerCamelCase_(      Generic[T]			):





					'''simple docstring'''



					def __init__(			self      ):
									_lowerCamelCase					     = None

					def 	snake_case__					(			self ,				lowerCamelCase__      ):
									if self.head is None:
													_lowerCamelCase					     = Node(lowerCamelCase__      )
									else:
													_lowerCamelCase					     = Node(lowerCamelCase__      )
													_lowerCamelCase					     = new_node
													_lowerCamelCase					     = self.head
													_lowerCamelCase					     = None
													_lowerCamelCase					     = new_node

					def 	snake_case__					(			self      ):
									if self.head is None:
													return None
									else:
													assert self.head is not None
													_lowerCamelCase					     = self.head.data
													_lowerCamelCase					     = self.head.next
													if self.head is not None:
																	_lowerCamelCase					     = None
													return temp

					def 	snake_case__					(			self      ):
									return self.head.data if self.head is not None else None

					def __len__(			self      ):
									_lowerCamelCase					     = self.head
									_lowerCamelCase					     = 0
									while temp is not None:
													count += 1
													_lowerCamelCase					     = temp.next
									return count

					def 	snake_case__					(			self      ):
									return self.head is None





					def 	snake_case__					(			self      ):
									print('''stack elements are:'''      )
									_lowerCamelCase					     = self.head
									while temp is not None:
													print(temp.data ,				end='''->'''      )
													_lowerCamelCase					     = temp.next


# Code execution starts here
if __name__ == "__main__":
			# Start with the empty stack
			__SCREAMING_SNAKE_CASE     :  Stack[int]										=					Stack()

			# Insert 4 at the beginning. So stack becomes 4->None
			print('''Stack operations using Doubly LinkedList''')
			stack.push(4)

			# Insert 5 at the beginning. So stack becomes 4->5->None
			stack.push(5)

			# Insert 6 at the beginning. So stack becomes 4->5->6->None
			stack.push(6)

			# Insert 7 at the beginning. So stack becomes 4->5->6->7->None
			stack.push(7)

			# Print the stack
			stack.print_stack()

			# Print the top element
			print('''\nTop element is ''', stack.top())

			# Print the stack size
			print('''Size of the stack is ''', len(stack))

			# pop the top element
			stack.pop()

			# pop the top element
			stack.pop()

			# two elements have now been popped off
			stack.print_stack()

			# Print True if the stack is empty else False
			print('''\nstack is empty:''', stack.is_empty())





"""simple docstring"""







from itertools import combinations_with_replacement


def       __SCREAMING_SNAKE_CASE      (   __UpperCAmelCase = 100	):
		_lowercase							:      list[int]			=					[*list(range(1					,							21	)	), 25]
		_lowercase							:      list[int]			=					[2 * x for x in range(1					,							21	)] + [50]
		_lowercase							:      list[int]			=					[3 * x for x in range(1					,							21	)]
		_lowercase							:      list[int]			=					singles + doubles + triples + [0]

		_lowercase							:      int			=					0
		_lowercase							:      int
		_lowercase							:      int
		_lowercase							:      int
		_lowercase							:      int

		for double in doubles:
				for throwa, throwa in combinations_with_replacement(__UpperCAmelCase					,							2	):
						_lowercase							:      Union[str, Any]			=					double + throwa + throwa
						if checkout_total < limit:
								num_checkouts += 1

		return num_checkouts


if __name__ == "__main__":
		print(F'{solution() = }')



