class SegTree:
    # n : 元の配列の長さ
    # init_list: 元の配列
    # segfunc : 載せる関数（演算）
    # ide_ele : segfuncの単位元
        
    def __init__(self, n, init_list ,segfunc, ide_ele):
        #　num : 2**num >= n となる最小の整数 （葉の数）
        # seg : segtreeのリスト
        self.num = 2**((n-1).bit_length())
        self.seg = [ide_ele]*(2*self.num)
        self.segfunc = segfunc
        self.ide_ele = ide_ele
        # 葉の要素をセット
        for i in range(n):
            self.seg[i+self.num-1] = init_list[i]        
        # segtreeの構築
        for i in range(self.num-2, -1, -1):
            self.seg[i] = segfunc(self.seg[2*i+1],self.seg[2*i+2])
        
        #memo: 要素iの子ノードは要素2*i+1, 2*i+2
        #    : 要素iの親ノードは要素(i-1)//2
        
    # 要素の更新 (init_list[k]=x)
    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[2*k+1], self.seg[2*k+2])
     
    # 区間クエリ （区間[l,r)に対する演算結果）
    def query(self, l,r):
        if r<=l:
            return self.ide_ele
        
        l += self.num-1 #葉のノードのインデックス
        r += self.num-2 #半開区間から閉区間へ
        ret = self.ide_ele
        
        while r-l>1:
            if l&1 == 0:
                ret = self.segfunc(ret,self.seg[l])
            
            if r&1 == 1:
                ret = self.segfunc(ret,self.seg[r])
                r -= 1
            # 親ノードへ遷移
            l = l//2
            r = (r-1)//2
        if r==l:
            ret = self.segfunc(ret, self.seg[r])
        else:
            ret = self.segfunc(ret, self.seg[l])
            ret = self.segfunc(ret, self.seg[r])
        
        return ret
            
def segfunc(x,y):
    return max(x,y)

def segfunc2(x,y):
    return min(x,y)

def segfunc3(x,y):
    return x | y

def ctoi(c):
    return ord(c) - ord('a')

def main():
    N = int(input())
    S = list(input())
    Q = int(input())
    Segtree = [SegTree(N,[0] * N,segfunc,0) for _ in range(26)]
    for i, c in enumerate(S):
        Segtree[ctoi(c)].update(i,1)

    for _ in range(Q):
        q, *query = map(str, input().split())
        if q == '1':
            i, c = query
            i = int(i) - 1
            if c == S[i]:
                continue
            Segtree[ctoi(c)].update(i, 1)
            Segtree[ctoi(S[i])].update(i,0)
            S[i] = c
        else:
            l, r = query
            l = int(l) - 1
            r = int(r)
            ans = 0
            for j in range(26):
                if Segtree[j].query(l,r):
                    ans += 1
                    
            print(ans)



    


