import sys
from collections import *
import heapq
import math
import bisect
from itertools import permutations,accumulate,combinations,product
from fractions import gcd
import copy
def input():
    return sys.stdin.readline()[:-1]
def ruiseki(lst):
    return [0]+list(accumulate(lst))
mod=pow(10,9)+7

n=int(input())
s=input()
q=int(input())
qlst=[list(input().split()) for i in range(q)]

lst=[0]*n

for i in range(n):
    lst[i] = pow(2,(ord(s[i])-ord("a")))

# print(lst)
#####segfunc######
# def segfunc(x,y):
#     return x|y
 
# def init(init_val): #渡されたリストでsegを初期化
#     #set_val
#     for i in range(n):
#         seg[i+num-1]=init_val[i]
#     #built
#     for i in range(num-2,-1,-1) :
#         seg[i]=segfunc(seg[2*i+1],seg[2*i+2]) 
    
# def update(k,x): #segの要素kをxに変更(セグ木全体の更新)
#     k += num-1
#     seg[k] = x
#     while k:
#         k = (k-1)//2
#         seg[k] = segfunc(seg[k*2+1],seg[k*2+2])
    
# def query(p,q): #区間[p,q)での、segfuncに準じた値を返す
#     if q<=p:
#         return ide_ele
#     p += num-1
#     q += num-2
#     res=ide_ele
#     while q-p>1:
#         if p&1 == 0:
#             res = segfunc(res,seg[p])
#         if q&1 == 1:
#             res = segfunc(res,seg[q])
#             q -= 1
#         p = p//2
#         q = (q-1)//2
#     if p == q:
#         res = segfunc(res,seg[p])
#     else:
#         res = segfunc(segfunc(res,seg[p]),seg[q])
#     return res
 
# #####単位元######
# """
# 最小値のセグ木 → 10**9　(最小値の更新に影響しないため)
# 　　和のセグ木 → 0　(上の単位元の説明を参照)
# 　　積のセグ木 → 1　(上の単位元の説明を参照)
# 　　gcdのセグ木 → 0　(gcdを更新しない値は0)
# """
# ide_ele = 0
 
# #num:n以上の最小の2のべき乗
# num =2**(n-1).bit_length()
# seg=[ide_ele]*2*num #単位元の配列(計算結果に影響を及ぼさない配列)を作成
 
class SegTree:
    def __init__(self, init_val, i_e):
        self.ide_ele=i_e
        self.num=2**(len(init_val)-1).bit_length()
        self.seg=[self.ide_ele]*2*self.num

        #set_val
        for i in range(len(init_val)):
            self.seg[i+self.num-1]=init_val[i]
        #built
        for i in range(self.num-2,-1,-1) :
            self.seg[i]=self.segfunc(self.seg[2*i+1],self.seg[2*i+2])

    # 書け
    def segfunc(self, x, y):
        return x|y
    
    def update(self, k, x):
        k += self.num-1
        self.seg[k] = x
        while k:
            k = (k-1)//2
            self.seg[k] = self.segfunc(self.seg[k*2+1],self.seg[k*2+2])

    def query(self, p, q):
        if q<=p:
            return self.ide_ele
        p += self.num-1
        q += self.num-2
        res=self.ide_ele
        while q-p>1:
            if p&1 == 0:
                res = self.segfunc(res,self.seg[p])
            if q&1 == 1:
                res = self.segfunc(res,self.seg[q])
                q -= 1
            p = p//2
            q = (q-1)//2
        if p == q:
            res = self.segfunc(res,self.seg[p])
        else:
            res = self.segfunc(self.segfunc(res,self.seg[p]),self.seg[q])
        return res

seg=SegTree(lst, 0)

def judge(u):
    res = 0
    for i in range(27):
        if u>>i & 1:
            res += 1
    return res
 
for i in range(q):
    t,x,y = qlst[i]
    if t == "1":
        seg.update(int(x)-1,pow(2,ord(y)-ord("a")))
    else:
        print(judge(seg.query(int(x)-1,int(y))))

Measured memory_bytes: 108740