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: Memory Limit Exceeded)

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
                    (seq sq' (return sq'))
                    ) empty [1..n]
  print_ls (toList res)