--双方向リスト
--sequenceがあるでよ。

import Data.Sequence
import Data.Foldable (toList)
import Control.Monad

data Command = INS Integer | DEL Integer | DELF | DELL deriving (Eq,Show)

parse::String->Command
parse str =  case words str of
            ["insert",num]  -> INS (read num)
            ["delete",num]  -> DEL (read num)
            ["deleteFirst"] -> DELF
            ["deleteLast"]  -> DELL

do_command::[Command]->Seq Integer->Seq Integer
do_command [] sq     = sq
do_command (c:cs) sq = case c of
                      INS x -> do_command cs (x<|sq)
                      DEL x -> let rec_del sq'= let l:<rest = viewl sq' in
                                                if l == x then rest
                                                          else l<|(rec_del rest)
                               in do_command cs (rec_del sq)
                      DELF  -> let l:<rest = viewl sq in do_command cs rest
                      DELL   -> let rest:>r = viewr sq in do_command cs rest

command_get::Integer->IO [Command]
command_get n = do
  cmd<-forM [1..n] (\ _ -> do
                str<-getLine
                return (parse str))
  return cmd

main::IO()
main=do
  nc<-getLine
  let n = read nc
  cmds<-command_get n
  let sq = do_command cmds empty
  print_ls (toList sq)

print_ls::[Integer]->IO()
print_ls [] = return ()
print_ls (x:xs) = do
  putStr (show x)
  if xs == [] then putStr "\n" else do
                                  putStr " "
                                  print_ls xs