if __name__ == "__main__":
    main() class SegTree:
    # n : 元の配列の長さ
    # init_list: 元の配列
    # segfunc : 載せる関数（演算）
    # ide_ele : segfuncの単位元
        
    def __init__(self, n, init_list ,segfunc, ide_ele):
        #　num : 2**num >= n となる最小の整数 （葉の数）
        # seg : segtreeのリスト
        self.num = 2**((n-1).bit_length())
        self.seg = [ide_ele]*(2*self.num)
        self.segfunc = segfunc
        self.ide_ele = ide_ele
        # 葉の要素をセット
        for i in range(n):
            self.seg[i+self.num-1] = init_list[i]        
        # segtreeの構築
        for i in range(self.num-2, -1, -1):
            self.seg[i] = segfunc(self.seg[2*i+1],self.seg[2*i+2])
        
        #memo: 要素iの子ノードは要素2*i+1, 2*i+2
        #    : 要素iの親ノードは要素(i-1)//2
        
    # 要素の更新 (init_list[k]=x)
    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[2*k+1], self.seg[2*k+2])
     
    # 区間クエリ （区間[l,r)に対する演算結果）
    def query(self, l,r):
        if r<=l:
            return self.ide_ele
        
        l += self.num-1 #葉のノードのインデックス
        r += self.num-2 #半開区間から閉区間へ
        ret = self.ide_ele
        
        while r-l>1:
            if l&1 == 0:
                ret = self.segfunc(ret,self.seg[l])
            
            if r&1 == 1:
                ret = self.segfunc(ret,self.seg[r])
                r -= 1
            # 親ノードへ遷移
            l = l//2
            r = (r-1)//2
        if r==l:
            ret = self.segfunc(ret, self.seg[r])
        else:
            ret = self.segfunc(ret, self.seg[l])
            ret = self.segfunc(ret, self.seg[r])
        
        return ret
             SegTree def __init__(self, n, init_list ,segfunc, ide_ele):
        #　num : 2**num >= n となる最小の整数 （葉の数）
        # seg : segtreeのリスト
        self.num = 2**((n-1).bit_length())
        self.seg = [ide_ele]*(2*self.num)
        self.segfunc = segfunc
        self.ide_ele = ide_ele
        # 葉の要素をセット
        for i in range(n):
            self.seg[i+self.num-1] = init_list[i]        
        # segtreeの構築
        for i in range(self.num-2, -1, -1):
            self.seg[i] = segfunc(self.seg[2*i+1],self.seg[2*i+2])
        
        #memo: 要素iの子ノードは要素2*i+1, 2*i+2
        #    : 要素iの親ノードは要素(i-1)//2
        
    # 要素の更新 (init_list[k]=x)
     __init__ self.num = 2**((n-1).bit_length()) self.num self num 2**((n-1).bit_length()) 2 (n-1).bit_length() n-1).bit_length n-1 n 1 bit_length self.seg = [ide_ele]*(2*self.num) self.seg self seg [ide_ele]*(2*self.num) [ide_ele] ide_ele 2*self.num 2 self.num self num self.segfunc = segfunc self.segfunc self segfunc segfunc self.ide_ele = ide_ele self.ide_ele self ide_ele ide_ele for i in range(n):
            self.seg[i+self.num-1] = init_list[i]        
        # segtreeの構築
         i range(n) range n self.seg[i+self.num-1] = init_list[i] self.seg[i+self.num-1] self.seg self seg i+self.num-1 i+self.num i self.num self num 1 init_list[i] init_list i for i in range(self.num-2, -1, -1):
            self.seg[i] = segfunc(self.seg[2*i+1],self.seg[2*i+2])
        
        #memo: 要素iの子ノードは要素2*i+1, 2*i+2
        #    : 要素iの親ノードは要素(i-1)//2
        
    # 要素の更新 (init_list[k]=x)
     i range(self.num-2, -1, -1) range self.num-2 self.num self num 2 -1 -1 self.seg[i] = segfunc(self.seg[2*i+1],self.seg[2*i+2]) self.seg[i] self.seg self seg i segfunc(self.seg[2*i+1],self.seg[2*i+2]) segfunc self.seg[2*i+1] self.seg self seg 2*i+1 2*i 2 i 1 self.seg[2*i+2] self.seg self seg 2*i+2 2*i 2 i 2 self self n n init_list init_list segfunc segfunc ide_ele ide_ele 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[2*k+1], self.seg[2*k+2])
     
    # 区間クエリ （区間[l,r)に対する演算結果）
     update k += self.num-1 k self.num-1 self.num self num 1 self.seg[k] = x self.seg[k] self.seg self seg k x while k:
            k = (k-1)//2
            self.seg[k] = self.segfunc(self.seg[2*k+1], self.seg[2*k+2])
     
    # 区間クエリ （区間[l,r)に対する演算結果）
     k k = (k-1)//2 k (k-1)//2 k-1 k 1 2 self.seg[k] = self.segfunc(self.seg[2*k+1], self.seg[2*k+2]) self.seg[k] self.seg self seg k self.segfunc(self.seg[2*k+1], self.seg[2*k+2]) self.segfunc self segfunc self.seg[2*k+1] self.seg self seg 2*k+1 2*k 2 k 1 self.seg[2*k+2] self.seg self seg 2*k+2 2*k 2 k 2 self self k k x x def query(self, l,r):
        if r<=l:
            return self.ide_ele
        
        l += self.num-1 #葉のノードのインデックス
        r += self.num-2 #半開区間から閉区間へ
        ret = self.ide_ele
        
        while r-l>1:
            if l&1 == 0:
                ret = self.segfunc(ret,self.seg[l])
            
            if r&1 == 1:
                ret = self.segfunc(ret,self.seg[r])
                r -= 1
            # 親ノードへ遷移
            l = l//2
            r = (r-1)//2
        if r==l:
            ret = self.segfunc(ret, self.seg[r])
        else:
            ret = self.segfunc(ret, self.seg[l])
            ret = self.segfunc(ret, self.seg[r])
        
        return ret
             query if r<=l:
            return self.ide_ele
        
         r<=l r l return self.ide_ele self.ide_ele self ide_ele l += self.num-1 l self.num-1 self.num self num 1 r += self.num-2 r self.num-2 self.num self num 2 ret = self.ide_ele ret self.ide_ele self ide_ele while r-l>1:
            if l&1 == 0:
                ret = self.segfunc(ret,self.seg[l])
            
            if r&1 == 1:
                ret = self.segfunc(ret,self.seg[r])
                r -= 1
            # 親ノードへ遷移
            l = l//2
            r = (r-1)//2
         r-l>1 r-l r l 1 if l&1 == 0:
                ret = self.segfunc(ret,self.seg[l])
            
             l&1 == 0 l&1 l 1 0 ret = self.segfunc(ret,self.seg[l]) ret self.segfunc(ret,self.seg[l]) self.segfunc self segfunc ret self.seg[l] self.seg self seg l if r&1 == 1:
                ret = self.segfunc(ret,self.seg[r])
                r -= 1
            # 親ノードへ遷移
             r&1 == 1 r&1 r 1 1 ret = self.segfunc(ret,self.seg[r]) ret self.segfunc(ret,self.seg[r]) self.segfunc self segfunc ret self.seg[r] self.seg self seg r r -= 1 r 1 l = l//2 l l//2 l 2 r = (r-1)//2 r (r-1)//2 r-1 r 1 2 if r==l:
            ret = self.segfunc(ret, self.seg[r])
        else:
            ret = self.segfunc(ret, self.seg[l])
            ret = self.segfunc(ret, self.seg[r])
        
         r==l r l ret = self.segfunc(ret, self.seg[r]) ret self.segfunc(ret, self.seg[r]) self.segfunc self segfunc ret self.seg[r] self.seg self seg r ret = self.segfunc(ret, self.seg[l]) ret self.segfunc(ret, self.seg[l]) self.segfunc self segfunc ret self.seg[l] self.seg self seg l ret = self.segfunc(ret, self.seg[r]) ret self.segfunc(ret, self.seg[r]) self.segfunc self segfunc ret self.seg[r] self.seg self seg r return ret ret self self l l r r def segfunc(x,y):
    return max(x,y) segfunc return max(x,y) max(x,y) max x y x x y y def segfunc2(x,y):
    return min(x,y) segfunc2 return min(x,y) min(x,y) min x y x x y y def segfunc3(x,y):
    return x | y segfunc3 return x | y x | y x y x x y y def ctoi(c):
    return ord(c) - ord('a') ctoi return ord(c) - ord('a') ord(c) - ord('a') ord(c) ord c ord('a') ord 'a' c c def main():
    N = int(input())
    S = list(input())
    Q = int(input())
    Segtree = [SegTree(N,[0] * N,segfunc,0) for _ in range(26)]
    for i, c in enumerate(S):
        Segtree[ctoi(c)].update(i,1)

    for _ in range(Q):
        q, *query = map(str, input().split())
        if q == '1':
            i, c = query
            i = int(i) - 1
            if c == S[i]:
                continue
            Segtree[ctoi(c)].update(i, 1)
            Segtree[ctoi(S[i])].update(i,0)
            S[i] = c
        else:
            l, r = query
            l = int(l) - 1
            r = int(r)
            ans = 0
            for j in range(26):
                if Segtree[j].query(l,r):
                    ans += 1
                    
            print(ans)



     main N = int(input()) N int(input()) int input() input S = list(input()) S list(input()) list input() input Q = int(input()) Q int(input()) int input() input SegTree(N,[0] * N,segfunc,0) for _ in range(26) for _ in range(26) _ range(26) range 26 for _ in range(26) SegTree(N,[0] * N,segfunc,0) SegTree N [0] * N [0] 0 N segfunc 0 Segtree = [SegTree(N,[0] * N,segfunc,0) for _ in range(26)] Segtree [SegTree(N,[0] * N,segfunc,0) for _ in range(26)] for i, c in enumerate(S):
        Segtree[ctoi(c)].update(i,1)

     i c enumerate(S) enumerate S Segtree[ctoi(c)].update(i,1) [ctoi(c)].update [ctoi(c)] Segtree ctoi(c) ctoi c update i 1 for _ in range(Q):
        q, *query = map(str, input().split())
        if q == '1':
            i, c = query
            i = int(i) - 1
            if c == S[i]:
                continue
            Segtree[ctoi(c)].update(i, 1)
            Segtree[ctoi(S[i])].update(i,0)
            S[i] = c
        else:
            l, r = query
            l = int(l) - 1
            r = int(r)
            ans = 0
            for j in range(26):
                if Segtree[j].query(l,r):
                    ans += 1
                    
            print(ans)



     _ range(Q) range Q q, *query = map(str, input().split()) q map(str, input().split()) map str input().split() ().split () input split *query query if q == '1':
            i, c = query
            i = int(i) - 1
            if c == S[i]:
                continue
            Segtree[ctoi(c)].update(i, 1)
            Segtree[ctoi(S[i])].update(i,0)
            S[i] = c
        else:
            l, r = query
            l = int(l) - 1
            r = int(r)
            ans = 0
            for j in range(26):
                if Segtree[j].query(l,r):
                    ans += 1
                    
            print(ans)



     q == '1' q '1' i, c = query i query c i = int(i) - 1 i int(i) - 1 int(i) int i 1 if c == S[i]:
                continue
             c == S[i] c S[i] S i continue Segtree[ctoi(c)].update(i, 1) [ctoi(c)].update [ctoi(c)] Segtree ctoi(c) ctoi c update i 1 Segtree[ctoi(S[i])].update(i,0) [ctoi(S[i])].update [ctoi(S[i])] Segtree ctoi(S[i]) ctoi S[i] S i update i 0 S[i] = c S[i] S i c l, r = query l query r l = int(l) - 1 l int(l) - 1 int(l) int l 1 r = int(r) r int(r) int r ans = 0 ans 0 for j in range(26):
                if Segtree[j].query(l,r):
                    ans += 1
                    
             j range(26) range 26 if Segtree[j].query(l,r):
                    ans += 1
                    
             Segtree[j].query(l,r) [j].query [j] Segtree j query l r ans += 1 ans 1 print(ans) print ans if __name__ == "__main__":
    main() __name__ == "__main__" __name__ "__main__" main() main def ctoi(c):
    return ord(c) - ord('a') def ctoi(c):
    return ord(c) - ord('a') ctoi def main():
    N = int(input())
    S = list(input())
    Q = int(input())
    Segtree = [SegTree(N,[0] * N,segfunc,0) for _ in range(26)]
    for i, c in enumerate(S):
        Segtree[ctoi(c)].update(i,1)

    for _ in range(Q):
        q, *query = map(str, input().split())
        if q == '1':
            i, c = query
            i = int(i) - 1
            if c == S[i]:
                continue
            Segtree[ctoi(c)].update(i, 1)
            Segtree[ctoi(S[i])].update(i,0)
            S[i] = c
        else:
            l, r = query
            l = int(l) - 1
            r = int(r)
            ans = 0
            for j in range(26):
                if Segtree[j].query(l,r):
                    ans += 1
                    
            print(ans)



     def main():
    N = int(input())
    S = list(input())
    Q = int(input())
    Segtree = [SegTree(N,[0] * N,segfunc,0) for _ in range(26)]
    for i, c in enumerate(S):
        Segtree[ctoi(c)].update(i,1)

    for _ in range(Q):
        q, *query = map(str, input().split())
        if q == '1':
            i, c = query
            i = int(i) - 1
            if c == S[i]:
                continue
            Segtree[ctoi(c)].update(i, 1)
            Segtree[ctoi(S[i])].update(i,0)
            S[i] = c
        else:
            l, r = query
            l = int(l) - 1
            r = int(r)
            ans = 0
            for j in range(26):
                if Segtree[j].query(l,r):
                    ans += 1
                    
            print(ans)



     main def segfunc3(x,y):
    return x | y def segfunc3(x,y):
    return x | y segfunc3 def segfunc(x,y):
    return max(x,y) def segfunc(x,y):
    return max(x,y) segfunc class SegTree:
    # n : 元の配列の長さ
    # init_list: 元の配列
    # segfunc : 載せる関数（演算）
    # ide_ele : segfuncの単位元
        
    def __init__(self, n, init_list ,segfunc, ide_ele):
        #　num : 2**num >= n となる最小の整数 （葉の数）
        # seg : segtreeのリスト
        self.num = 2**((n-1).bit_length())
        self.seg = [ide_ele]*(2*self.num)
        self.segfunc = segfunc
        self.ide_ele = ide_ele
        # 葉の要素をセット
        for i in range(n):
            self.seg[i+self.num-1] = init_list[i]        
        # segtreeの構築
        for i in range(self.num-2, -1, -1):
            self.seg[i] = segfunc(self.seg[2*i+1],self.seg[2*i+2])
        
        #memo: 要素iの子ノードは要素2*i+1, 2*i+2
        #    : 要素iの親ノードは要素(i-1)//2
        
    # 要素の更新 (init_list[k]=x)
    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[2*k+1], self.seg[2*k+2])
     
    # 区間クエリ （区間[l,r)に対する演算結果）
    def query(self, l,r):
        if r<=l:
            return self.ide_ele
        
        l += self.num-1 #葉のノードのインデックス
        r += self.num-2 #半開区間から閉区間へ
        ret = self.ide_ele
        
        while r-l>1:
            if l&1 == 0:
                ret = self.segfunc(ret,self.seg[l])
            
            if r&1 == 1:
                ret = self.segfunc(ret,self.seg[r])
                r -= 1
            # 親ノードへ遷移
            l = l//2
            r = (r-1)//2
        if r==l:
            ret = self.segfunc(ret, self.seg[r])
        else:
            ret = self.segfunc(ret, self.seg[l])
            ret = self.segfunc(ret, self.seg[r])
        
        return ret
             class SegTree:
    # n : 元の配列の長さ
    # init_list: 元の配列
    # segfunc : 載せる関数（演算）
    # ide_ele : segfuncの単位元
        
    def __init__(self, n, init_list ,segfunc, ide_ele):
        #　num : 2**num >= n となる最小の整数 （葉の数）
        # seg : segtreeのリスト
        self.num = 2**((n-1).bit_length())
        self.seg = [ide_ele]*(2*self.num)
        self.segfunc = segfunc
        self.ide_ele = ide_ele
        # 葉の要素をセット
        for i in range(n):
            self.seg[i+self.num-1] = init_list[i]        
        # segtreeの構築
        for i in range(self.num-2, -1, -1):
            self.seg[i] = segfunc(self.seg[2*i+1],self.seg[2*i+2])
        
        #memo: 要素iの子ノードは要素2*i+1, 2*i+2
        #    : 要素iの親ノードは要素(i-1)//2
        
    # 要素の更新 (init_list[k]=x)
    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[2*k+1], self.seg[2*k+2])
     
    # 区間クエリ （区間[l,r)に対する演算結果）
    def query(self, l,r):
        if r<=l:
            return self.ide_ele
        
        l += self.num-1 #葉のノードのインデックス
        r += self.num-2 #半開区間から閉区間へ
        ret = self.ide_ele
        
        while r-l>1:
            if l&1 == 0:
                ret = self.segfunc(ret,self.seg[l])
            
            if r&1 == 1:
                ret = self.segfunc(ret,self.seg[r])
                r -= 1
            # 親ノードへ遷移
            l = l//2
            r = (r-1)//2
        if r==l:
            ret = self.segfunc(ret, self.seg[r])
        else:
            ret = self.segfunc(ret, self.seg[l])
            ret = self.segfunc(ret, self.seg[r])
        
        return ret
             SegTree def segfunc2(x,y):
    return min(x,y) def segfunc2(x,y):
    return min(x,y) segfunc2
