#include <iostream>
#include <vector>
#include <fstream>
using namespace std;


struct node {
    string key;
    vector < vector < string > > a;
};

struct bignode {
    vector < node > A;
};

int hashfunc(string s)
{
    unsigned int res, pow, p;

    res = 0;
    pow = 1;
    p = 31;

    for(int i = 0; i < s.length(); i++)
    {
        res += (s[i] - 'A') * pow;
        pow *= p;
    }

    return res % 100001;
}


int key_inchain(vector < bignode > &arr, string k)
{
    int x = hashfunc(k);
    for (int i = 0; i < arr[x].A.size(); i++)
    {
        if (arr[x].A[i].key == k)
        {
            return i;
        }
    }
    return 1;
}

string getp(vector < bignode > &arr, string k, vector < string > &elements)
{
    int c = 0;
    int index = key_inchain(arr, k);
    int x = hashfunc(k);
    if (index != -1) //if key exists
    {
        for (int i = 0; i < arr[x].A[index].a.size(); i++)
        {
            c++;
            elements.push_back(arr[x].A[index].a[i]);
        }
    }
    return c;
}

void add(vector < bignode > &arr, string k, string v)
{
    int x = hashfunc(k);
    int index = key_inchain(arr, k);
    if (index == -1) //key not there
    {
        node q;
        q.key = k;
        q.a.push_back(v);
        arr[x].A.push_back(q);
    } else {
        int exists = 0;
        for (int i = 0; i < arr[x].A[index].a.size())
        {
            if (arr[x].A[index].a[i] == v)
            {
                exists = 1;
            }
        }
        if (exists == 0)
        {
            arr[x].A[index].a.push_back(v);
        }
    }
}

void del(vector < bignode > &arr, string k, string v)
{
    int index = key_inchain(arr, k);
    int x = hashfunc(k);

    if (index != -1) //exist key
    {
        int exists = 0;
        int pairindex = -1;
        for (int i = 0; i < arr[x].A[index].a.size())
        {
            if (arr[x].A[index].a[i] == v)
            {
                exists = 1;
                pairindex = i;
            }
        }

        if(exists) //exists pair
        {
            if (arr[x].A[index].a.size() == 1) //dell key
            {
                vector < node > >::iterator it;
                it = arr[x].A.begin() + index;
                arr[x].A.erase(it);
            } else {
                vector < int > >::iterator it;
                it = arr[x].A[index].a.begin() + pairindex;
                arr[x].A[index].a.erase(it);
            }
        }
    }
}

void delall(vector < bignode > &arr, string k)
{
    int index = key_inchain(arr, k);
    int x = hashfunc(k);
    if (index != -1)
    {
        vector < node > >::iterator it;
        it = arr[x].A.begin() + index;
        arr[x].A.erase(it);
    }
}

int main()
{
    bignode default_node;
    vector < bignode > arr (100001, default_node);

    ifstream fin("1.txt");
    ofstream fout("map.out");

    vector < string > elements;

    string command;
    string key;
    string value;
    while (fin >> command)
    {
        if (command == "put")
        {
            fin >> key;
            fin >> value;
            add(arr, key, value);
        } else if (command == "get")
        {
            fin >> key;
            answer = getp(arr, key, elements);
            cout << answer << " ";
            if (answer != 0)
            {
                for (int i = 0; i < elements.size(); i++)
                {
                    cout << elements[i] << " ";
                }
            }
            elements.clear();
            cout << "\n";
        } else if (command == "delete")
        {
            fin >> key >> value;
            del(arr, key, value);
        } else if (command == "deleteall")
        {
            fin >> key;
            delall(arr, key);
        }
    }
    return 0;
}