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

data Command = INS Int | DEL Int | 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 Int->Seq Int
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'= case viewl sq' of
                                                l:<rest ->if l == x then rest
                                                                    else l<|(rec_del $! rest)
                                                EmptyL  ->sq'
                               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::Int->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::[Int]->IO()
print_ls [] = return ()
print_ls (x:xs) = do
  putStr (show x)
  if xs == [] then putStr "\n" else do
                                  putStr " "
                                  print_ls xs

main::IO()
main=do
  nc<-getLine
  let n = read nc
  res<-foldM (\ sq -> \ _ -> do
                    str<-getLine
                    let sq' = do_command [parse str] sq
                    return $! sq'
                    ) empty [1..n]
  print_ls (toList res)
