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

package main

import (
	"bufio"
	"fmt"
	"os"
	"strconv"
	"strings"
)

func main() {

	sc := bufio.NewScanner(os.Stdin)
	sc.Scan()
	sc.Text()

	list := list()

	for {
		sc.Scan()
		in := sc.Text()
		if len(in) == 0 {
			break
		}
		ins := strings.Split(in, " ")
		command := ins[0]

		switch command {
		case "insert":
			num, _ := strconv.Atoi(ins[1])
			list.insert(num)
		case "delete":
			num, _ := strconv.Atoi(ins[1])
			list.delete(num)
		case "deleteFirst":
			list.deleteFirst()
		case "deleteLast":
			list.deleteLast()
		}
	}
	printLine(&list)

}

func printLine(list *DoublyLinkedList) {
	r := []string{}
	elem := list.top
	for {

		if !elem.first && !elem.last {
			r = append(r, strconv.Itoa(elem.val))
		}

		elem = elem.next
		if list.top == elem {
			break
		}
	}

	fmt.Println(strings.Join(r, " "))
}

type DoublyLinkedList struct {
	top *Element
}

type Element struct {
	prev  *Element
	next  *Element
	val   int
	first bool
	last  bool
}

func list() DoublyLinkedList {
	first := Element{nil, nil, 0, true, false}
	last := Element{nil, nil, 0, false, true}

	first.next = &last
	first.prev = &last
	last.next = &first
	last.prev = &first
	return DoublyLinkedList{&first}
}

func (list *DoublyLinkedList) insert(x int) {
	e := Element{list.top, list.top.next, x, false, false}
	list.top.next.prev = &e
	list.top.next = &e
}

func (list *DoublyLinkedList) delete(x int) {
	now := list.top
	for {
		if !now.first && !now.last && now.val == x {
			now.next.prev = now.prev
			now.prev.next = now.next
			return
		}
		now = now.next
		if now == list.top {
			return
		}
	}
}

func (list *DoublyLinkedList) deleteFirst() {
	target := list.top.next
	target.next.prev = target.prev
	target.prev.next = target.next
}

func (list *DoublyLinkedList) deleteLast() {
	target := list.top.prev.prev
	target.next.prev = target.prev
	target.prev.next = target.next
}