#include "bits/stdc++.h"
#include<unordered_map>
#include<unordered_set>
#pragma warning(disable:4996)
using namespace std;
using ld = double;
const ld eps = 1e-9;
//
//using Graph = vector<vector<int>>;
//
//int dfs(const Graph&g, const int now, vector<int>&ch_cnts) {
//  ch_cnts[now]++;
//  for (auto&& e : g[now]) {
//      ch_cnts[now] += dfs(g, e, ch_cnts);
//  }
//  return ch_cnts[now];
//}
//
//struct HL_Edge {
//  int from;
//  int to;
//  bool heavy;
//};
//
//void dfs2(const Graph&g, vector<vector<HL_Edge>>&hl_tree, const int now, const vector<int>&ch_cnts) {
//
//  int max_ch_id = 1;
//  {
//      int max_ch_num = -1;
//      for (auto&&e : g[now]) {
//          if (max_ch_num < ch_cnts[e]) {
//              max_ch_num = ch_cnts[e];
//              max_ch_id = e;
//          }
//      }
//  }
//  for (auto e : g[now]) {
//      bool heavy = (e == max_ch_id);
//
//      hl_tree[now].push_back(HL_Edge{ now,e,heavy });
//  }
//  return;
//}
//
//void HL(const vector<vector<int>>&ro_tree) {
//  vector<int>ch_cnts(ro_tree.size());
//
//  dfs(ro_tree, 0, ch_cnts);
//
//  vector<vector<HL_Edge>>hl_tree(ro_tree.size());
//
//  dfs2(ro_tree, hl_tree, 0, ch_cnts);
//}
//
//namespace FastFourierTransform
//{
//  using C = complex< double >;
//
//  void DiscreteFourierTransform(vector< C > &F, bool rev)
//  {
//      const int N = (int)F.size();
//      const double PI = (rev ? -1 : 1) * acos(-1);
//      for (int i = 0, j = 1; j + 1 < N; j++) {
//          for (int k = N >> 1; k > (i ^= k); k >>= 1);
//          if (i > j) swap(F[i], F[j]);
//      }
//      C w, s, t;
//      for (int i = 1; i < N; i <<= 1) {
//          for (int k = 0; k < i; k++) {
//              w = polar(1.0, PI / i * k);
//              for (int j = 0; j < N; j += i * 2) {
//                  s = F[j + k];
//                  t = C(F[j + k + i].real() * w.real() - F[j + k + i].imag() * w.imag(),
//                      F[j + k + i].real() * w.imag() + F[j + k + i].imag() * w.real());
//                  F[j + k] = s + t, F[j + k + i] = s - t;
//              }
//          }
//      }
//      if (rev) for (int i = 0; i < N; i++) F[i] /= N;
//  }
//
//  vector< int> Multiply(const vector<int > &A, const vector<int > &B)
//  {
//      int sz = 1;
//      while (sz <= A.size() + B.size()) sz <<= 1;
//      vector< C > F(sz), G(sz);
//      for (int i = 0; i < A.size(); i++) F[i] = A[i];
//      for (int i = 0; i < B.size(); i++) G[i] = B[i];
//      DiscreteFourierTransform(F, false);
//      DiscreteFourierTransform(G, false);
//      for (int i = 0; i < sz; i++) F[i] *= G[i];
//      DiscreteFourierTransform(F, true);
//      vector< int > X(A.size() + B.size() - 1);
//      for (int i = 0; i < A.size() + B.size() - 1; i++) X[i] = F[i].real() + 0.5;
//      return (X);
//  }
//};

struct aa {
	string name;
	int l;
	int r;
	int u;
	int d;
	vector<shared_ptr<aa>>chs;
};

int get_num(string st, int&a) {
	int num=0;
	while (a != st.size() && isdigit(st[a])) {
		num*=10;
		num+=st[a]-'0';
		a++;
	}
	return num;
}

string get_name(string st, int &a) {
	string name="";
	while (a != st.size() && 'a' <= st[a] && st[a] <= 'z') {
		name+=st[a];
		a++;
	}
	return name;
}

string get_on_name(string st,bool flag, int &a) {
	assert(st[a]=='<');
	a++;
	if (flag) {
		assert(st[a]=='/');
		a++;
	}
	string name=get_name(st,a);
	assert(st[a]=='>');
	a++;
	return name;
}



pair<pair<int, int>, pair<int, int>>get_on_num(string st, int &a) {
	int l=get_num(st,a);
	assert(st[a]==',');
	a++;
	int u=get_num(st,a);
	assert(st[a]==',');
	a++;
	int r=get_num(st,a);
	assert(st[a]==',');
	a++;
	int d=get_num(st,a);

	return make_pair(make_pair(l,r),make_pair(u,d));
}

shared_ptr<aa>solve(string st, int &a) {

	aa now;
	string aname=get_on_name(st,false,a);
	now.name=aname;



	auto p=get_on_num(st,a);
	now.l=p.first.first;
	now.r=p.first.second;
	now.u=p.second.first;
	now.d=p.second.second;

	while (st[a + 1] != '/') {
		auto naa=solve(st,a);
		now.chs.push_back(naa);
	}
	get_on_name(st,true,a);
	return make_shared<aa>(now);
}

pair<string, int>get_ans(const aa&naa, int x, int y) {

	if (naa.l <= x&&x <= naa.r&&naa.u <= y&&y <= naa.d) {
		for (auto ch : naa.chs) {
			auto p = get_ans(*ch, x, y);
			if (p.first == "") {
			}
			else {
				return p;
			}
		}
		return make_pair(naa.name, naa.chs.size());
	}
	else {
		return make_pair("",0);
	}
}

int main() {
	while (true) {
		int N; cin >> N;
		if(!N)break;
		string st; cin >> st;

		int k = 0;
		auto top(solve(st, k));

		for (int i = 0; i < N; ++i) {
			int x, y; cin >> x >> y;
			auto p = get_ans(*top, x, y);
			if (p.first == "") {
				cout << "OUT OF MAIN PANEL 1" << endl;
			}
			else {

				cout << p.first << " " << p.second << endl;
			}
		}
	}
	
	return 0;
}


Measured memory_bytes: 3080