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      #-}
{-# LANGUAGE OverloadedStrings #-}

import           Control.Applicative
import           Control.Monad
import qualified Data.ByteString.Char8 as B
import           Debug.Trace

import           Data.Sequence         (Seq (..), ViewL (..), ViewR (..), (<|),
                                        (><), (|>))
import qualified Data.Sequence         as S

readInt' :: B.ByteString -> Int
readInt' bs | Just (n, _) <- B.readInt bs = n

insert :: a -> Seq a -> Seq a
insert = (<|)

delete :: Eq a => a -> Seq a -> Seq a
delete x s =
    case S.viewl r of
        EmptyL -> s
        x :< xs -> l >< xs
  where
    (l, r) = S.breakl (== x) s

deleteFirst :: Seq a -> Seq a
deleteFirst s =
    case S.viewl s of
        x :< xs -> xs

deleteLast :: Seq a -> Seq a
deleteLast s =
    case S.viewr s of
        xs :> x -> xs

make :: [(B.ByteString, Int)] -> Seq Int
make xs = go S.empty xs
  where
    go !seq [] = seq
    go !seq ((com,n):cs)
        | com == "insert" = go (insert n seq) cs
        | com == "delete" = go (delete n seq) cs
        | com == "deleteFirst" = go (deleteFirst seq) cs
        | com == "deleteLast"  = go (deleteLast seq) cs

print' :: Seq Int -> IO ()
print' s =
    case S.viewl s of
        EmptyL -> putStrLn ""
        a :< s' -> putStr (show a) >> go s'
  where
    go s =
        case S.viewl s of
            EmptyL -> putStrLn ""
            a :< s' -> putStr (" " ++ show a) >> go s'

main :: IO ()
main = do
    B.getLine
    let f xs =
            case xs of
                [a]    -> (a, 0)
                [a, b] -> (a, readInt' b)
    xs <- fmap (f . B.words) . B.lines <$> B.getContents
    print' $ make xs