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

	def euler(n)
		if @children.empty?
			@l = n
			@r = n + 1
			return n + 2
		end	
		@l = n
		n += 1
		@children.each do |c|
			n = c.euler(n)
		end
		@r = n
		return n + 1
	end

	def compute_depth(d = 0)
		@depth = d
		@children.each {|c| c.compute_depth(d+1)}
	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)
		force if @lazy
		if @l == l && @r == r
			@lazy = marked
		elsif 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].euler(0)
	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