#include <bits/stdc++.h>
using namespace std;

struct node {
	int prior, size, pos;
	int val, sum;
	node *l, *r;
};
typedef node* pnode;

int sz(pnode t) {
	return t ? t->size : 0;
}

void upd_sz(pnode t) {
	if(t) {
		t->size = sz(t->l) + sz(t->r) + 1;
	}
}

void combine(pnode &t, pnode l, pnode r) {
	if(!l || !r) {
		t = l ? l : r;
		return;
	}
	t->sum = l->sum + r->sum;
}

void reset(pnode t) {
	if(t) {
		t->sum = t->val;
	}
}

void operation(pnode t) {
	if(!t) {
		return;
	}
	reset(t);
	combine(t, t->l, t);
	combine(t, t, t->r);
}

void split(pnode t, pnode &l, pnode &r, int pos) {
	if(!t) {
		l = r = NULL;
		return;
	}

	if(t->pos <= pos) {
		split(t->r, t->r, r, pos);
		l = t;
	}
	else {
		split(t->l, l, t->l, pos);
		r = t;
	}
	upd_sz(t);
	operation(t);
}

void merge(pnode &t, pnode l, pnode r) {
	if(!l || !r) {
		t = l ? l : r;
	}
	else if(l->prior > r->prior) {
		merge(l->r, l->r, r);
		t = l;
	}
	else {
		merge(r->l, l, r->l);
		t = r;
	}
	upd_sz(t);
	operation(t);
}

void init(pnode &t, int pos = -1, int val = 0) {
	t->prior = rand();
	t->pos = pos;
	t->size = 1;
	t->val = val;
	t->sum = t->val;
	t->l = t->r = NULL;
}

const int N = 1e5 + 10;
pnode seg[N << 2];
int A[N];
int Left[N];

int get_sum(pnode t, int pos) {
	pnode l, r;
	split(t, l, r, pos);
	int ans = l ? l->sum : 0;
	merge(t, l, r);
	return ans;
}

void update(int l, int r, int id, int pos, int old_val, int val, int old_pos, int new_pos) {
	pnode L, mid, R;
	if(old_pos > -1) {
		split(seg[id], L, mid, old_pos-1);
		split(mid, seg[id], R, old_pos);

		if(seg[id]) {
			seg[id]->val -= old_val;
			seg[id]->sum -= old_val;
		}

		merge(mid, L, seg[id]);
		merge(seg[id], mid, R);
	}


	split(seg[id], L, mid, new_pos-1);
	split(mid, seg[id], R, new_pos);

	if(seg[id]) {
		seg[id]->val += val;
		seg[id]->sum += val;
	}
	else {
		seg[id] = new node;
		init(seg[id], new_pos, val);
	}
	
	merge(mid, L, seg[id]);
	merge(seg[id], mid, R);

	if(l == r) {
		return;
	}	
	
	int _mid = l + r >> 1;
	if(_mid >= pos)
		update(l, _mid, id << 1, pos, old_val, val, old_pos, new_pos);
	else
		update(_mid + 1, r, id << 1 | 1, pos, old_val, val, old_pos, new_pos);
}

int query(int l, int r, int id, int x, int y) {
	if(l > y || r < x)	
		return 0;
	if(l >= x && r <= y) {
		return get_sum(seg[id], x - 1);
	}
	int mid = l + r >> 1;
	return query(l, mid, id << 1, x, y) + query(mid + 1, r, id << 1 | 1, x, y);
}

map < int, set < int > > M;

int main() {
	int n;
	scanf("%d", &n);
	for(int i = 1; i <= n; ++i) {
		scanf("%d", A + i);

		M[A[i]].insert(0);
		
		auto it = M[A[i]].end();
		--it;
		Left[i] = *it;

		M[A[i]].insert(i);
	}
	for(int i = 1; i <= n; ++i) {
		update(1, n, 1, i, 0, A[i], -1, Left[i]);
	}

	int q;
	scanf("%d", &q);
	for(int i = 1; i <= q; ++i) {
		char c;
		int x, y;
		scanf(" %c %d %d", &c, &x, &y);
		if(c == 'Q') {
			int ans = query(1, n, 1, x, y);
			printf("%d\n", ans);
		}
		else if(A[x] != y) {

			M[y].insert(0);
			auto it = M[y].lower_bound(x);
			auto it3 = M[A[x]].upper_bound(x);
			auto it2 = it;
			--it;
			update(1, n, 1, x, A[x], y, Left[x], *it);
			if(it2 != M[y].end()) {
				update(1, n, 1, *it2, y, y, Left[*it2], x);
				Left[*it2] = x;
			} 
			if(it3 != M[A[x]].end()) {
				update(1, n, 1, *it3, A[x], A[x], x, Left[x]);
				Left[*it3] = Left[x];
			}
			M[y].insert(x);
			M[A[x]].erase(x);
			A[x] = y;
			Left[x] = *it;

		}
	}

}