#include<map>
#include<tuple>
#include<cmath>
#include<queue>
#include<vector>
#include<iostream>
#include<algorithm>
#define MAX_MEMBER 105
struct Varr{
    std::string type_name;/*类型名*/
    int memory;/*此变量占用内存大小*/
    int start_address;/*此变量起始位置*/
    int end_address;/*此变量结束位置*/
};
struct S{
    int member_count;/*成员个数*/
    int max_memory;/*对齐要求(其成员的对齐要求的最大值)*/
    int memory_used;/*该结构体占用的内存*/
    std::map<std::string,Varr>member_guide;/*<成员名,tuple<类型,内存>*/
};
std::map<std::string,S>guide;/*寻找目标结构体*/
std::map<std::string,int>get_memory;/*得到目标类型/结构体 占用内存大小*/
std::map<std::string,Varr>guide_varr;/*寻找目标变量*/
int nearNum(int x,int k){
    int q=x/k,p=q*k;
    return (p==x?x:p+k);
}
bool chk(const std::string &s){
    return s=="byte"||s=="int"||s=="short"||s=="long";
}
int main(){
	freopen("P9754_6.in","r",stdin);
	freopen("P9754_6.ans","w",stdout);
	guide["int"]={0,4,4,{}};
	guide["byte"]={0,1,1,{}};
	guide["long"]={0,8,8,{}};
	guide["short"]={0,2,2,{}};
    int cur_memory=0; /*到现在为止，所有变量(op 2)占用的总内存*/
    get_memory["byte"]=1;
    get_memory["short"]=2;
    get_memory["int"]=4;
    get_memory["long"]=8;
    int n;/*操作数量*/
    std::cin>>n;
    while(n--){
        int op; /*操作类型*/
        std::cin>>op;
        
        if(op==1){/*新建一个结构体 */
            std::string struct_name;/*新建结构体的名字*/
            std::cin>>struct_name;
            int k;/*成员个数*/
            std::cin>>k;
            guide[struct_name].member_count=k;
			
			
	//		std::cout<<1<<" "<<struct_name<<k<<" |  "; 
			
			
			
            int max_mem=0,now_memory=0;

            for(int i=1;i<=k;i++){/*读入新建结构体的成员 */
                std::string typename_;/*成员的类型*/
                std::cin>>typename_;
                std::string member_name;/*成员的名字*/
                std::cin>>member_name;

                max_mem=std::max(max_mem,get_memory[typename_]);/*找到占用内存最大的值*/
                int start_add=nearNum(now_memory,get_memory[typename_]);
                int end_add=start_add+get_memory[typename_]-1;
                
           //     std::cout<<"wflwfgwe "<<start_add<<" "<<end_add<<std::endl;
                
                guide[struct_name].member_guide[member_name]={typename_,get_memory[typename_],start_add,end_add};
                now_memory=end_add+1;
       //         std::cout<<typename_<<std::endl;
            }
            guide[struct_name].max_memory=max_mem;

            get_memory[struct_name]=nearNum(now_memory,max_mem);/*记录新建结构体占用内存大小*/
			guide[struct_name].memory_used=get_memory[struct_name];
			
			
			
            std::cout<<get_memory[struct_name]<<" "<<guide[struct_name].max_memory<<std::endl;

        }else if(op==2){
            std::string typename_;/*新创建变量的类型名*/
            std::cin>>typename_;
            std::string varrible_name;/*变量名称*/
            std::cin>>varrible_name;
			guide_varr[varrible_name].type_name=typename_;
			
			
	//		std::cout<<2<<" "<<typename_<<" "<<varrible_name<<" |  ";
			
			
            int varr_memory=get_memory[typename_];/*该变量占用内存*/
            guide_varr[varrible_name].memory=varr_memory;
            
            int start_add=nearNum(cur_memory,guide[typename_].max_memory);
            int end_add=start_add+get_memory[typename_]-1;

            guide_varr[varrible_name].start_address=start_add;
            guide_varr[varrible_name].end_address=end_add;

            std::cout<<start_add<<std::endl;
            cur_memory=end_add+1;

        }else if(op==3){
            std::string name;
            std::cin>>name;

	//		std::cout<<3<<" "<<name<<" |  ";

            std::vector<std::string>visiting;//将name分成 a/b/c/d...
            std::string t;
            for(int i=0;i<name.size();i++){
                if(name[i]=='.'){
                    visiting.push_back(t);
                    t.clear();
                }else{
                    t=t+name[i];
                }
            }
            if(t.size()!=0){
                visiting.push_back(t);
                t.clear();
            }
            
            if(visiting.size()==1){//基本类型
                std::cout<<guide_varr[visiting[0]].start_address<<std::endl;
            }else{
                int cur=0;
                std::string fromstruct_name=guide_varr[visiting[0]].type_name;
                
                for(int i=1;i<visiting.size();i++){
                    std::string nextstruct_name=guide[fromstruct_name].member_guide[visiting[i]].type_name;
                    
                    cur=guide[fromstruct_name].member_guide[visiting[i]].start_address;
                    fromstruct_name=nextstruct_name;
                }
                std::cout<<guide_varr[visiting[0]].start_address+cur<<std::endl;
            }
        }else if(op==4){
            
            int targetPosition;
            std::cin>>targetPosition;

		//	std::cout<<4<<" "<<targetPosition<<" |  ";

            std::queue<std::pair<Varr,std::string>>q;
            //string + varr
            for(auto x:guide_varr){
                q.push({x.second,x.first});
            }

            while(q.size()){
                auto u=q.front();
//                std::cout<<u.first.type_name<<" "<<u.first.start_address<<" "<<u.first.end_address<<" "<<u.first.memory<<std::endl;
//                std::cout<<u.second<<std::endl;
                q.pop();
//                std::cout<<(u.first.start_address<=targetPosition)<<" "<<(u.first.end_address>=targetPosition)
//				<<" "<<(chk(u.first.type_name))<<std::endl;
                if(u.first.start_address<=targetPosition&&u.first.end_address>=targetPosition&&chk(u.first.type_name)){
                    std::cout<<u.second<<std::endl;
                    goto Hello_World;
                }
                std::string varrtypename=u.first.type_name;
                int starting=u.first.start_address;
                int ending=u.first.end_address;
                
          //      std::cout<<starting<<" "<<ending<<std::endl;
                
                for(auto lx:guide[varrtypename].member_guide){
                    //string + Varr;
                    //Varr: typename,begin,end,memory
        //          std::string origin=u.second.substr(u.second.rfind('.')+1);
                    std::string path=u.second+"."+lx.first;
                    //Varr + string;
                    std::string typename__=lx.second.type_name;

                    int nowbegin=starting+lx.second.start_address;
                    int nowend=starting+lx.second.end_address;
                    
      //             std::cout<<lx.second.start_address<<" "<<lx.second.end_address<<std::endl;
          //          std::cout<<nowbegin<<" "<<nowend<<"\n";
                    std::pair<Varr,std::string>temp;
                    temp.first={typename__,get_memory[typename__],nowbegin,nowend};
                    temp.second=path;
                    q.push(temp);
                    
              //     std::cout<<nowbegin<<" "<<nowend<<"\n";
                  //	std::cout<<typename__<<std::endl;
                }
            }
            puts("ERR");
        }
        Hello_World:;
    }
}