

from __future__ import annotations

from typing import Generic, TypeVar

UpperCamelCase__     :					List[str]								=			TypeVar("T")



class 					__snake_case     (			Generic[T]				):

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






class 					__snake_case     (			Generic[T]				):

  def __init__(    self):
      SCREAMING_SNAKE_CASE_													=  None

  def   lowerCAmelCase__   (    self  ,						_A):
      if self.head is None:
          SCREAMING_SNAKE_CASE_													=  Node(_A)
      else:
          SCREAMING_SNAKE_CASE_													=  Node(_A)
          SCREAMING_SNAKE_CASE_													=  new_node
          SCREAMING_SNAKE_CASE_													=  self.head
          SCREAMING_SNAKE_CASE_													=  None
          SCREAMING_SNAKE_CASE_													=  new_node

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

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

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

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


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


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





from itertools import permutations


def     _UpperCAmelCase				(     ):





    """simple docstring"""


    SCREAMING_SNAKE_CASE_													=  list(map(''.join       ,      permutations('0123456789'				)				)				)
    return result[999_999]


if __name__ == "__main__":
       print(solution())