class SegTree:
    # n : 元の配列の長さ
    # init_list: 元の配列
    # segfunc : 載せる関数（演算）
    # ide_ele : segfuncの単位元
        
    def __init__(self, n, init_list ,segfunc, ide_ele):
        #　num : 2**num >= n となる最小の整数 （葉の数）
        # seg : segtreeのリスト
        self.num = 2**((n-1).bit_length())
        self.seg = [ide_ele]*(2*self.num)
        self.segfunc = segfunc
        self.ide_ele = ide_ele
        # 葉の要素をセット
        for i in range(n):
            self.seg[i+self.num-1] = init_list[i]        
        # segtreeの構築
        for i in range(self.num-2, -1, -1):
            self.seg[i] = segfunc(self.seg[2*i+1],self.seg[2*i+2])
        
        #memo: 要素iの子ノードは要素2*i+1, 2*i+2
        #    : 要素iの親ノードは要素(i-1)//2
        
    # 要素の更新 (init_list[k]=x)
    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[2*k+1], self.seg[2*k+2])
     
    # 区間クエリ （区間[l,r)に対する演算結果）
    def query(self, l,r):
        if r<=l:
            return self.ide_ele
        
        l += self.num-1 #葉のノードのインデックス
        r += self.num-2 #半開区間から閉区間へ
        ret = self.ide_ele
        
        while r-l>1:
            if l&1 == 0:
                ret = self.segfunc(ret,self.seg[l])
            
            if r&1 == 1:
                ret = self.segfunc(ret,self.seg[r])
                r -= 1
            # 親ノードへ遷移
            l = l//2
            r = (r-1)//2
        if r==l:
            ret = self.segfunc(ret, self.seg[r])
        else:
            ret = self.segfunc(ret, self.seg[l])
            ret = self.segfunc(ret, self.seg[r])
        
        return ret
            
def segfunc(x,y):
    return max(x,y)

def segfunc2(x,y):
    return min(x,y)

def segfunc3(x,y):
    return x | y

def ctoi(c):
    return ord(c) - ord('a')

def main():
    N = int(input())
    S = list(input())
    Q = int(input())
    Segtree = [SegTree(N,[0] * N,segfunc,0) for _ in range(26)]
    for i, c in enumerate(S):
        Segtree[ctoi(c)].update(i,1)

    for _ in range(Q):
        q, *query = map(str, input().split())
        if q == '1':
            i, c = query
            i = int(i) - 1
            if c == S[i]:
                continue
            Segtree[ctoi(c)].update(i, 1)
            Segtree[ctoi(S[i])].update(i,0)
            S[i] = c
        else:
            l, r = query
            l = int(l) - 1
            r = int(r)
            ans = 0
            for j in range(26):
                if Segtree[j].query(l,r):
                    ans += 1
                    
            print(ans)



    


if __name__ == "__main__":
    main()