class Node:
    def __init__(self, nxt=None, value=None, prev=None):
        self.value = value
        self.next = nxt
        self.prev = prev

    def __str__(self):
        return f"{self.value}"

class DLL:
    def __init__(self):
        self.head = Node()
        self.tail = Node()
        self.size = 0
        self.current = self.tail


    def __str__(self):
        ret = ""
        current = self.head.next
        if self.size == 0:
            return ret
        if current.next == None:
            return ret
        while current is not self.tail:
            ret += str(current) + " "
            current = current.next
        return ret

    def __len__(self):
        return self.size

    def insert(self, value):
        new_node = Node(value)
        new_node.value = value
        if self.size == 0:
            self.head.next = new_node
            self.tail.prev = new_node
            new_node.next = self.tail
            new_node.prev = self.head
            self.size += 1
            self.current = new_node
        else:
            new_node.next = self.current
            new_node.prev = self.current.prev
            new_node.prev.next = new_node
            new_node.next.prev = new_node
            self.size += 1
            self.current = new_node

    def remove(self):
        self.__remove_node(self.current)

    def __remove_node(self, node):
        if self.size == 0:
            return -1
        node.next.prev = node.prev
        node.prev.next = node.next
        node = node.prev
        self.size -= 1


    def get_value(self):
        return self.current

    def move_to_next(self):
        if self.current.next is self.tail:
            return
        self.current = self.current.next


    def move_to_prev(self):
        """if self.current is self.head:
            return
        if self.current.prev is self.head:
            return
        self.current = self.current.prev"""
        if self.current.value is not None:
            if self.current.prev.value is not None:
                self.current = self.current.prev

    def move_to_pos(self, position):
        if 0 <= position <= self.size:
            count = 0
            node = self.head.next
            while count < int(position):
                node = node.next
                count += 1
            self.current = node

    def remove_all(self, value):
        current = self.head
        while current is not self.tail:
            if current.value == value:
                self.__remove_node(current)
            current = current.next


    def reverse(self):
        front = self.head.next
        back = self.tail.prev
        while front is not back or front.next is not back:
            if front is back:
                break
            front.value, back.value = back.value, front.value
            if front.next is back:
                break
            front, back = front.next, back.prev


    def sort(self):
        if self.size < 2:
            return
        pivot = self.head.next.next
        while pivot is not self.tail:
            current = pivot
            while current.prev is self.head or current.value < current.prev.value:
                current.value, current.prev.value = current.prev.value, current.value
                current = current.prev
            pivot = pivot.next