module DLinkedList : sig
  type 'a t
  type 'a element
  val create : unit -> 'a t
  val is_empty : 'a t -> bool
  val next : 'a element -> 'a element option
  val prev : 'a element -> 'a element option
  val value : 'a element -> 'a
  val find : 'a t -> f:('a -> bool) -> 'a element option
  val iter : 'a t -> f:('a element -> unit) -> unit
  val insert_first : 'a t -> 'a -> 'a element
  val remove : 'a t -> 'a element -> unit
  val remove_first : 'a t -> unit
  val remove_last : 'a t -> unit
end = 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 prev elt = elt.prev

  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;
    new_elt

  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 remove_first t =
    begin match t.first with
      | Some e -> remove t e
      | 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 find t ~f =
    let rec loop = function
      | None -> None
      | Some elt ->
        if f (value elt) then Some elt
        else loop (next elt)
    in
    loop t.first

  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 = read_int () in
  let dll = create () in
  let rec loop = function
      0 -> ()
    | i ->
      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 -> let _ = insert_first dll n in ()
          | "delete", n -> (match find dll ~f:((=) n) with
              | Some e -> remove dll e
              | None -> ())
          | _,_ -> ()
          end
      end;
      loop (i-1)
  in
  loop n;
  iter dll
    ~f:(fun e -> match next e with
          Some _ -> Printf.printf "%d " (value e)
        | None -> Printf.printf "%d\n" (value e))