class Tree
	def initialize(i)
		@index = i
		@children = []
	end

	def compute_euler_index
		stack = [[self, 0]]
		@l = 0
		n = 0
		until stack.empty? do
			v, i = stack[-1]
			if i >= v.children.size
				v.r = (n += 1)
				stack.pop
				stack[-1][1] += 1 unless stack.empty?
				next
			end
			c = v.children[i]
			c.l = (n += 1)
			stack << [c, 0]
		end
	end

	def compute_depth
		stack = [[self, 0]]
		d = 0
		until stack.empty? do
			v, i = stack[-1]
			if i >= v.children.size
				v.depth = d
				d -= 1
				stack.pop
				stack[-1][1] += 1 unless stack.empty?
				next
			end
			c = v.children[i]
			stack << [c, 0]
			d += 1
		end
	end

	attr_accessor :index, :children, :l, :r, :depth
end

class SegTree
	def initialize(a, l = 0, r = a.size-1)
		@l = l
		@r = r
		if l == r
			@value = a[l]
		else
			c = (l + r) / 2
			@children = [SegTree.new(a, l, c), SegTree.new(a, c + 1, r)]	
		end
	end

	def update(marked, l = @l, r = @r)
		if @l == l && @r == r
			if @lazy
				@lazy = marked if marked.depth > @lazy.depth
			else
				@lazy = marked
			end
			return
		end

		force if @lazy
		if r <= @children[0].r
			@children[0].update(marked, l, r)
		elsif @children[1].l <= l
			@children[1].update(marked, l, r)
		else
			@children[0].update(marked, l, @children[0].r)
			@children[1].update(marked, @children[1].l, r)
		end
	end

	def query(i)
		force if @lazy
		if @l == @r && @l == i
			@value.index
		elsif i <= @children[0].r
			@children[0].query(i)
		else
			@children[1].query(i)
		end
	end

	def force
		if @l == @r
			@value = @lazy if @lazy.depth > @value.depth
		else
			@children.each {|c| c.update(@lazy)}
		end

		@lazy = nil
	end

	attr_reader :l, :r
end

loop do
	n, q = gets.split.map(&:to_i)		
	break if n == 0
	sum = 0
	nodes = (0..n).map{|i| Tree.new(i) }
	(n-1).times do |i|
		j = gets.to_i
		nodes[j].children << nodes[i+2]
	end
	nodes[1].compute_euler_index
	nodes[1].compute_depth

	seg = SegTree.new((0..2*n-1).map { nodes[1] })

	q.times do
		query, i = gets.chomp.split
		target = nodes[i.to_i]
		if query == ?Q
		 	sum += seg.query(target.l)
		else
			seg.update(target, target.l, target.r)
		end
	end
	puts sum
end