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)

module DLinkedList = struct
  type 'a element =
    { value : 'a;
      mutable next : 'a element option;
      mutable prev : 'a element option
    }
  type 'a t = {
    mutable first : 'a element option;
    mutable last  : 'a element option
  }

  let create () = {first = None; last = None}
  let is_empty t = t.first = None && t.last = None
  let value elt = elt.value
  let next elt = elt.next

  let insert_first t value =
    let new_elt = {prev = None; next = t.first; value} in
    begin match t.first with
      | Some old_first -> old_first.prev <- Some new_elt
      | None -> ()
    end;
    t.first <- Some new_elt;
    begin match t.last with
      | Some _ -> ()
      | None -> t.last <- Some new_elt
    end

  let remove t elt =
    let {prev; next; _} = elt in
    begin match prev with
      | Some prev -> prev.next <- next
      | None -> t.first <- next
    end;
    begin match next with
      | Some next -> next.prev <- prev
      | None -> t.last <- prev
    end;
    elt.prev <- None;
    elt.next <- None
      
  let find t (v:int) =
    let rec loop = function
      | None -> ()
      | Some elt ->
        if v = (value elt) then remove t elt
        else loop (next elt)
    in
    loop t.first

  let remove_first t =
    begin match t.first with
      | Some first ->
        begin match first.next with
          | Some e -> e.prev <- None; t.first <- first.next
          | None -> t.first <- None; t.last <- None
        end
      | None -> ()
    end

  let remove_last t =
    begin match t.last with
      | Some last ->
        begin match last.prev with
          | Some e -> e.next <- None; t.last <- last.prev
          | None -> t.first <- None; t.last <- None
        end
      | None -> ()
    end

  let iter t ~f =
    let rec loop = function
      | None -> ()
      | Some elt -> f elt; loop (next elt)
    in loop t.first
end

let () =
  let open DLinkedList in
  let (n: int) = read_int () in
  let (dll: int t) = create () in
  for i=1 to n do
    begin match read_line () with
      | "deleteFirst" -> remove_first dll
      | "deleteLast" -> remove_last dll
      | s ->
        begin match String.sub s 0 6,
                    (String.sub s 7 (String.length s - 7)
                     |> int_of_string) with
        | "insert", n -> insert_first dll n
        | "delete", n -> find dll n
        | _ -> ()
        end
    end
  done;
  iter dll
    ~f:(fun e -> match next e with
          Some _ -> Printf.printf "%d " (value e)
        | None -> Printf.printf "%d\n" (value e))