#include "bits/stdc++.h"
#include<unordered_map>
#include<unordered_set>
#pragma warning(disable:4996)
using namespace std;
using ld = long double;
template<class T>
using Table = vector<vector<T>>;
const ld eps=1e-9;

//// < "D:\D_Download\Visual Studio 2015\Projects\programing_contest_c++\Debug\a.txt"

//


#define Seg_Max_N (1<<18) 
// update(l,r,v) := [l,r]?????????????????????v???????§?????¶????. k,a,b????£????

struct NODE {
	int sum;//??´??°????????????. ?????????????????§??????????????????????????¨????????????????????????????????????.
	int lazy;	//?????¶???????????????????????????????????????
	NODE() {
		sum = lazy = 0;
	}
};

NODE seg[2 * Seg_Max_N];

// inline??????????????¨??§???????????¨????????????!(??????)
inline void lazy_evaluate_node(int k, int a, int b) {
	seg[k].sum = max(seg[k].sum,seg[k].lazy);
	if (k < Seg_Max_N) { // 2*k(???????????????) < 2*N (???????????°) ?????????????????§. ???????????????????????????????????¬???????????¨??????.
		seg[2 * k].lazy =max(seg[2*k].lazy, seg[k].lazy);	//?¬???????????????¬??????????????£?????????.
		seg[2 * k + 1].lazy = max(seg[2*k+1].lazy,seg[k].lazy);
	}
	seg[k].lazy = 0;
}

inline void update_node(int k) { // k???????????¢?????????????????????????????¨?????????. ????????\????????¨????????????????????????????????????????????????????????§if???????????????.
	seg[k].sum = max(seg[2 * k].sum , seg[2 * k + 1].sum);
}

// update(l,r,v) := [l,r]?????´??°??????. ?????????1-indexed.
void update(int l, int r, int v, int k = 1, int a = 1, int b = Seg_Max_N) {
	if (l < 0 || r<0)assert(false);
	lazy_evaluate_node(k, a, b); 	// ??¨?????????????????£???????????????????????????????????§?????¬?????¨???????\?.

	if (b < l || r < a) //[a,b]??¨[l,r]???????????????????????´???
		return;
	if (l <= a && b <= r) { // [l,r]???[a,b]????????¨???????????§????????´???
		seg[k].lazy = max(seg[k].lazy,v);
		lazy_evaluate_node(k, a, b); //???????????¶???????????¨???????????¨?????????????????§.
		return;
	}

	int m = (a + b) / 2;
	update(l, r, v, 2 * k, a, m);
	update(l, r, v, 2 * k + 1, m + 1, b);
	update_node(k);
}

// get(l,r) := [l,r]?????????????????¨?????????????????????. ?????????1-indexed.
int get(int l, int r, int k = 1, int a = 1, int b = Seg_Max_N) {
	if (l < 0 || r<0)assert(false);
	lazy_evaluate_node(k, a, b); // ??¨?????????????????£???????????????????????????????????§?????¬?????¨???????\?.

	if (b < l || r < a) //[a,b]??¨[l,r]???????????????????????´???
		return 0;

	if (l <= a && b <= r) { // [l,r]???[a,b]????????¨???????????§????????´???
		return seg[k].sum;
	}

	int m = (a + b) / 2;
	int vl = get(l, r, 2 * k, a, m);
	int vr = get(l, r, 2 * k + 1, m + 1, b);
	update_node(k);
	return vl + vr;
}

void dfs(const int now, vector<pair<int, int>>&ps,vector<int>&ids,int&id,const vector<vector<int>>&edges) {
	ids[now] = id;
	ps[now].first = id;
	id++;
	for (auto e : edges[now]) {
		dfs(e, ps, ids, id, edges);
	}
	ps[now].second = id - 1;
}

int main() {
	while (1) {
		for (int i = 0; i < 2 * Seg_Max_N; ++i) {
			seg[i] = NODE();
		}
		int N, Q; cin >> N >> Q;
		if (!N)break;
		vector<vector<int>>edges(N);
		for (int i = 0; i < N - 1; ++i) {
			int a; cin >> a;
			edges[a - 1].push_back(i + 1);
		}
		vector<pair<int, int>>ps(N);
		vector<int>ids(N);
		vector<int>revids(N);
		int id = 0;
		dfs(0, ps, ids, id, edges);
		for (int i = 0; i < ids.size(); ++i) {
			revids[ids[i]] = i;
		}
		long long int sum = 0;
		for (int i = 0; i < Q; ++i) {
			char c; cin >> c;
			if (c == 'Q') {
				int a; cin >> a;
				a--;
				int aid = ids[a];
				int ans = get(aid, aid);
				ans = revids[ans];
				sum += ans+1;
				//cout << ans+1 << endl;
			}
			else {
				int a; cin >> a;
				a--;
				update(ps[a].first, ps[a].second,ids[a]);
			}
		}
		cout << sum << endl;
	}
	
	return 0;
}

Measured memory_bytes: 21884