#include <iostream>
#include <queue>
#include <sstream>

using namespace std;

template<class T>
class ICircularBoundedQueue {
public:

	virtual void offer(T value) = 0; // insert an element to the rear of the queue
	// overwrite the oldest elements
	// when the queue is full
	virtual T poll() = 0; // remove an element from the front of the queue
	virtual T peek() = 0; // look at the element at the front of the queue
	// (without removing it)
	virtual void flush() = 0; // remove all elements from the queue
	virtual bool isEmpty() = 0; // is the queue empty?
	virtual bool isFull() = 0; // is the queue full?
	virtual int size() = 0; // number of elements
	virtual int capacity() = 0; // maximum capacity
};

template<class T>
class ArrayCircularBoundedQueue : public virtual ICircularBoundedQueue<T>
{
private:
	const size_t CAPACITY;
	T* arr_;
	T default_value_;
	int index_front_;
	int index_rear_;

public:
	explicit ArrayCircularBoundedQueue(size_t capacity, T default_value) :CAPACITY(capacity), arr_(new T[CAPACITY]), default_value_(default_value), index_front_(-1),
		index_rear_(-1)
	{}

	void offer(T value) override
	{
		if (index_front_ == -1 && index_rear_ == -1)
		{
			arr_[0] = value;
			index_front_ = 0;
			index_rear_ = 0;
		}
		else
		{
			index_rear_ = (index_rear_ + 1) % CAPACITY;

			if (index_rear_ == index_front_)
				index_front_ = (index_front_ + 1) % CAPACITY;

			arr_[index_rear_] = value;
		}
	}
	T poll() override
	{
		if (index_front_ == -1 && index_rear_ == -1)
			return default_value_;

		T val = arr_[index_front_];

		if (index_front_ == index_rear_)
		{
			index_front_ = -1;
			index_rear_ = -1;
		}
		else index_front_ = (index_front_ + 1) % CAPACITY;

		return val;
	}
	T peek() override
	{
		if (index_front_ == -1 && index_rear_ == -1)
			return default_value_;

		return arr_[index_front_];
	}
	void flush() override
	{
		index_front_ = -1;
		index_rear_ = -1;
	}
	bool isEmpty() override
	{
		return (index_front_ == -1 && index_rear_ == -1);
	}
	bool isFull() override
	{
		return abs(index_front_ - index_rear_) == (CAPACITY - 1);
	}
	int size() override
	{
		if (index_front_ == -1 && index_rear_ == -1)
			return 0;

		if (index_front_ <= index_rear_)
			return index_rear_ - index_front_ + 1;

		return CAPACITY - index_front_ + index_rear_ + 1;

	}
	int capacity() override
	{
		return CAPACITY;
	}

	ArrayCircularBoundedQueue& operator=(ArrayCircularBoundedQueue queue) noexcept
	{
		if (this == &queue)
			return *this;

		copy(queue.arr_, queue.arr_ + queue.capacity(), this->arr_);
		this->index_front_ = queue.index_front_;
		this->index_rear_ = queue.index_rear_;
		this->default_value_ = queue.default_value_;

		return *this;
	}
};

template<class T>
class IBoundedStack
{
public:
	virtual void push(T value) = 0; // push an element onto the stack
	// remove the oldest element
		// when if stack is full
	virtual T pop() = 0; // remove an element from the top of the stack
	virtual T top() = 0; // look at the element at the top of the stack
	// (without removing it)
	virtual void flush() = 0; // remove all elements from the stack
	virtual bool isEmpty() = 0; // is the stack empty?
	virtual bool isFull() = 0; // is the stack full?
	virtual int size() = 0; // number of elements
	virtual int capacity() = 0; // maximum capacity
};

template<class T>
class BoundedStack :public IBoundedStack<T>
{
private:
	const size_t CAPACITY;
	const T DEFAULT_VALUE;
	ArrayCircularBoundedQueue<T> main_queue_;
	ArrayCircularBoundedQueue<T> duplicate_queue_;

public:
	BoundedStack(size_t capacity, T default_value) :CAPACITY(capacity), DEFAULT_VALUE(default_value), main_queue_(CAPACITY, default_value), duplicate_queue_(CAPACITY, default_value)
	{}

	void push(T value) override
	{
		main_queue_.offer(value);
	}
	T pop() override
	{
		if (main_queue_.isEmpty())
			return DEFAULT_VALUE;

		while (main_queue_.size() > 1)
		{
			duplicate_queue_.offer(main_queue_.poll());
		}

		T returnValue = main_queue_.poll();

		main_queue_ = duplicate_queue_;
		duplicate_queue_.flush();

		return returnValue;
	}
	T top() override
	{
		T returnValue = pop();
		main_queue_.offer(returnValue);
		return returnValue;
	}
	void flush() override
	{
		main_queue_.flush();
	}
	bool isEmpty() override
	{
		return main_queue_.isEmpty();
	}
	bool isFull() override
	{
		return main_queue_.isFull();
	}
	int size() override
	{
		return main_queue_.size();
	}
	int capacity() override
	{
		return CAPACITY;
	}
};

