#include <iostream>
#include <queue>
#include <map>
using namespace std;

int main() {
    int n, q; cin >> n >> q;
    string s;
    queue<string>qu;
    map<string, string>mp;
    string cur = "", lst = "";
    while(cin >> s){
        if(qu.size() >= q)
            qu.pop();
        qu.push(s);
        if(s[0] == '<'){
            if(s[1] == '/'){
                while(!cur.empty() && cur.back() != '.'){
                    cur.pop_back();
                }
                if(!cur.empty())
                    cur.pop_back();
            }
            else{
                s.erase(0, 1);
                if(s.back() == '>') 
                   s.pop_back();
                if(!cur.empty())
                    cur += "." + s;
                else
                    cur += s;
            }
        }
        else if(s[0] == '='){
            cin >> s;
            s.erase(0, 1);
            while(s.back() == '"' || s.back() == '>'){
                s.pop_back();
            }
            string q = cur + '~' + lst;
            mp[q] = s;
            // cout << q << ' ' << mp[q] << endl;  
        }
        lst = s;
    }
    while(!qu.empty()){
        if(mp.find(qu.front()) == mp.end())
            cout << "Not Found!\n";
        else 
            cout << mp[qu.front()] << endl;
        qu.pop();
    }
    return 0;
}

#include <cmath>
#include <cstdio>
#include <vector>
#include <iostream>
#include <algorithm>
using namespace std;

vector<string> getQuery(vector<string> query) {
    int l, st;
    string buf;
    query.clear();
    getline(cin, buf);
    l = buf.length();
    st = 0;
    for (int i = 0; i < l; i++) {
        if (buf[i] == '.') {
            query.push_back(buf.substr(st, i - st));
            st = i + 1;
        }
        else if (buf[i] == '~') {
            query.push_back(buf.substr(st, i - st));
            st = i;
            query.push_back(buf.substr(st, l - st));
        }
    }
    return query;
}

void resolveQuery(vector<string> query, vector<string> listing) {
    int lQ = query.size();
    int lL = listing.size();
    int iQ = 0;
    int listS, attL, lineL;
    vector<string> currentTagList;
    for (int j = 0; j < lL; j++) {
        if (listing[j][1] == '/') { 
            currentTagList.pop_back(); //we remove last tag from the list, valid listing means, we dont need to check what tag it is
        }
        else {
            int k = 1;
            while (listing[j][k] != ' ' && listing[j][k] != '>') {
                k++;
            }
            string newTag = listing[j].substr(1, k-1);
            currentTagList.push_back(newTag);
            if (newTag == query[iQ]) {
                iQ++;
                if (query[iQ][0] == '~') { //we are on the attribute query, our value is on this line, or nowhere
                    listS = currentTagList.size();
                    for (int i = 0; i < listS; i++) {
                        if (currentTagList[i] != query[i]) {
                            cout << "Not Found!" << endl;
                            return;
                        }
                    }
                    attL = query[iQ].length() - 1; //don't count '~'
                    lineL = listing[j].length();
                    for (int i = 1; i + attL < lineL; i++) {
                        if (listing[j].substr(i, attL + 1) == ' ' + query[iQ].substr(1, attL)) {
                            k = i + attL;
                            while (listing[j][k] != '"') {
                                k++;
                            }
                            k++;
                            while (listing[j][k] != '"') {
                                cout << listing[j][k];
                                k++;
                            }
                            cout << endl;
                            return;
                        }
                    }
                    cout << "Not Found!" << endl; //since we didn't find <attribute> on this line we can safetly return
                    return;
                }
            }
        }
    }
    cout << "Not Found!" << endl; //if we gone through the whole list without finding out tag we do not forget to print the result
    return;
}

int main() {
    vector<string> listing;
    vector<string> query;
    int t, q;
    string buffer;
    cin >> t >> q;
    listing.reserve(t);
    getline(cin, buffer); //clearing cin from last endl
    for (int i = 0; i < t; i++) {
        getline(cin, buffer);
        listing.push_back(buffer);
    }
    for (int i = 0; i < q; i++) {
        query = getQuery(query);
        resolveQuery(query, listing);
    }
    return 0;
}

