12 8
<tag1 value = "HelloWorld">
	<tag2 name = "Name1">
		<tag3 name = "Name3">
		</tag3>
		<tag4 name = "Name4" text = "Super">
			<tag6 buzz = "Buzz6">
			</tag6>
		</tag4>
		<tag5>
		</tag5>
	</tag2>
</tag1>
tag1.tag2~name
tag1~name
tag1~value
tag1.tag2.tag3~name
tag1.tag2.tag3~value
tag1.tag2.tag4~text
tag1.tag2.tag4.tag6~text
tag1.tag2.tag4.tag6~buzz

#include <cstdio>
#include <vector>
#include <iostream>
#include <sstream>
using namespace std;

int search_for_tag(size_t start, string s_end, vector<string> &vec, string needle) {
    int curr = start;
    int end = vec.size();
    string endcur;
    char buff[200];
    while(true) {
        if(vec[curr][0] == '|') {
            //see if its the one
            if(!vec[curr].compare(needle)) {
                return curr;
            //see if its the end
            } else if (!vec[curr].compare(s_end) ){
                return -1;
            //pass this tag
            } else {
                vec[curr].copy(buff,vec[curr].size(),0);
                buff[vec[curr].size()] = '\0';
                endcur = "|" + string(buff);
                endcur.replace(1,1,"/");
                while(vec[curr].compare(endcur)) {
                    curr++;
                }
                curr++;
                if(curr == end) return -1;
            }
        } else {
            while(vec[curr][0] != '|') {
                curr ++;
            }
        }
    }
} 

int search_for_att(size_t start, string s_end, vector<string> &vec, string needle) {
    int curr = start;
    while(vec[curr][0] != '|'){
        if(!vec[curr].compare(needle)) {
            return curr;
        }
        curr++;
        if(curr == vec.size()) return -1;
    }
    return -1;
}

int main() {
    int tlines, qlines;
    string ints;
    getline(cin, ints);
    stringstream ss(ints);
    ss >> tlines;
    ss >> qlines;

    string line;
    char buf[200];
    size_t del_tag;
    vector<string> contain;
    //Parse the shenanigans
    for(int i=0; i<tlines; i++) {
        getline(cin, line);
        del_tag = line.find_first_of(" >");       
        //Get Tag
        line.copy(buf,del_tag-1, 1);
        buf[del_tag-1] = '\0';
        string tagbuf(buf);
        tagbuf = "|" + tagbuf;
        contain.push_back(tagbuf);
        size_t found = line.find("=", del_tag);
        while(found != string::npos) {
            //Get the attribute
            line.copy(buf, found-del_tag-2, del_tag + 1);
            buf[found-del_tag-2] = '\0';
            string attbuf(buf);
            contain.push_back(attbuf);
            //move past the =
            del_tag = found + 2;
            found = line.find("\"", del_tag + 1);
            //Copy the value
            line.copy(buf,found - del_tag - 1, del_tag + 1);
            buf[found-del_tag -1] = '\0';
            string valbuf(buf);
            contain.push_back(valbuf);
            del_tag = line.find(" ", found);
            found = line.find("=", found);
        }
    }
    //Query Time   
    for(int i = 0; i < qlines; i++) {
        size_t startString = 0;
        bool typeTag = true;
        size_t startVec = 0;
        string endVec ="";
        bool notFound = true;
        string attval;
        string line;
        getline(cin,line);
        while (true) {
            //Get next token
            size_t found = line.find_first_of(".~", startString);
            if(found == string::npos) found  = line.size();
            line.copy(buf, found - startString, startString);
            buf[found - startString] = '\0';
            string tagbuf(buf);
            
            //Check if its a Tag
            if(startString > 0 && line[startString-1] == '~') {
                typeTag = false;
            } else {
                tagbuf = "|" + tagbuf;
            }
            //Find a tag
            if(typeTag) {
                int res = search_for_tag(startVec,endVec,contain,tagbuf);
                if(res<0) {
                    break;
                } else {
                    startVec = res+1;
                    endVec = "|" + tagbuf;
                    endVec.replace(1,1,"/");
                    startString = found + 1;
                }
            } else {
                //Find an attibute
                int res = search_for_att(startVec,endVec,contain,tagbuf);
                if(res >=0) {
                    attval = contain[res + 1];
                    notFound = false;
                }
                break;
            }   
        }
        //Printing
        if(notFound) {
            cout << "Not Found!" << endl;
        } else {
            cout << attval << endl;
        }
    }
    return 0;
}

