You are given a string S of length N consisting of lowercase English letters.

Process Q queries of the following two types:

* Type 1: change the i_q-th character of S to c_q. (Do nothing if the i_q-th character is already c_q.)
* Type 2: answer the number of different characters occurring in the substring of S between the l_q-th and r_q-th characters (inclusive).

Constraints

* N, Q, i_q, l_q, and r_q are integers.
* S is a string consisting of lowercase English letters.
* c_q is a lowercase English letter.
* 1 \leq N \leq 500000
* 1 \leq Q \leq 20000
* |S| = N
* 1 \leq i_q \leq N
* 1 \leq l_q \leq r_q \leq N
* There is at least one query of type 2 in each testcase.

Input

Input is given from Standard Input in the following format:


N
S
Q
Query_1
\vdots
Query_Q


Here, Query_i in the 4-th through (Q+3)-th lines is one of the following:


1 i_q c_q



2 l_q r_q


Output

For each query of type 2, print a line containing the answer.

Example

Input

7
abcdbbd
6
2 3 6
1 5 z
2 1 1
1 4 a
1 7 d
2 1 7


Output

3
1
5
import java.util.*;
import java.util.stream.Collectors;
import java.io.*;
import java.nio.charset.StandardCharsets;

public class Main {
	int N;
	char[] S;
	int Q;
	Query[] queries;
	Map<Character, List<Integer>> map;

	static class Query {
		int type;
		int i, l, r;
		char c;

		Query(String line) {
			String[] tokens = line.split(" ");
			type = Integer.parseInt(tokens[0]);
			if (type == 1) {
				i = Integer.parseInt(tokens[1]) - 1;
				c = tokens[2].charAt(0);
			} else {
				l = Integer.parseInt(tokens[1]) - 1;
				r = Integer.parseInt(tokens[2]) - 1;
			}
		}
	}

	public static void main(String[] args) throws IOException {
		InputStreamReader reader = new InputStreamReader(System.in, StandardCharsets.UTF_8);
		BufferedReader in = new BufferedReader(reader);
		Main ins = new Main(in);
		ins.calc();
		ins.showResult();
	}

	Main(BufferedReader in) throws IOException {
		N = Integer.parseInt(in.readLine());
		S = in.readLine().toCharArray();
		Q = Integer.parseInt(in.readLine());
		queries = new Query[Q];
		for (int i = 0; i < Q; ++i) {
			queries[i] = new Query(in.readLine());
		}
		this.map = new HashMap<>();
		// まず全アルファベットだけ用意する
		for (int i = (int) 'a'; i <= (int) 'z'; ++i) {
			char c = (char) i;
			map.put(c, new ArrayList<>());
		}
		for (int i = 0; i < N; ++i) {
			Character c = S[i];
			map.get(c).add(i);
		}
	}

	boolean check(int l, int r, List<Integer> positions) {
		if (positions.isEmpty()) {
			return false;
		}
		if (r < positions.get(0)) {
			return false;
		}
		if (positions.get(positions.size() - 1) < l) {
			return false;
		}
		int posL = Collections.binarySearch(positions, l);
		int posR = Collections.binarySearch(positions, r);
		if (posL >= 0 && posR >= 0) {
			return true;
		} else {
			if (posL == posR) {
				return false;
			} else {
				return true;
			}
		}
	}

	int eval(Query query) {
		if (query.type == 1) {
			// replaceする
			char old = S[query.i];
			S[query.i] = query.c;
			// list側もreplaceする
			int index = Collections.binarySearch(map.get(old), query.i);
			map.get(old).remove(index);
			// insertするindexを求める
			int index2 = Collections.binarySearch(map.get(query.c), query.i);
			index2 = (index2 + 1) * -1;
			map.get(query.c).add(index2, query.i);
			return -1;
		} else {
			// countする
			int count = 0;
			for(List<Integer> list: map.values()) {
				if(check(query.l, query.r, list)) {
					++count;
				}
			}
			return count;
		}
	}

	void calc() {
		for (int i = 0; i < Q; ++i) {
			int count = eval(queries[i]);
			if (count >= 0) {
				System.out.println(count);
			}
		}
	}

	void showResult() {
	}

}
