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

open Str

type dllist = {value : int option; mutable prev : dllist ref; mutable next : dllist ref}
       
let read_list () =
  split (regexp " +") (read_line ())
                                                 
let () =
  let n = read_int () in
  let rec tn = {value = None; prev = ref tn; next = ref tn} in
  let insert x =
    let nn = {value = Some x; prev = ref tn; next = ref tn} in
    let nnn = !(tn.next) in
    nn.next <- tn.next;
    nn.prev <- nnn.prev;
    tn.next <- ref nn;
    nnn.prev <- ref nn
  in
  let find x =
    let rec loop n =
      let nn = !(n.next) in
      match nn.value with
        None -> raise Not_found
      | Some y -> if x = y then nn else loop nn in
    loop tn
  in
  let delete x = try
      let n = find x in
      let pn = !(n.prev) in
      let nn = !(n.next) in
      pn.next <- n.next;
      nn.prev <- n.prev
    with
      _ -> ()
  in
  let delete_first () =
    let dn = !(tn.next) in
    let nn = !(dn.next) in
    tn.next <- dn.next;
    nn.prev <- dn.prev
  in
  let delete_last () =
    let dn = !(tn.prev) in
    let pn = !(dn.prev) in
    tn.prev <- dn.prev;
    pn.next <- dn.next
  in
  let print_dll () =
    let rec loop n ls =
      let nn = !(n.next) in
      match nn.value with
        None -> List.rev ls
      | Some x -> loop nn (x :: ls) in
    loop tn [] |> List.map string_of_int |> String.concat " " |> print_endline
  in
  let rec iter x =
    if x = 0 then print_dll ()
    else
      let s = read_list () in
      match s with
        "deleteFirst" :: _  -> delete_first (); iter (x-1)
      | "deleteLast" :: _ -> delete_last (); iter (x-1)
      | "insert" :: n :: _ -> insert (int_of_string n); iter (x-1)
      | "delete" :: n :: _ -> delete (int_of_string n); iter (x-1)
      | _ -> failwith "ddl"
  in iter n