





class 			_lowerCamelCase	:



      """simple docstring"""






      def __init__(	self			,  UpperCAmelCase				)    ->				List[Any]:






        '''simple docstring'''






        __snake_case				:			List[Any]            =    val
        # Number of nodes in left subtree
        __snake_case				:			Union[str, Any]            =    0
        __snake_case				:			List[Any]            =    None
        __snake_case				:			Optional[Any]            =    None
        __snake_case				:			List[str]            =    None







      def   UpperCAmelCase						(	self			,  UpperCAmelCase				)    ->				Tuple:






        '''simple docstring'''






        assert self.left_tree_size == other.left_tree_size, "Unequal Sizes of Blocks"

        if self.val < other.val:
          __snake_case				:			Any            =    self.right
          __snake_case				:			Union[str, Any]            =    None
          if self.right:
            __snake_case				:			List[str]            =    other
          __snake_case				:			str            =    other
          __snake_case				:			Optional[int]            =    self.left_tree_size * 2 + 1
          return self
        else:
          __snake_case				:			Union[str, Any]            =    other.right
          __snake_case				:			str            =    None
          if other.right:
            __snake_case				:			int            =    self
          __snake_case				:			Tuple            =    self
          __snake_case				:			int            =    other.left_tree_size * 2 + 1
          return other




