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

#include<iostream>
using namespace std;
#include<string>
#include<stdio.h>

typedef struct box { int val; box *prev, *next; } box_t;
box_t* init()
{
    box_t* head = new box_t;
    head->val = -1;
    head->next = NULL;
    head->prev = NULL;
    return head;
}
box_t* make_tail(box_t* head)
{
    box_t* tail = new box_t;
    tail->val = -1;
    head->next = tail;
    tail->next = NULL;
    tail->prev = head;
    return tail;
}
// f_insert, f_delete_key, f_delete, b_delete, f_show.
box_t* f_insert(box_t* head, int data)
{
    box_t* box = new box_t;
    box->val = data;
    box->next = head->next;
    box->prev = head;
    head->next->prev = box;
    head->next = box;
    return box;
}
int f_delete_key(box_t* head, box_t* tail, int key)
{
    box_t* box = head->next;
    while(box != tail){
        if(box->val == key){
            box->next->prev = box->prev;
            box->prev->next = box->next;
            delete box;
            return 1; }
        box = box->next; };
    return -1;
}
int f_delete(box_t* head)
{
    if(!(head->next->next)) return -1;
    box_t* box = head->next;
    head->next = box->next;
    box->next->prev = head;
    delete box;
    return 1;
}
int b_delete(box_t* tail)
{
    if(!(tail->prev->prev)) return -1;
    box_t* box = tail->prev;
    tail->prev = box->prev;
    box->prev->next = tail;
    delete box;
    return 1;
}
void f_show(box_t* head, box_t* tail)
{
    box_t* box = head->next;
    while(box != tail){
        printf("%d", box->val);
        box = box->next;
        if(box != tail) printf(" "); };
    printf("\n");
    return;
}

int main()
{
    int i, n;
    scanf("%d", &n);
    char cmd[12]; int key;
    box_t* head = init();
    box_t* tail = make_tail(head);
    for(i = 0; i < n; i++){
        scanf("%s", cmd);
        if(cmd[0] == 'i'){ scanf("%d", &key); f_insert(head, key); }
        else if(cmd[6] == 'F'){ f_delete(head); }else if(cmd[6] == 'L'){ b_delete(tail); }
        else{ scanf("%d", &key); f_delete_key(head, tail, key); }
    }
    f_show(head, tail);
    return 0;
}