template<class T>
class ISet {
public:
	virtual void add(T item) = 0; // add item in the set
	virtual void remove(T item) = 0; // remove an item from a set
	virtual bool contains(T item) = 0; // check if a item belongs to a set
	virtual int size() = 0; // number of elements in a set
	virtual bool isEmpty() = 0; // check if the set is empty
};

//template<class T>
//class DoubleHashSet : public virtual ISet<T>
//{
//private:
//	T* arr_;
//	bool* arr_exist_;
//	int size_{ 0 };
//	const int CAPACITY = 1003;
//	const int prime_num = 739;
//
//	void get_hashes(const T& item, long long& hash1, long long& hash2)
//	{
//		auto hash_ = hash<T>();
//
//		const string string_item = (string) item;
//
//		hash1 = abs((int)(hash_(item))) % CAPACITY;
//		hash2 = abs(prime_num - hash1 % prime_num) % (CAPACITY - 2);
//	}
//
//	bool findIndex(T item, int* index = nullptr)
//	{
//		long long hash1;
//		long long hash2;;
//		int hash_code;
//
//		get_hashes(item, hash1, hash2);
//
//		for (int j = 0; j < CAPACITY; j++)
//		{
//			hash_code = (hash1 + j * hash2) % CAPACITY;
//			if (arr_exist_[hash_code] != false && arr_[hash_code] == item)
//			{
//				if (index != nullptr)
//					*index = hash_code;
//				return true;
//			}
//		}
//		return false;
//	}
//public:
//	DoubleHashSet()
//	{
//		arr_ = new T[CAPACITY];
//		arr_exist_ = new bool[CAPACITY];
//
//		for (int i = 0; i < CAPACITY; i++)
//			arr_exist_[i] = false;
//	}
//
//	DoubleHashSet(const DoubleHashSet& set)
//	{
//		this->size_ = set.size_;
//		this->arr_ = new T[CAPACITY];
//		this->arr_exist_ = new bool[CAPACITY];
//		std::copy(set.arr_, set.arr_ + set.CAPACITY, this->arr_);
//		std::copy(set.arr_exist_, set.arr_exist_ + set.CAPACITY, this->arr_exist_);
//	}
//
//	~DoubleHashSet()
//	{
//		delete[] arr_;
//		delete[] arr_exist_;
//	}
//
//	void add(T item) override
//	{
//		if (size() == CAPACITY)
//			throw overflow_error("Set is full");
//
//		long long hash1;
//		long long hash2;
//		int hash_code;
//
//		get_hashes(item, hash1, hash2);
//
//		for (int j = 1; j < CAPACITY; j++)
//		{
//			hash_code = (hash1 + j * hash2) % CAPACITY;
//			if (arr_exist_[hash_code] == false)
//			{
//				size_++;
//				arr_[hash_code] = item;
//				arr_exist_[hash_code] = true;
//				return;
//			}
//		}
//	}
//	void remove(T item) override
//	{
//		long long hash1;
//		long long hash2;
//		int hash_code;
//
//		get_hashes(item, hash1, hash2);
//
//		for (int j = 1; j < CAPACITY; j++)
//		{
//			hash_code = (hash1 + j * hash2) % CAPACITY;
//			if (arr_[hash_code] == item)
//			{
//				size_--;
//				arr_exist_[hash_code] = false;
//				return;
//			}
//		}
//	}
//	bool contains(T item) override
//	{
//		return findIndex(item);
//	}
//	int size() override
//	{
//		return size_;
//	}
//	bool isEmpty() override
//	{
//		return size_ == 0;
//	}
//
//
//
//	DoubleHashSet& operator= (const DoubleHashSet& set)
//	{
//		if (this == &set)
//			return *this;
//
//		delete[] arr_;
//		delete[]arr_exist_;
//
//		this->size_ = set.size_;
//		this->arr_ = new T[CAPACITY];
//		this->arr_exist_ = new bool[CAPACITY];
//
//		std::copy(set.arr_, set.arr_ + set.CAPACITY, this->arr_);
//		std::copy(set.arr_exist_, set.arr_exist_ + set.CAPACITY, this->arr_exist_);
//
//		return *this;
//	}
//};

template <typename T>
class DoubleHashSet : ISet<T>
{
private:
	// pointer to array of T pointers
	T** array;
	int sizeS;
	int CAPACITY = 797;
	int PRIME_NUMBER = 37;

public:
	DoubleHashSet()
	{
		array = new T * [CAPACITY];
		for (int i = 0; i < CAPACITY; i++)
			array[i] = nullptr;
		this->sizeS = 0;
	}

	DoubleHashSet(const DoubleHashSet& copy)
	{
		this->sizeS = copy.sizeS;
		this->array = new T * [CAPACITY];
		std::copy(copy.array, copy.array + copy.CAPACITY, this->array);
	}