class 			_lowerCamelCase	:



      """simple docstring"""






      def __init__(	self			,  UpperCAmelCase=None			,  UpperCAmelCase=None			,  UpperCAmelCase=0				)    ->				Union[str, Any]:






        '''simple docstring'''






        __snake_case				:			List[str]            =    heap_size
        __snake_case				:			Any            =    bottom_root
        __snake_case				:			int            =    min_node







      def   UpperCAmelCase						(	self			,  UpperCAmelCase				)    ->				Dict:






        '''simple docstring'''






        if other.size == 0:
          return None
        if self.size == 0:
          __snake_case				:			str            =    other.size
          __snake_case				:			Union[str, Any]            =    other.bottom_root
          __snake_case				:			Any            =    other.min_node
          return None
        # Update size
        __snake_case				:			List[Any]            =    self.size + other.size

        # Update min.node
        if self.min_node.val > other.min_node.val:
          __snake_case				:			Any            =    other.min_node
        # Merge

        # Order roots by left_subtree_size
        __snake_case				:			Tuple            =    []
        __snake_case				:			List[Any]            =    self.bottom_root, other.bottom_root
        while i or j:
          if i and ((not j) or i.left_tree_size < j.left_tree_size):
            combined_roots_list.append((i, True)				)
            __snake_case				:			Any            =    i.parent
          else:
            combined_roots_list.append((j, False)				)
            __snake_case				:			str            =    j.parent
        # Insert links between them
        for i in range(len(UpperCAmelCase				) - 1				):
          if combined_roots_list[i][1] != combined_roots_list[i + 1][1]:
            __snake_case				:			Any            =    combined_roots_list[i + 1][0]
            __snake_case				:			List[Any]            =    combined_roots_list[i][0]
        # Consecutively merge roots with same left_tree_size
        __snake_case				:			Tuple            =    combined_roots_list[0][0]
        while i.parent:
          if (
              (i.left_tree_size == i.parent.left_tree_size) and (not i.parent.parent)
          ) or (
              i.left_tree_size == i.parent.left_tree_size
              and i.left_tree_size != i.parent.parent.left_tree_size
          ):
            # Neighbouring Nodes
            __snake_case				:			Union[str, Any]            =    i.left
            __snake_case				:			List[Any]            =    i.parent.parent

            # Merging trees
            __snake_case				:			Optional[int]            =    i.merge_trees(i.parent				)

            # Updating links
            __snake_case				:			int            =    previous_node
            __snake_case				:			Dict            =    next_node
            if previous_node:
              __snake_case				:			int            =    i
            if next_node:
              __snake_case				:			List[Any]            =    i
          else:
            __snake_case				:			int            =    i.parent
        # Updating self.bottom_root
        while i.left:
          __snake_case				:			int            =    i.left
        __snake_case				:			List[Any]            =    i

        # Update other
        __snake_case				:			Optional[int]            =    self.size
        __snake_case				:			Dict            =    self.bottom_root
        __snake_case				:			List[str]            =    self.min_node

        # Return the merged heap
        return self







      def   UpperCAmelCase						(	self			,  UpperCAmelCase				)    ->				Union[str, Any]:






        '''simple docstring'''






        if self.size == 0:
          __snake_case				:			str            =    Node(UpperCAmelCase				)
          __snake_case				:			Union[str, Any]            =    1
          __snake_case				:			Optional[int]            =    self.bottom_root
        else:
          # Create new node
          __snake_case				:			str            =    Node(UpperCAmelCase				)

          # Update size
          self.size += 1

          # update min_node
          if val < self.min_node.val:
            __snake_case				:			List[str]            =    new_node
          # Put new_node as a bottom_root in heap
          __snake_case				:			Any            =    new_node
          __snake_case				:			List[Any]            =    self.bottom_root
          __snake_case				:			List[Any]            =    new_node

          # Consecutively merge roots with same left_tree_size
          while (
              self.bottom_root.parent
              and self.bottom_root.left_tree_size
              == self.bottom_root.parent.left_tree_size
          ):
            # Next node
            __snake_case				:			Tuple            =    self.bottom_root.parent.parent

            # Merge
            __snake_case				:			List[str]            =    self.bottom_root.merge_trees(self.bottom_root.parent				)

            # Update Links
            __snake_case				:			List[Any]            =    next_node
            __snake_case				:			List[str]            =    None
            if next_node:
              __snake_case				:			Optional[Any]            =    self.bottom_root







      def   UpperCAmelCase						(	self				)    ->				Any:






        '''simple docstring'''






        return self.min_node.val







      def   UpperCAmelCase						(	self				)    ->				int:






        '''simple docstring'''






        return self.size == 0







      def   UpperCAmelCase						(	self				)    ->				Dict:






        '''simple docstring'''






        __snake_case				:			Optional[Any]            =    self.min_node.val

        # Last element in heap corner case
        if self.size == 1:
          # Update size
          __snake_case				:			Optional[Any]            =    0

          # Update bottom root
          __snake_case				:			int            =    None

          # Update min_node
          __snake_case				:			Optional[int]            =    None

          return min_value
        # No right subtree corner case
        # The structure of the tree implies that this should be the bottom root
        # and there is at least one other root
        if self.min_node.right is None:
          # Update size
          self.size -= 1

          # Update bottom root
          __snake_case				:			Optional[int]            =    self.bottom_root.parent
          __snake_case				:			str            =    None

          # Update min_node
          __snake_case				:			str            =    self.bottom_root
          __snake_case				:			Tuple            =    self.bottom_root.parent
          while i:
            if i.val < self.min_node.val:
              __snake_case				:			Any            =    i
            __snake_case				:			Tuple            =    i.parent
          return min_value
        # General case
        # Find the BinomialHeap of the right subtree of min_node
        __snake_case				:			List[str]            =    self.min_node.right
        __snake_case				:			Union[str, Any]            =    None
        __snake_case				:			Tuple            =    bottom_of_new
        __snake_case				:			List[str]            =    1

        # Size, min_node and bottom_root
        while bottom_of_new.left:
          __snake_case				:			Union[str, Any]            =    size_of_new * 2 + 1
          __snake_case				:			Dict            =    bottom_of_new.left
          if bottom_of_new.val < min_of_new.val:
            __snake_case				:			List[str]            =    bottom_of_new
        # Corner case of single root on top left path
        if (not self.min_node.left) and (not self.min_node.parent):
          __snake_case				:			Union[str, Any]            =    size_of_new
          __snake_case				:			List[Any]            =    bottom_of_new
          __snake_case				:			Optional[Any]            =    min_of_new
          # print("Single root, multiple nodes case")
          return min_value
        # Remaining cases
        # Construct heap of right subtree
        __snake_case				:			str            =    BinomialHeap(
            bottom_root=UpperCAmelCase			,  min_node=UpperCAmelCase			,  heap_size=UpperCAmelCase				)

        # Update size
        __snake_case				:			Tuple            =    self.size - 1 - size_of_new

        # Neighbour nodes
        __snake_case				:			List[Any]            =    self.min_node.left
        __snake_case				:			int            =    self.min_node.parent

        # Initialize new bottom_root and min_node
        __snake_case				:			str            =    previous_node or next_node
        __snake_case				:			Any            =    next_node

        # Update links of previous_node and search below for new min_node and
        # bottom_root
        if previous_node:
          __snake_case				:			Union[str, Any]            =    next_node

          # Update bottom_root and search for min_node below
          __snake_case				:			Union[str, Any]            =    previous_node
          __snake_case				:			Dict            =    previous_node
          while self.bottom_root.left:
            __snake_case				:			Tuple            =    self.bottom_root.left
            if self.bottom_root.val < self.min_node.val:
              __snake_case				:			Any            =    self.bottom_root
        if next_node:
          __snake_case				:			List[Any]            =    previous_node

          # Search for new min_node above min_node
          __snake_case				:			List[Any]            =    next_node
          while i:
            if i.val < self.min_node.val:
              __snake_case				:			Tuple            =    i
            __snake_case				:			Optional[Any]            =    i.parent
        # Merge heaps
        self.merge_heaps(UpperCAmelCase				)

        return min_value







      def   UpperCAmelCase						(	self				)    ->				Dict:






        '''simple docstring'''






        __snake_case				:			Dict            =    self.bottom_root
        while top_root.parent:
          __snake_case				:			List[Any]            =    top_root.parent
        # preorder
        __snake_case				:			Any            =    []
        self.__traversal(UpperCAmelCase			,  UpperCAmelCase				)
        return heap_pre_order







      def   UpperCAmelCase						(	self			,  UpperCAmelCase			,  UpperCAmelCase			,  UpperCAmelCase=0				)    ->				Dict:






        '''simple docstring'''






        if curr_node:
          preorder.append((curr_node.val, level)				)
          self.__traversal(curr_node.left			,  UpperCAmelCase			,  level + 1				)
          self.__traversal(curr_node.right			,  UpperCAmelCase			,  level + 1				)
        else:
          preorder.append(("#", level)				)







      def __str__(	self				)    ->				List[Any]:






        '''simple docstring'''






        if self.is_empty():
          return ""
        __snake_case				:			Optional[int]            =    self.pre_order()

        return "\n".join(("-" * level + str(UpperCAmelCase				)) for value, level in preorder_heap				)


