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 JavaScript (judge verdict: Accepted)

function LinkedNode(element) {
    this.element = element;
    this.previous = null;
    this.next = null;
}

function LinkedList() {
    this.dummy = new LinkedNode(null);
    this.dummy.previous = this.dummy;
    this.dummy.next = this.dummy;
}

LinkedList.prototype.getFirst = function() {
    return this.dummy.next.element;
};

LinkedList.prototype.getLast = function() {
    return this.dummy.previous.element;
};

LinkedList.prototype.addFirst = function(element) {
    var firstNode = this.dummy.next;
    var node = new LinkedNode(element);
    node.previous = this.dummy;
    node.next = firstNode;
    this.dummy.next = node;
    firstNode.previous = node;
};

LinkedList.prototype.remove = function(element) {
    var node = this.dummy;
    while (node = node.next) {
        if (node == this.dummy) {
            return;
        }
        if (node.element === element) {
            break;
        }
    }
    var previousNode = node.previous;
    var nextNode = node.next;
    previousNode.next = nextNode;
    nextNode.previous = previousNode;
};

LinkedList.prototype.removeFirst = function() {
    var firstNode = this.dummy.next;
    var secondNode = firstNode.next;
    this.dummy.next = secondNode;
    secondNode.previous = this.dummy;
};

LinkedList.prototype.removeLast = function() {
    var lastNode = this.dummy.previous;
    var secondLastNode = lastNode.previous;
    this.dummy.previous = secondLastNode;
    secondLastNode.next = this.dummy;
};

LinkedList.prototype.toArray = function() {
    var array = [];
    var node = this.dummy;
    while (node = node.next) {
        if (node == this.dummy) {
            return array;
        }
        array.push(node.element);
    }
};

(function(input) {
    var p = input.split('\n');
    var n = Number(p.shift());
    var commands = p.slice(0, n);
    var linkedList = new LinkedList();

    commands.forEach(function(e) {
        linkedList = execCommand(linkedList, e);
    });

    console.log(linkedList.toArray().join(' '));
})(require('fs').readFileSync('/dev/stdin', 'utf8'));

function execCommand(linkedList, c) {
    var a = c.split(' ');
    var command = a.shift();
    var arg = Number(a.shift());
    switch (command) {
        case 'insert':
            linkedList.addFirst(arg);
            break;
        case 'delete':
            linkedList.remove(arg);
            break;
        case 'deleteFirst':
            linkedList.removeFirst();
            break;
        case 'deleteLast':
            linkedList.removeLast();
            break;
    }
    return linkedList;
}