from sys import stdin
import sys
class node:
    def __init__(self,num,pre = None,nextnode = None):
        self.num = num
        self.prenode = pre
        self.nextnode = nextnode
    
class doubly_linked_list:
    import sys
    begin_node = None
    end_node = None
    
    def insert(self,num):
        if(self.end_node):
            self.end_node.nextnode = node(num,pre = self.end_node)
            self.end_node = self.end_node.nextnode
        else:
            self.begin_node = self.end_node = node(num)
    def deleteFirst(self):
        if self.begin_node is self.end_node:
            self.begin_node = self.end_node = None
        else:
            self.begin_node = self.begin_node.nextnode
            self.begin_node.prenode = None
            
    def deleteLast(self):
        if self.begin_node is self.end_node:
            self.begin_node = self.end_node = None
        else:        
            self.end_node = self.end_node.prenode
            self.end_node.nextnode = None

    def delete_num(self, target):
        it = self.begin_node
        while it is not None:
            if it.num == target:
                if it.prenode is None and it.nextnode is None:
                    self.begin_node = self.end_node = None
                else:
                    if it.prenode is not None:
                        it.prenode.nextnode = it.nextnode
                    else:
                        self.begin_node = self.begin_node.nextnode
  
                    if it.nextnode is not None:
                        it.nextnode.prenode = it.prenode
                    else:
                        self.end_node = self.end_node.prenode
                break
            it = it.nextnode
            
    def print_all(self):
        current_node = self.begin_node
        while(current_node is not self.end_node):
            print(current_node.num,end = " ",flush = True)
            current_node = current_node.nextnode
        print(self.end_node.num,flush = True)
        sys.stdout.flush()
        
n = int(input())
dll = doubly_linked_list()
dll.insert(stdin.readline().strip().split()[1])

for i in range(n - 1):
    command = stdin.readline().strip()
    if(command == "deleteFirst"):
        dll.deleteFirst()
    elif(command == "deleteLast"):
        dll.deleteLast()
    else:
        command,num = command.split(sep = " ")
        #num = int(num)
        if(command == "delete"):
            dll.delete(num)            
        else:
            dll.insert(num)
dll.print_all()


### FIXED CODE ###

class Node(object):
    def __init__(self, num, prv = None, nxt = None):
        self.num = num
        self.prv = prv
        self.nxt = nxt
  
  
class DoublyLinkedList(object):
    def __init__(self):
        self.start = self.last = None
  
    def insert(self, num):
        new_elem = Node(num)
  
        if self.start is None:
            self.start = self.last = new_elem
        else:
            new_elem.nxt = self.start
            self.start.prv = new_elem
            self.start = new_elem
  
    def delete_num(self, target):
        it = self.start
        while it is not None:
            if it.num == target:
                if it.prv is None and it.nxt is None:
                    self.start = self.last = None
                else:
                    if it.prv is not None:
                        it.prv.nxt = it.nxt
                    else:
                        self.start = self.start.nxt
  
                    if it.nxt is not None:
                        it.nxt.prv = it.prv
                    else:
                        self.last = self.last.prv
                break
            it = it.nxt
  
    def delete_start(self):
        if self.start is self.last:
            self.start = self.last = None
        else:
            self.start.nxt.prv = None
            self.start = self.start.nxt
  
    def delete_last(self):
        if self.start is self.last:
            self.start = self.last = None
        else:
            self.last.prv.nxt = None
            self.last = self.last.prv
  
    def get_content(self):
        ret = []
        it = self.start
  
        while it is not None:
            ret.append(it.num)
            it = it.nxt
  
        return ' '.join(ret)
  
  
def _main():
    from sys import stdin
  
    n = int(input())
  
    lst = DoublyLinkedList()
      
    for _ in range(n):
        cmd = stdin.readline().strip().split()
        if cmd[0] == 'insert':
            lst.insert(cmd[1])
        elif cmd[0] == 'delete':
            lst.delete_num(cmd[1])
        elif cmd[0] == 'deleteFirst':
            lst.delete_start()
        elif cmd[0] == 'deleteLast':
            lst.delete_last()
  
    print(lst.get_content())
  
  
if __name__ == '__main__':
    _main()