# Unit Tests
if __name__ == "__main__":
     import doctest

     doctest.testmod()








_UpperCamelCase    =	[chr(i) for i in range(32, 126)]
_UpperCamelCase    =	list(range(len(alphabets)))
_UpperCamelCase    =	list(range(len(alphabets)))
_UpperCamelCase    =	list(range(len(alphabets)))
_UpperCamelCase    =	list(reversed(range(len(alphabets))))
_UpperCamelCase    =	[]
_UpperCamelCase    =	_UpperCamelCase    =	_UpperCamelCase    =	0







def  lowerCAmelCase__(		)	->      int:
  global gear_one_pos
  global gear_two_pos
  global gear_three_pos
  __snake_case				:			int            =    gear_one[0]
  gear_one.append(lowercase			)
  del gear_one[0]
  gear_one_pos += 1
  if gear_one_pos % int(len(lowercase			)			) == 0:
    __snake_case				:			List[str]            =    gear_two[0]
    gear_two.append(lowercase			)
    del gear_two[0]
    gear_two_pos += 1
    if gear_two_pos % int(len(lowercase			)			) == 0:
      __snake_case				:			Any            =    gear_three[0]
      gear_three.append(lowercase			)
      del gear_three[0]
      gear_three_pos += 1







def  lowerCAmelCase__(		lowercase    :      Tuple			)	->      Union[str, Any]:
  __snake_case				:			Union[str, Any]            =    alphabets.index(lowercase			)
  __snake_case				:			Tuple            =    gear_one[target]
  __snake_case				:			Union[str, Any]            =    gear_two[target]
  __snake_case				:			int            =    gear_three[target]
  __snake_case				:			Optional[int]            =    reflector[target]
  __snake_case				:			Union[str, Any]            =    gear_three.index(lowercase			)
  __snake_case				:			Optional[Any]            =    gear_two.index(lowercase			)
  __snake_case				:			int            =    gear_one.index(lowercase			)
  code.append(alphabets[target]			)
  rotator()


if __name__ == "__main__":
     _UpperCamelCase    =	list(input('''Type your message:\n'''))
     while True:
          try:
               _UpperCamelCase    =	int(input('''Please set token:(must be only digits)\n'''))
               break
          except Exception as error:
               print(error)
     for _ in range(token):
          rotator()
     for j in decode:
          engine(j)
     print('''\n''' + ''''''.join(code))
     print(
         F'''\nYour Token is {token} please write it down.\nIf you want to decode '''
         '''this message again you should input same digits as token!'''
     )

