

'''simple docstring'''
_snake_case     						=						{
    '0': 1,
    '1': 1,
    '2': 2,
    '3': 6,
    '4': 24,
    '5': 120,
    '6': 720,
    '7': 5_040,
    '8': 40_320,
    '9': 362_880,
}

_snake_case     						=						{145: 145}

_snake_case     						=						{
    145: 0,
    169: 3,
    36_301: 3,
    1_454: 3,
    871: 2,
    45_361: 2,
    872: 2,
}







def       _A	(			snake_case  )    ->			int:
   if n in CACHE_SUM_DIGIT_FACTORIALS:
      return CACHE_SUM_DIGIT_FACTORIALS[n]
   _lowercase    :   Dict      =     sum(DIGIT_FACTORIALS[let] for let in str(snake_case  )  )
   _lowercase    :   Optional[Any]      =     ret
   return ret







def       _A	(			snake_case	,							snake_case = None  )    ->			int:
   _lowercase    :   Optional[int]      =     previous or set()
   if n in CHAIN_LENGTH_CACHE:
      return CHAIN_LENGTH_CACHE[n]
   _lowercase    :   Optional[Any]      =     sum_digit_factorials(snake_case  )
   if next_number in previous:
      _lowercase    :   Union[str, Any]      =     0
      return 0
   else:
      previous.add(snake_case  )
      _lowercase    :   List[str]      =     1 + chain_length(snake_case	,							snake_case  )
      _lowercase    :   List[Any]      =     ret
      return ret







def       _A	(			snake_case = 60	,							snake_case = 1_00_00_00  )    ->			int:
   return sum(1 for i in range(1	,							snake_case  ) if chain_length(snake_case  ) == num_terms  )


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









'''simple docstring'''
from __future__ import annotations

from typing import Generic, TypeVar

_snake_case     						=						TypeVar('T')


class      a__						(							Generic[T]						):


   def __init__(				self    ,       _UpperCamelCase						):





      """simple docstring"""





      _lowercase    :   Any      =     data  # Assign data
      _lowercase    :   Node[T] | None      =     None  # Initialize next as null
      _lowercase    :   Node[T] | None      =     None  # Initialize prev as null




class      a__						(							Generic[T]						):


   def __init__(				self						):





      """simple docstring"""





      _lowercase    :   Node[T] | None      =     None


   def 		_lowerCamelCase     (				self    ,       _UpperCamelCase						):





      """simple docstring"""





      if self.head is None:
         _lowercase    :   Optional[int]      =     Node(_UpperCamelCase						)
      else:
         _lowercase    :   str      =     Node(_UpperCamelCase						)
         _lowercase    :   Optional[Any]      =     new_node
         _lowercase    :   List[str]      =     self.head
         _lowercase    :   Tuple      =     None
         _lowercase    :   Tuple      =     new_node


   def 		_lowerCamelCase     (				self						):





      """simple docstring"""





      if self.head is None:
         return None
      else:
         assert self.head is not None
         _lowercase    :   str      =     self.head.data
         _lowercase    :   Optional[Any]      =     self.head.next
         if self.head is not None:
            _lowercase    :   Optional[int]      =     None
         return temp


   def 		_lowerCamelCase     (				self						):





      """simple docstring"""





      return self.head.data if self.head is not None else None


   def __len__(				self						):





      """simple docstring"""





      _lowercase    :   Optional[Any]      =     self.head
      _lowercase    :   Tuple      =     0
      while temp is not None:
         count += 1
         _lowercase    :   Tuple      =     temp.next
      return count


   def 		_lowerCamelCase     (				self						):





      """simple docstring"""





      return self.head is None






   def 		_lowerCamelCase     (				self						):





      """simple docstring"""





      print("stack elements are:"						)
      _lowercase    :   str      =     self.head
      while temp is not None:
         print(temp.data    ,       end="->"						)
         _lowercase    :   Any      =     temp.next


# Code execution starts here
if __name__ == "__main__":
    # Start with the empty stack
    _snake_case     						=						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())






