#include <iostream>
#include <list>
#include <map>

#define _STD ::std::

class Class;
class BaseType;

class Base {
public:
	int offset = -1;
	bool isBase = false;
	friend class Class;
	friend class BaseType;
	virtual void* alloc() const noexcept = 0;
	virtual void dealloc(void* ptr) const noexcept = 0;
	virtual int size() const noexcept = 0;
	virtual int align() const noexcept = 0;
	virtual void* create() const noexcept = 0;

	virtual ~Base() {}
};

struct BaseType : public Base {
	BaseType() { isBase = true; }
};

struct Byte : public BaseType {
	int size() const noexcept override { return 1; }

	int align() const noexcept override { return 1; }

	void* alloc() const noexcept override { return new char; }

	void dealloc(void* ptr) const noexcept override { delete (char*) ptr; }

	void* create() const noexcept override { return new Byte; }
};

struct Short : public BaseType {
	int size() const noexcept override { return 2; }

	int align() const noexcept override { return 2; }

	void* alloc() const noexcept override { return new short; }

	void dealloc(void* ptr) const noexcept override { delete (short*) ptr; }

	void* create() const noexcept override { return new Short; }
};

struct Int : public BaseType {
	int size() const noexcept override { return 4; }

	int align() const noexcept override { return 4; }

	void* alloc() const noexcept override { return new int; }

	void dealloc(void* ptr) const noexcept override { delete (int*) ptr; }

	void* create() const noexcept override { return new Int; }
};

struct Long : public BaseType {
	int size() const noexcept override { return 8; }

	int align() const noexcept override { return 8; }

	void* alloc() const noexcept override { return new long; }

	void dealloc(void* ptr) const noexcept override { delete (long*) ptr; }

	void* create() const noexcept override { return new Long; }
};

struct Codata {
	_STD map<_STD string, Base*> namedMembers;
	_STD list<Base*> members;
	int sizes = 0;
	int aligns = 0;
	int offsets = 0;
};

class Class : public Base {
	Codata* codata;
public:
	Class() { codata = new Codata; }

	Class(Codata* c) :
		codata{ c } {}

	~Class() override {
		for (auto iter = codata->members.begin(); iter != codata->members.end(); ++iter) delete iter.operator*();
	}

	void addMember(_STD string name, Base* member) {
		member = (Base*) member->create();
		if (member->align() > codata->aligns) {
			codata->aligns = member->align();
			codata->offsets = 0;
			for (auto iter = codata->members.begin(); iter != codata->members.end(); ++iter) {
				(*iter)->offset = codata->offsets;
				codata->offsets += ((*iter)->size() / codata->aligns + ((*iter)->align() % codata->aligns == 0 ? 0 : 1));
			}
		}
		member->offset = codata->offsets;
		codata->offsets += (member->size() / codata->aligns + (member->align() % codata->aligns == 0 ? 0 : 1));
		codata->sizes = codata->offsets * codata->aligns;

		codata->members.push_back(member);
		codata->namedMembers.insert(_STD make_pair(name, member));
	}

	void* getMember(_STD string name, void* ptr, int& align) const {
		int p = name.find_first_of('.');
		align = codata->aligns;
		if (p == _STD string::npos) return ((char*) ptr) + (codata->namedMembers.at(name)->offset * codata->aligns);
		else {
			Class* k = ((Class*) codata->namedMembers.at(name.substr(0, p)));
			return k->getMember(name.substr(p + 1), ((char*) ptr) + (k->offset * codata->aligns), align);
		}
	}

	void* ptrof(void* src, int off, int& align) const noexcept {
		if (off > codata->sizes) return nullptr;
		align = codata->aligns;
 // offset未必遵循aligns
		for (auto iter = codata->members.begin(); iter != codata->members.end(); ++iter) {
			if ((*iter)->offset * codata->aligns == off) {
				if ((*iter)->isBase)
					return ((char*) src) + off;
				else
					return ((Class*) *iter)->ptrof(((char*) src) + off, 0, align);
			} else if ((*iter)->offset * codata->aligns > off) {
				if (iter == codata->members.begin())
					return nullptr;
				else if ((*--iter)->isBase)
					return nullptr;
				else {
					return ((Class*) *iter++)->ptrof(((char*) src + (*iter)->offset * codata->aligns), offset - (*iter)->offset * codata->aligns, align);
				}
			}
		}
 // 比最后一个还大一点
		if (codata->members.back()->offset * codata->aligns == off)
			return ((char*) src) + off;
		else
			return nullptr;
	}

