#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 EntrySet
{
public:
    T data;
    bool existence;

    EntrySet() : existence(false)
    {}

    EntrySet(T data) : existence(true)
    {
        this->data = data;
    }

    EntrySet& operator=(const EntrySet& entry) noexcept
    {
        if (this == &entry)
            return *this;

        this->data = entry.data;
        this->existence = entry.existence;

        return *this;
    }

    bool operator==(const EntrySet& entry)
    {
        if (existence == false && entry.existence == false)
            return true;

        return (existence == entry.existence) && (data == entry.data);
    }

    bool operator!=(const EntrySet& entry)
    {
        if (existence == false && entry.existence == false)
            return false;

        return (existence != entry.existence) || data != entry.data;
    }

    bool operator==(const int& data)
    {
        return existence && (this->data == data);
    }
};

template<class T>
class DoubleHashSet : public virtual ISet<T>
{
private:
    EntrySet<T>* arr_;
    int size_{};
    const int CAPACITY = 379;
    const int prime_num = 37;
    /*const int CAPACITY = 2027;
    const int prime_num = 103;*/
    //1993
    const EntrySet<T> DEFAULT_ENTRY;

    int hash_func_1(T item)
    {
        auto hash_ = hash<T>();
        int ha = hash_(item);
        return abs(ha);
    }
    int hash_func_2(T item, int hash1)
    {
        return (prime_num - abs(hash1) % prime_num);
    }

    bool findIndex(T item, int* index = nullptr)
    {
        int hash1 = hash_func_1(item);
        int hash2 = hash_func_2(item, hash1);
        int hash_code;
        for (int j = 1; j < CAPACITY; j++)
        {
            hash_code = (hash1 + j * hash2) % CAPACITY;
            if (arr_[hash_code] != DEFAULT_ENTRY && arr_[hash_code] == item)
            {
                if (index != nullptr)
                    *index = hash_code;
                return true;
            }
        }
        return false;
    }
public:
    DoubleHashSet() :size_(0), DEFAULT_ENTRY(EntrySet<T>())
    {
        arr_ = new EntrySet<T>[CAPACITY];
    }

    DoubleHashSet(const DoubleHashSet& set)
    {
        this->size_ = set.size_;
        this->arr_ = new EntrySet<T>[CAPACITY];
        std::copy(set.arr_, set.arr_ + set.CAPACITY, this->arr_);
    }

    ~DoubleHashSet()
    {
        delete[] arr_;
    }

    void add(T item) override
    {
        int index;

        if (size() == CAPACITY)
            throw overflow_error("Set is full");

        int hash1 = hash_func_1(item);
        int hash2 = hash_func_2(item, hash1);
        int hash_code;
        for (int j = 1; j < CAPACITY; j++)
        {
            hash_code = (hash1 + j * hash2) % CAPACITY;
            if (arr_[hash_code] == DEFAULT_ENTRY)
            {
                size_++;
                arr_[hash_code] = EntrySet<T>(item);
                return;
            }
        }
    }
    void remove(T item) override
    {
        int hash1 = hash_func_1(item);
        int hash2 = hash_func_2(item, hash1);
        int hash_code;

        for (int j = 1; j < CAPACITY; j++)
        {
            hash_code = (hash1 + j * hash2) % CAPACITY;
            if (arr_[hash_code] == item)
            {
                size_--;
                arr_[hash_code] = DEFAULT_ENTRY;
                return;
            }
        }
    }
    bool contains(T item) override
    {
        return findIndex(item);
    }
    int size() override
    {
        return size_;
    }
    bool isEmpty() override
    {
        return size_ == 0;
    }

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

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

        delete[] arr_;

        this->size_ = set.size_;
        this->arr_ = new EntrySet<T>[CAPACITY];
        std::copy(set.arr_, set.arr_ + set.CAPACITY, this->arr_);

        return *this;
    }
};

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
            {
                while (undo_parameter--)
                {
                    StatusSet.pop();
                }
                Set = StatusSet.top();
            }
        }

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

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

}