#include <cstdio>
#include <iostream>
#include <sstream>
#include <map>
using namespace std;

struct tagobj {
    string name;
    map<string, tagobj*> tmap;
    map<string, string> map_att;
    tagobj* prev = NULL;
};

void delete_tags(tagobj* tag) {
    for (map<string, tagobj*>::iterator i = tag->tmap.begin() ; i != tag->tmap.end() ; i ++ ) {
        delete_tags(i->second);
    }
    delete(tag);
}

int main(){
    //Setup a vector holding all first level tags
    map<string, tagobj*> main;
    //Current depth so as to nest
    tagobj* masterTag = NULL;

    int tlines, qlines;
    string ints;
    getline(cin, ints);
    stringstream ss(ints);
    ss >> tlines;
    ss >> qlines;

    string line;
    size_t del_tag;
    //Save the information 
    for(int i=0; i<tlines; i++) {
        //Get Tag from line
        getline(cin, line);
        del_tag = line.find_first_of(" >"); 
        string tag = line.substr(1,del_tag-1);
        //opening tags
        if(tag[0] != '/') {
            //Create Struct
            tagobj* currTag = new tagobj();
            currTag->prev = masterTag;
            currTag->name = tag;
            //check if we add to master vector or previous:
            if(!masterTag) {
                main[currTag->name] = currTag;
            } else {
                masterTag->tmap[currTag->name] = currTag;
            }
            masterTag = currTag;
            //Add all attributes
            size_t found = line.find("=", del_tag);
            while(found != string::npos) {
                //Get the attribute
                string name = line.substr(del_tag + 1, found-del_tag-2);
                //move past the =
                del_tag = found + 2;
                found = line.find("\"", del_tag + 1);
                //Copy the value
                string value = line.substr(del_tag + 1,found - del_tag - 1);
                //add to map
                currTag->map_att[name]=value;
                //keep going
                del_tag = line.find(" ", found);
                found = line.find("=", found);
            }
        } else {
            //If its a closing Tag return main tag to its previous
            masterTag = masterTag->prev;
        }
    }
    
    for(int i=0; i < qlines; i++) {
        tagobj* masterq = NULL;
        getline(cin,line);
        size_t start = 0;
        string val;
        bool fnd;
        while (true) {
            size_t found = line.find_first_of(".~", start);
            string buff = line.substr(start,found-start);
            fnd = false;
            //looking for attribute
            if(start > 0 && line[start-1] == '~') {
                //Attributes have a sentinal
                //Check for bad input
                if(masterq) {
                    val = masterq->map_att[buff];
                    if(!val.empty()){
                        fnd = true;
                    }
                    break;
                }
            } else {
                //Looking for a tag, if found, continue looking
                map<string, tagobj*> *bufobj = NULL;
                //Make sure to look in right place
                if(masterq) {
                    bufobj = &(masterq->tmap);
                } else {
                    bufobj = &main;
                }
                tagobj* frommap = (*bufobj)[buff];
                if(frommap) {
                    masterq = frommap;
                } else {
                    break;
                }
            }
            start = found + 1;
        }
        //Printing Time:
        if(fnd) {
            cout << val << endl;
        } else {
            cout << "Not Found!" << endl;
        }
    }
    for (map<string, tagobj*>::iterator i = main.begin() ; i != main.end() ; i ++ ) {
        delete_tags(i->second);
    }
}