// Online C++ compiler to run C++ program online
#include <cmath>
#include <cstdio>
#include <vector>
#include <iostream>
#include <algorithm>
#include <string>
#include <map>
#include <stack>
#include <sstream>
using namespace std;

string parseTag(map<string, map<string, string>*>& tags) {
    string line;
    string tag;
    string word;
    getline(cin, line);
    stringstream ss(line);
    if(line[1] == '/') {
        return "";
    }
    ss >> word;
    if(word.back() != '>') {
        tag = (word.substr(1));
        tags.emplace(tag, new map<string, string>());
    }
    else {
        tag = (word.substr(1, word.size()-2));
        tags.emplace(tag, new map<string, string>());
        return tag;
    }
    
    
    while((word.back() != '>')) {
        string value;
        ss >> word;
        string attribute = word;
        ss >> word;
        ss >> word;
        if(word.back() == '>')
            value = word.substr(1, word.size()-3);
        else {
            value = word.substr(1, word.size()-2);
        }
        tags.at(tag)->emplace(attribute, value);
    }
    return tag;
}

string getAttributeValue(string attr, map<string, string> attrValuePair) {
    string value;
    try {
        return attrValuePair.at(attr);
    } catch(const out_of_range& ex) {
        return "Not Found!";
    }
}

string parseOutput(vector<string>& input, string line) {
    stringstream ln(line);
    string word;
    getline(ln, word, '.');
    while(word.find("~") == string::npos) {
        input.push_back(word);
        getline(ln, word, '.');
    }
    size_t pos = word.find("~");
    input.push_back(word.substr(0, pos));
    return word.substr(pos+1);
}

bool checkValidity(vector<string> tagChain, map<string, vector<string>> tagMapper, map<string, int> tagLevels) {
    string tag, prevTag;
    for(int i = 1; i < tagChain.size(); i++) {
        prevTag = tagChain.at(i-1);
        tag = tagChain.at(i);
        try {
            vector<string> vec = tagMapper.at(prevTag);
            if(find(vec.begin(), vec.end(), tag) == vec.end()) {
                return false;
            }
        } catch(const out_of_range& ex) {
            return false;
        }
    }
    try {
            if(tagChain.size() - 1 != tagLevels.at(tagChain.back()))
                return false;
        } catch(const out_of_range& ex) {
            return false;
        }
    
    return true;
}

int main() {
    // Write C++ code here
    
    map<string, map<string, string>*> tags; // tag and its attributes
    map<string, vector<string>> tagMapper; // tag and its children tags
    map<string, int> tagLevels; // tag and their hierarchical level
    stack<string> tagTrace;
    string line;
    int n, q;
    getline(cin, line);
    stringstream input(line);
    input >> n >> q;

    for(int i = 0; i < n; i++) {
        string tag = parseTag(tags);
        if(tag.empty()) {
            tagTrace.pop();
            continue;
        }
        tagLevels.emplace(tag, tagTrace.size());
        if(tagTrace.size() > 0) {
            tagMapper.at(tagTrace.top()).push_back(tag);
        }
        tagTrace.push(tag);
        tagMapper.emplace(tag, vector<string>());
    }
    
    for(int i = 0; i < q; i++) {
        string currentTag;
        string attribute;
        vector<string> tagChain;
        getline(cin, line);
        attribute = parseOutput(tagChain, line);
        //cout << "Attribute: " << attribute << endl;
        if(checkValidity(tagChain, tagMapper, tagLevels)) {
            try {
                map<string, string>* attrValuePair = tags.at(tagChain.back());
                cout << getAttributeValue(attribute, *attrValuePair) << endl;
            } catch(const out_of_range& ex) {
                cout << "Not Found!" << endl;
            }
        } else {
            cout << "Not Found!" << endl;
        }
        
            
    }

    return 0;
}