#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("avx,avx2,fma")
#define ff first
#define ss second
using namespace std;

typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;

const int SZ = 100;
namespace dinic {
	struct edge {
		int v, c, d;
	};
	vector<edge> g[SZ];

	int src, snk, fsrc, fsnk;
	void init_lrflow(int _src, int _snk, int _fsrc, int _fsnk) {
		for (int i = 0; i < SZ; i++) {
			g[i].clear();
		}
		src = _src; snk = _snk; fsrc = _fsrc, fsnk = _fsnk;

		g[snk].push_back({src, (int)1e9, (int)g[src].size()});
		g[src].push_back({snk, 0, (int)g[snk].size() - 1});
	}

	void add_edge(int u, int v, int l, int r) {
		if (l != r) {
			g[u].push_back({v, r - l, (int)g[v].size()});
			g[v].push_back({u, 0, (int)g[u].size() - 1});
		}
		if (l != 0) {
			g[fsrc].push_back({v, l, (int)g[v].size()});
			g[v].push_back({v, 0, (int)g[fsrc].size() - 1});
		
			g[u].push_back({fsnk, l, (int)g[fsnk].size()});
			g[fsnk].push_back({u, 0, (int)g[u].size() - 1});
		}
	}

	int ds[SZ];
	void bfs() {
		fill(ds, ds + SZ, -1);
		queue<int> Q;
		Q.push(fsrc);

		while (!Q.empty()) {
			int v = Q.front();
			Q.pop();

			for (auto &e : g[v]) if (e.c > 0) {
				if (ds[e.v] == -1) {
					ds[e.v] = ds[v] + 1;
					Q.push(e.v);
				}
			}
		}
	}

	int sp[SZ];
	int dfs(int v, int f) {
		if (v == fsnk) {
			return f;
		}

		while (sp[v] < g[v].size()) {
			auto &e = g[v][sp[v]++];

			if (e.c == 0 || ds[e.v] != ds[v] + 1) continue;
			int h = dfs(e.v, min(f, e.c));

			if (h > 0) {
				e.c -= h;
				g[e.v][e.d].c += h;
				return h;
			}
		}
		return 0;
	}

	bool run_lrflow() {
		while (true) {
			bfs();

			int f = 0;
			fill(sp, sp + SZ, 0);
			while (true) {
				int g = dfs(fsrc, 1e9);
				if (g == 0) break;

				f += g;
			}
			if (f == 0) break;
		}

		for (auto &e : g[fsrc]) {
			if (e.c != 0) {
				return false;
			}
		}
		return true;
	}
}

int main() {
	cin.tie(0); ios_base::sync_with_stdio(0);
	
	int n;
	cin >> n;

	int t[n], x[n], y[n], sk[n], res[n];

	for (int i = 0; i < n; i++) {
		int a; string S;
		cin >> a >> S;

		if (S == "A") {
			int b; string C, T;
			cin >> b >> C >> T;
			
			t[i] = 0; x[i] = a - 1; y[i] = b - 1;
			sk[i] = 4 * (C[0] - '1') + (C[1] - 'A');
			res[i] = (T == "yes");
		}
		else {
			int b; cin >> b;

			t[i] = 1; x[i] = a - 1; y[i] = b - 1;
		}
	}

	int pos[32][n + 1];
	bool grp[4][8];
	bool dont[4][32];

	int ss = 1, ee = n + 1;
	while (ss < ee) {
		int k = (ss + ee) / 2;

		for (int g = 0; g < 32; g++) pos[g][0] = -1;
		for (int p = 0; p < 4; p++) for (int s = 0; s < 8; s++) grp[p][s] = false;
		for (int p = 0; p < 4; p++) for (int g = 0; g < 32; g++) dont[p][g] = false;

		bool flag = true;
		for (int i = 0; i < k; i++) {
			for (int g = 0; g < 32; g++) pos[g][i + 1] = pos[g][i];

			if (t[i] == 0 && res[i]) {
				int g = sk[i];
				if (pos[g][i + 1] == -1) { // first discovered
					for (int j = 0; j <= i; j++) pos[g][j] = y[i];
					pos[g][i + 1] = x[i];
				}
				else { // already discovered
					if (pos[g][i] != y[i]) {
						flag = false;
						break;
					}
					else pos[g][i + 1] = x[i];
				}
			}
			else if (t[i] == 1) {
				for (int g = 4 * y[i]; g < 4 * y[i] + 4; g++) {
					if (pos[g][i] == -1) {
						for (int j = 0; j <= i + 1; j++) pos[g][j] = x[i];
					}
					else {
						if (pos[g][i] != x[i]) {
							flag = false;
							break;
						}
					}
				}
			}
		}
		if (!flag) {
			ee = k; continue;
		}

		for (int i = 0; i < k; i++) {
			if (t[i] == 0) {
				bool has = false;
				for (int g = 4 * (sk[i] / 4); g < 4 * (sk[i] / 4) + 4; g++) if (pos[g][i] == x[i]) has = true;
				if (!has) grp[x[i]][sk[i] / 4] = true;

				if (!res[i]) {
					int g = sk[i];
					if (pos[g][i] == -1) dont[y[i]][g] = true;
					else {
						if (pos[g][i] == y[i]) {
							flag = false;
							break;
						}
					}
				}
			}
		}
		if (!flag) {
			ee = k; continue;
		}

		dinic::init_lrflow(0, 69, 70, 71);

		int cnt[4] = {};
		for (int g = 0; g < 32; g++) {
			if (pos[g][0] != -1) {
				cnt[pos[g][0]]++;
			}
		}
		for (int p = 0; p < 4; p++) {
			if (cnt[p] > 8) {
				flag = false;
				break;
			}
		}
		if (!flag) {
			ee = k; continue;
		}

		for (int g = 0; g < 32; g++) {
			if (pos[g][0] == -1) {
				dinic::add_edge(0, 1 + g, 1, 1);
			}
		}
		for (int s = 0; s < 8; s++) {
			for (int p = 0; p < 4; p++) {
				for (int k = 0; k < 4; k++) {
					if (!dont[p][4 * s + k]) dinic::add_edge(1 + (4 * s + k), 33 + (4 * s + p), 0, 1);
				}
			}
		}

		for (int p = 0; p < 4; p++) {
			for (int s = 0; s < 8; s++) {
				if (grp[p][s]) {
					dinic::add_edge(33 + (4 * s + p), 65 + p, 1, 8);
				}
				else {
					dinic::add_edge(33 + (4 * s + p), 65 + p, 0, 8);
				}
			}
			dinic::add_edge(65 + p, 69, 8 - cnt[p], 8 - cnt[p]);
		}

		flag = dinic::run_lrflow();
		if (flag) {
			ss = k + 1;
		}
		else {
			ee = k;
		}
	}
	if (ss == n + 1) {
		cout << "yes\n";
	}
	else {
		cout << "no\n";
		cout << ss << '\n';
	}
}