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

{-# LANGUAGE BangPatterns #-}
import Control.Monad
import Data.List
import qualified Data.ByteString.Char8 as B
import Data.Maybe (fromJust)
import Debug.Trace
import Data.Functor
import qualified Data.Sequence as S
import Data.Foldable

main :: IO()
main = do
  n <- readLn :: IO Int
  cs <- B.getContents :: IO B.ByteString
  B.putStrLn . B.unwords $ solve''' cs
 
insertC = B.pack "insert"
deleteC = B.pack "delete"
deleteLastC = B.pack "deleteLast"
deleteFirstC = B.pack "deleteFirst"

data Dll a = Dll !Int [a] deriving (Show) 
emptyDll :: Dll a
emptyDll = Dll 0 []
dllToList :: Dll a -> [a]
dllToList (Dll n vs) = take n vs
insertDll :: a -> Dll a -> Dll a
insertDll !v (Dll n vs) = let newn = n + 1 in newn `seq` Dll newn (v:vs)
deleteDll :: (Eq a) => a -> Dll a -> Dll a
deleteDll !v (Dll n vs) = if Data.List.elem v validVs
                          then Dll (n - 1) $ delete v validVs
                          else Dll n validVs
  where
    validVs = take n vs
    delete _ [] = []
    delete !v (b:bcc) = if v == b
                        then bcc
                        else b:(delete v bcc)
deleteLast :: Dll a -> Dll a
deleteLast (Dll n vs) = let newn = n - 1 in newn `seq` Dll newn vs
deleteFirst :: Dll a -> Dll a
deleteFirst (Dll n vs) = let newn = n - 1 in newn `seq` Dll newn $ tail vs

solve''' :: B.ByteString -> [B.ByteString]
solve''' = dllToList . Data.Foldable.foldl' func emptyDll . B.lines
  where
    func :: Dll B.ByteString -> B.ByteString ->Dll B.ByteString
    func acc cs
      | command == insertC = {-# SCC insertDll #-} insertDll val acc
      | command == deleteC = {-# SCC deleteDll #-} deleteDll val acc
      | command == deleteLastC = {-# SCC deleteLastDll #-} deleteLast acc
      | command == deleteFirstC = {-# SCC deleteFirstDll #-} deleteFirst acc
        where
          (command:c) = B.words cs
          (val:_) = c
          delete _ [] = []
          delete !v (b:bcc) = if v == b
                              then bcc
                              else b:(delete v bcc)