	DoubleHashSet& operator= (const DoubleHashSet& set)
	{
		if (this == &set)
			return *this;

		delete[] this->array;

		this->sizeS = set.sizeS;
		this->array = new T * [CAPACITY];
		std::copy(set.array, set.array + set.CAPACITY, this->array);

		return *this;
	}

	~DoubleHashSet()
	{
		delete[] array;
	}

	void add(T item)
	{
		if (!contains(item))
		{
			int i = 0, h1, h2;
			h1 = hashCode1(item);
			h2 = hashCode2(item, h1);
			while (array[(h1 + i * h2) % CAPACITY] != nullptr && i < CAPACITY)
				i++;

			int index = (h1 + i * h2) % CAPACITY;
			array[index] = new T;
			array[index][0] = item;
			sizeS++;
		}
	}

	/**
	 * \remove element in array[index] if it exists
	}
	 * \param element
	 */

	virtual void remove(T item)
	{
		int index = 0;
		if (contains(item, index))
		{
			array[index] = nullptr;
			sizeS--;
		}
	}

	virtual bool contains(T item)
	{
		int i = 0, h1, h2;
		h1 = hashCode1(item);
		h2 = hashCode2(item, h1);
		while (i < CAPACITY)
		{
			int index = (h1 + i * h2) % CAPACITY;

			if (array[index] != nullptr)
				if (array[index][0] == item)
					return true;
			i++;
		}
		return false;
	}

	int size()
	{
		return this->sizeS;
	}

	bool isEmpty()
	{
		return (this->sizeS == 0);
	}
	/**
	 * \print all element that DoubleHashSet contains
	 * \return line with all elements
	 */
	string ToString()
	{
		ostringstream answer;
		for (int i = 0; i < CAPACITY - 1; i++)
			if (array[i] != nullptr)
				answer << array[i][0] << " ";

		if (array[CAPACITY - 1] != nullptr)
			answer << array[CAPACITY - 1][0];
		return answer.str();

	}

	operator string() const
	{
		ostringstream ans;
		for (int i = 0; i < CAPACITY; i++)
			if (array[i] != nullptr)
				ans << array[i][0] << " ";
		return ans.str();
	}

private:

	int hashCode1(T key) {

		auto hashfunc = hash<T>();

		int hashcode = hashfunc(key);

		return abs(hashcode) % CAPACITY;
	}

	int hashCode2(T key, int hash1) {

		return (PRIME_NUMBER - (abs(hash1) % PRIME_NUMBER));
	}

	virtual bool contains(T item, int& out_index)
	{
		int i = 0, h1, h2;
		h1 = hashCode1(item);
		h2 = hashCode2(item, h1);
		while (i < CAPACITY)
		{
			int index = (h1 + i * h2) % CAPACITY;

			if (array[index] != nullptr)
				if (array[index][0] == item)
				{
					out_index = index;
					return true;
				}
			i++;
		}

		return false;
	}
};

void parse_line(string& line, string& command, string& parameter)
{
	const size_t space_index = line.find(' ');

	if (space_index != string::npos)
	{
		command = line.substr(0, space_index);
		parameter = line.substr(space_index + 1);
	}
	else
	{
		command = line.substr(0);
		parameter = "";
	}
}

int main()
{
	int n, k;
	cin >> n >> k;

	DoubleHashSet<string> Set;
	BoundedStack<DoubleHashSet<string>> StatusSet(k, DoubleHashSet<string>());
	bool flag = true;

	string line, command, parameter;
	getline(cin, line);

	for (int i = 0; i < n; i++)
	{
		getline(cin, line);

		parse_line(line, command, parameter);

		if (command == "NEW")
		{
			string second_name = parameter;

			if (second_name[second_name.size() - 1] == '/')
				second_name = second_name.substr(0, second_name.size() - 1);
			else second_name = second_name.append("/");

			if (!(Set.contains(second_name) || Set.contains(parameter)))
			{
				Set.add(parameter);
				StatusSet.push(Set);
			}
			else cout << "ERROR: cannot execute " << command.append(" ").append(parameter).append("\n");
		}

		if (command == "REMOVE")
		{
			if (Set.contains(parameter))
			{
				Set.remove(parameter);
				StatusSet.push(Set);
			}
			else cout << "ERROR: cannot execute " << command.append(" ").append(parameter).append("\n");
		}

		if (command == "UNDO")
		{
			int undo_parameter = 1;
			if (!parameter.empty())
				undo_parameter = stoi(parameter, nullptr, 10);

			if ((!flag && (undo_parameter == StatusSet.size())) || (undo_parameter >= k) || undo_parameter > StatusSet.size())
			{
				cout << "ERROR: cannot execute " << command.append(" ").append(parameter).append("\n");
			}
			else
			{
				for (int i = 0; i < undo_parameter; i++)
				{
					StatusSet.pop();
				}
				Set = StatusSet.top();
			}
		}

		if (command == "LIST")
		{
			cout << static_cast<string>(Set) << endl;
		}

		if (flag)
			flag = !StatusSet.isFull();
	}

}