//	-*- mode: C++ -*-
//	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

#include <iostream>
#include <string>
#include <cstdio>

typedef struct element {
	unsigned int	key;
	element*		next;
	element*		prev;
} element;

class DLList{
private:
	static constexpr	unsigned int	maxElements	= 2000000 + 2;
	element				elements[maxElements];
	unsigned int		headIndex;
	unsigned int		tailIndex;

public:
	DLList();
	~DLList(){};

	void	insertKey(const unsigned int	key);
	void	deleteKey(const unsigned int	key);
	void	deleteFirst();
	void	deleteLast();
	inline void	initializeList()
	{
		headIndex	= 0;
		tailIndex	= 1;
		elements[headIndex].prev	= NULL;
		elements[headIndex].next	= &elements[tailIndex];
		elements[tailIndex].prev	= &elements[headIndex];
		elements[tailIndex].next	= NULL;
	};
	void	print();
};

DLList::DLList()
{
	initializeList();
}

void	DLList::insertKey(const unsigned int	key)
{
	auto	prev	= &elements[tailIndex];

	elements[tailIndex].key		= key;
	elements[tailIndex].next	= &elements[tailIndex + 1];
	++tailIndex;
	elements[tailIndex].prev	= prev;
	elements[tailIndex].next	= NULL;
}

void	DLList::deleteKey(const unsigned int	key)
{
	// 本メソッドが呼ばれるときは必ず要素がある
	auto	current	= elements[tailIndex].prev;

	while(current->prev){
		if(current->key	== key){
			auto	next	= current->next;
			auto	prev	= current->prev;

			next->prev	= prev;
			prev->next	= next;
			break;
		}

		current	= current->prev;
	}
}

void	DLList::deleteFirst()
{
	// 本メソッドが呼ばれるときは必ず要素がある
	auto	newPrev	= elements[tailIndex].prev->prev;

	newPrev->next	= &elements[tailIndex];
	elements[tailIndex].prev	= newPrev;
}

void	DLList::deleteLast()
{
	// 本メソッドが呼ばれるときは必ず要素がある
	auto	newNext	= elements[headIndex].next->next;

	newNext->prev	= &elements[headIndex];
	elements[headIndex].next	= newNext;
}

void	DLList::print()
{
	auto	current	= elements[tailIndex].prev;
	if(current->prev == NULL){
		return;
	}

	std::cout << current->key;

	current	= current->prev;
	while(current->prev){
		std::cout << ' '  << current->key;

		current	= current->prev;
	}

	std::cout << '\n';
}

DLList				l;

int	main(int	argc,
		 char*	argv[])
{
	unsigned int	n	{0};
	scanf("%u", &n);

	for(unsigned int i = 0; i < n; ++i){
		char	command[12];
		scanf("%s", command);

		unsigned int	key	{0};
		char	c6	= command[6];
		char	c0	= command[0];
		if(c6 == 'F'){
			l.deleteFirst();
		}
		else if(c6 == 'L'){
			l.deleteLast();
		}
		else if(c0 == 'i'){
			scanf("%u", &key);
			l.insertKey(key);
		}
		else{
			scanf("%u", &key);
			l.deleteKey(key);
		}
	}

	l.print();

	return	0;
}



Measured memory_bytes: 28924