	int size() const noexcept override { return codata->sizes; }

	int align() const noexcept override { return codata->aligns; }

	void* alloc() const noexcept override { return malloc(codata->sizes); }

	void dealloc(void* ptr) const noexcept override { free(ptr); }

	void* create() const noexcept override { return new Class(codata); }
};

struct ClassRegistry {
	_STD map<_STD string, Base*> registry;

	ClassRegistry() {
		registry.insert(_STD make_pair("byte", new Byte));
		registry.insert(_STD make_pair("short", new Short));
		registry.insert(_STD make_pair("int", new Int));
		registry.insert(_STD make_pair("long", new Long));
	}

	~ClassRegistry() {
		for (auto iter = registry.begin(); iter != registry.end(); ++iter) delete iter.operator*().second;
	}
} classes;

struct Instance {
	Base* type;
	void* value;

	Instance(Base* type) {
		value = type->alloc();
	}

	~Instance() {
		type->dealloc(value);
	}
};

struct InstanceRegistry {
	_STD map<_STD string, Instance*> registry;
	_STD list<Instance*> instances;
	int size = 0;

	~InstanceRegistry() {
		for (auto iter = instances.begin(); iter != instances.end(); ++iter) delete iter.operator*();
	}

	void* getMember(_STD string name, int& align) {
		align = 0;
		int p = name.find_first_of('.');
		Instance* i = registry.at(name.substr(0, p));
		return ((Class*) i->type)->getMember(name.substr(p + 1), i->value, align);
	}

	int reg(_STD string name, Instance* instance) noexcept {
		registry.insert(_STD make_pair(name, instance));
		instances.push_back(instance);
		instance->type->offset = size;
		size += instance->type->size();
		return instance->type->offset;
	}

	void* ptrof(int off, int& align) noexcept {
		for (auto iter = instances.begin(); iter != instances.end(); ++iter) {
			if ((*iter)->type->offset == off) return (*iter)->value;
			else if ((*iter)->type->offset > off) {
				--iter;
				if (iter.operator*()->type->isBase)
					return nullptr;
				else
					return ((Class*) iter.operator*()->type)->ptrof(((char*) iter.operator*()->value), off - iter.operator*()->type->offset, align);
			}
		}
		return nullptr;
	}
} instances;

int main() {
	int count;
	int pos;
	_STD cin >> count;
	_STD string temp;
	_STD string name;
	for (int i = 0; i < count; i++) {
		_STD cin >> temp;
		switch (temp.at(0)) {
			case '1': {
				_STD cin >> name;
				_STD cin >> temp;
				Class* klass = new Class();
				classes.registry.insert(_STD make_pair(name, klass));
				int t = atoi(temp.c_str());
				for (int j = 0; j < t; ++j) {
					_STD cin >> name;
					_STD cin >> temp;
					klass->addMember(temp, classes.registry.at(name));
				}
				_STD cout << klass->size() << ' ' << klass->align() << _STD endl;
			} break;
			case '2': {
				_STD cin >> name;
				_STD cin >> temp;
				Instance* instance = new Instance(classes.registry.at(name));
				_STD cout << instances.reg(temp, instance) << _STD endl;
			} break;
			case '3': {
				_STD cin >> temp;
				int align = 0;
				void* ptr = instances.getMember(temp, align);
				if (ptr == nullptr) {
					_STD cout << "ERR\n";
					continue;
				}
				switch (align) {
					case 1:
						_STD cout << (int) *(char*) ptr;
					case 2:
						_STD cout << *(short*) ptr;
					case 4:
						_STD cout << *(int*) ptr;
					case 8:
						_STD cout << *(long*) ptr;
				}
			} break;
			case '4': {
				_STD cin >> temp;
				int align = 0;
				void* ptr = instances.ptrof(atoi(temp.c_str()), align);
				if (ptr == nullptr) {
					_STD cout << "ERR\n";
					continue;
				}
				switch (align) {
					case 1:
						_STD cout << (int) *(char*) ptr;
					case 2:
						_STD cout << *(short*) ptr;
					case 4:
						_STD cout << *(int*) ptr;
					case 8:
						_STD cout << *(long*) ptr;
				}
			} break;
		}
	}
}