Problem:
Doubly Linked List

Your task is to implement a double linked list.

Write a program which performs the following operations:

insert x: insert an element with key x into the front of the list.

delete x: delete the first element which has the key of x from the list. If there is not such element, you need not do anything.

deleteFirst: delete the first element from the list.

deleteLast: delete the last element from the list.

Input

The input is given in the following format:

n

command1

command2

...

commandn

In the first line, the number of operations n is given. In the following n lines, the above mentioned operations are given in the following format:

insert x

delete x

deleteFirst

deleteLast

Output

Print all the element (key) in the list after the given operations. Two consequtive keys should be separated by a single space.

Constraints

The number of operations ≤ 2,000,000

The number of delete operations ≤ 20

0 ≤ value of a key ≤ 109

The number of elements in the list does not exceed 106

For a delete, deleteFirst or deleteLast operation, there is at least one element in the list.

Sample Input 1

7
insert 5
insert 2
insert 3
insert 1
delete 3
insert 6
delete 5

Sample Output 1

6 1 2

Sample Input 2

9
insert 5
insert 2
insert 3
insert 1
delete 3
insert 6
delete 5
deleteFirst
deleteLast

Sample Output 2

1

Solution in Python (judge verdict: Wrong Answer)

#! -*-coding:utf-8-*-
# linked list????§???????????????????
class Deque:
    class Cell:
        def __init__(self,x,y=None,z=None):
            self.data = x
            self.next = y
            self.prev = z
    def __init__(self):
        head = Deque.Cell(None)
        head.next = head
        head.prev = head
        self.size = 0
        self.head = head
    def my_insert(self,x):
        h = self.head
        q = h.next
        p = Deque.Cell(x,q,h)
        h.next = p
        q.prev = p
        self.size +=1
    def my_del(self,x):
        if self.size==0:
            return
        h = self.head.next
        num=self.size
        while num > 0:
            if h.data == x:
                p = h.prev
                n = h.next
                h.prev.next = n
                h.next.prev = p
                self.size -=1
            h=h.next
            num -= 1
        # cp_h=h
        # while True:
        #     h = h.next
        #     if h==cp_h:
        #         break
        #     if h.data == x:
        #         p = h.prev
        #         n = h.next
        #         h.prev.next = n
        #         h.next.prev = p
        #         self.size -=1
    def my_deleteFirst(self):
        if self.size==0:
            return
        h = self.head.next
        p = h.prev
        n = h.next
        h.prev.next = n
        h.next.prev = p
        self.size-=1
    def my_deleteLast(self):
        if self.size==0:
            return
        h=self.head.prev
        p = h.prev
        n = h.next
        h.prev.next=n
        h.next.prev = p
        self.size-=1
    # ??¨???
    def __str__(self):
        if self.size == 0: return ''
        buff = ''
        n = self.size
        cp = self.head.next
        while n > 1:
            buff += '%s ' % cp.data
            cp = cp.next
            n -= 1
        buff += '%s' % cp.data
        return buff

def main():
    q = Deque()
    num = input()
    i=0
    while True:
        if i>=num:
            break
        tmp = raw_input().split()
        if len(tmp)==1:
            if tmp[0]=="deleteFirst":
                q.my_deleteFirst()
            elif tmp[0]=="deleteLast":
                q.my_deleteLast()
            else:
                print "This command is invalid."
                return
        elif len(tmp)==2:
            if tmp[0]=="insert":
                q.my_insert(int(tmp[1]))
            elif tmp[0]=="delete":
                q.my_del(int(tmp[1]))
            else:
                print "This command is invalid."
                return
        else:
            print "This command is invalid."
            return
        i+=1
    print q

if __name__ == '__main__':
    main()