#include "bits/stdc++.h"
using namespace std;
#define Rep(i,n) for(int i=0;i<(int)(n);i++)
#define For(i,n1,n2) for(int i=(int)(n1);i<(int)(n2);i++)
#define REP(i,n) for(ll i=0;i<(ll)(n);i++)
#define RREP(i,n) for(ll i=((ll)(n)-1);i>=0;i--)
#define FOR(i,n1,n2) for(ll i=(ll)(n1);i<(ll)(n2);i++)
#define RFOR(i,n1,n2) for(ll i=((ll)(n1)-1);i>=(ll)(n2);i--)
#define all(a)  (a).begin(),(a).end()
#define SORT(a) sort((a).begin(),(a).end())
#define oorret 0
#define oor(x) [&](){try{x;} catch(const out_of_range& oor){return oorret;} return x;}()
#define IOS cin.tie(0),ios::sync_with_stdio(false)
typedef long long ll;
typedef unsigned long long ull;
typedef std::pair<ll, ll> P;
template<typename T1, typename T2> inline bool chmin(T1& a, T2 b) { if (a > b) { a = b; return 1; }return 0; }
template<typename T1, typename T2> inline bool chmax(T1& a, T2 b) { if (a < b) { a = b; return 1; }return 0; }
template<class Type>struct is_vector : std::false_type {};
template<class ValueType, class Alloc>struct is_vector<std::vector<ValueType, Alloc>> : std::true_type {};
template <typename T> inline std::ostream& operator << (std::ostream& out, const std::vector<T>& v) {
	if (v.empty())return out;
	constexpr bool is_vector_v = is_vector<T>::value;
	if (is_vector_v)for (auto itr = v.begin(); itr != v.end();)out << (*itr), out << ((++itr != v.end()) ? "\n" : "");
	else for (auto itr = v.begin(); itr != v.end();)out << (*itr), out << ((++itr != v.end()) ? " " : "");
	return out;
}
inline void put() {}
template<class T> inline void put(const T& first) { std::cout << first << "\n"; }
template<class T, class... N> inline void put(const T& first, const N& ... rest) { std::cout << first << " "; put(rest...); }
inline void putn() {}
template<class T, class... N> inline void putn(const T& first, const N& ... rest) { std::cout << first << "\n"; putn(rest...); }


template<typename T>
class LazySegmentTree {
public:
	int sz = 1;
	int contFlag;
	T elemUp; // upの単位元
	T elemPr; // procの単位元
	vector<T> seg; // セグメント木のデータ配列
	vector<T> lazy; // 遅延評価用の配列
	T up(T& a, T b) { // 更新関数
		if (b == elemUp)return a;
		if (a == elemUp)return b;
		//return a + b; // 加算
		return b; // 代入
	}
	T proc(T& a, T b) { // 評価関数
		if (b == elemPr)return a;
		if (a == elemPr)return b;
		//if(a>b)return a;// max
		//return b;
		//if (a < b)return a;// min
		//return b;
		return a+b; // 加算
	}
	T cont(T& a, int b) { // aをb回procした値
		if (b <= 0)return elemPr;
		if (b % 2 == 0) {
			T c = cont(a, b / 2);
			return proc(c, c);
		} else {
			return proc(a, cont(a, b - 1));
		}
		return a;
	}
	T contSum(T& a, int b) { // procが加算のとき
		return a * b;
	}
	T contId(T& a, int b) { // procが繰り返しても同じ値になるもの(max,min,etc...)
		return a;
	}
	LazySegmentTree(int n, T ep = 0, T eu = 0, int cf = 0) :elemPr(ep), elemUp(eu), contFlag(cf) {
		while (sz < n) sz <<= 1;
		seg.clear();
		lazy.clear();
		seg.resize(sz * 2, elemPr);
		lazy.resize(sz * 2, elemUp);
	}
	void init(std::vector<T> ary) { // aryで初期化する
		const int n = (int)ary.size();
		for (int i = 0; i < n; ++i) {
			set(i, ary[i]);
		}
		for (int i = sz - 2; i >= 0; --i) {
			seg[i] = proc(seg[2 * i + 1], seg[2 * i + 2]);
		}
	}
	void init(T a) { // sz個の全要素をaで初期化する
		for (int i = 0; i < sz; ++i) {
			set(i, a);
		}
		for (int i = sz - 2; i >= 0; --i) {
			seg[i] = proc(seg[2 * i + 1], seg[2 * i + 2]);
		}
	}
	inline void set(const int& k, const T& x) {// 左からk番目の葉にxを代入する
		seg[sz - 1 + k] = x;
	}

	// k 番目のノードについて遅延評価を行う
	void eval(int k, int l, int r) { // k = [l,r)
		if (lazy[k] != elemUp) {
			int len = r - l;
			if (len > 1) {
				lazy[2 * k + 1] = up(lazy[2 * k + 1], lazy[k]);
				lazy[2 * k + 2] = up(lazy[2 * k + 2], lazy[k]);
			}
			if (contFlag == 0) {
				seg[k] = up(seg[k], cont(lazy[k], len));
			} else if (contFlag == 1) {
				seg[k] = up(seg[k], contSum(lazy[k], len));
			} else if (contFlag == 2) {
				seg[k] = up(seg[k], contId(lazy[k], len));
			}
			lazy[k] = elemUp;
		}
	}
	void update(int a, int b, T x, int k = 0, int l = 0, int r = -1) { // i in [a,b)に更新up(seg[i],a)を適用
		if (r < 0) r = sz;
		eval(k, l, r);
		if (b <= l || r <= a) return;
		if (a <= l && r <= b) {// 被覆
			lazy[k] = up(lazy[k], x);
			eval(k, l, r);
		} else {// 非被覆
			update(a, b, x, 2 * k + 1, l, (l + r) / 2);
			update(a, b, x, 2 * k + 2, (l + r) / 2, r);
			seg[k] = proc(seg[2 * k + 1], seg[2 * k + 2]);
		}
	}
	T query(int a, int b, int k = 0, int l = 0, int r = -1) {
		if (r < 0) r = sz;
		if (b <= l || r <= a) return elemPr;
		eval(k, l, r);
		if (a <= l && r <= b) return seg[k];
		T vl = query(a, b, 2 * k + 1, l, (l + r) / 2);
		T vr = query(a, b, 2 * k + 2, (l + r) / 2, r);
		return proc(vl, vr);
	}
};


int main() {
	IOS;
	int n;
	string s;
	int q;
	cin >> n >> s >> q;
	vector<vector<ll>> cnt(26, vector<ll>(n, 0));
	vector<LazySegmentTree<ll>> sg(26, LazySegmentTree<ll>(n,0,-1,1));
	REP(i, n) {
		cnt[s[i] - 'a'][i] = 1;
	}
	REP(i, 26) {
		sg[i].init(cnt[i]);
	}
	REP(loop, q) {
		int que;
		cin >> que;
		if (que == 1) {
			int i;
			char c;
			cin >> i >> c;
			i--;
			sg[s[i] - 'a'].update(i,i+1, 0);
			sg[c - 'a'].update(i,i+1, 1);
			s[i] = c;
		} else {
			int l, r;
			cin >> l >> r;
			l--;
			int res = 0;
			REP(j, 26) {
				int cc = sg[j].query(l, r);
				if (cc > 0) {
					res++;
				}
			}
			put(res);
		}
	}
	return 0;
}

Measured memory_bytes: 545112