n = int(input())
S = input()
q = int(input())


class BIT:
    def __init__(self, n):
        """
        初期化
        Input:　
            n: 配列の大きさ
        """
        self.n = n
        self.bit = [0] * (n+10)

    def add(self, x, w):
        """
        更新クエリ(add)
        Input:
            x: インデックス
            w: 加える値
        Note:
            self.bitが更新される
        """        
        while x <= self.n:
            self.bit[x] += w
            x += x&-x
    
    def sum(self, x):
        """
        部分和算出クエリ
        Input:
            x: インデックス
        Return:
            [1,a]の部分和
        """
        cnt = 0
        while x > 0:
            cnt += self.bit[x]
            # 次の最下位桁はどこか
            x -= x&-x
        return cnt   
    
    def psum(self, a, b):
        """
        区間[a,b)(0-indexed)における和
        Input
            a,b: 半開区間
        Return
            [a,b)の和
        """
        return self.sum(b-1) - self.sum(a-1)


def str2num(s):
    return ord(s)-ord("a")

bits = [BIT(n) for i in range(26)]
# 入力
ans = []
for i, s in enumerate(S):
    ind = str2num(s)
    bits[ind].add(i+1, 1)

S = list(S)
for _ in range(q):
    x,a,b = input().split()
    if x == "1":
        i = int(a)
        # 更新処理
        ind_before = str2num(S[i-1])
        ind = str2num(b)
        bits[ind_before].add(i,-1)
        bits[ind].add(i, 1)
        S[i-1] = b
    else:
        l = int(a)
        r = int(b)
        cnt = 0
        for bit in bits:
            if bit.psum(l,r+1) > 0:
                cnt += 1
        ans.append(cnt)
print(*ans)

         n = int(input()) n int(input()) int input() input S = input() S input() input q = int(input()) q int(input()) int input() input class BIT:
    def __init__(self, n):
        """
        初期化
        Input:　
            n: 配列の大きさ
        """
        self.n = n
        self.bit = [0] * (n+10)

    def add(self, x, w):
        """
        更新クエリ(add)
        Input:
            x: インデックス
            w: 加える値
        Note:
            self.bitが更新される
        """        
        while x <= self.n:
            self.bit[x] += w
            x += x&-x
    
    def sum(self, x):
        """
        部分和算出クエリ
        Input:
            x: インデックス
        Return:
            [1,a]の部分和
        """
        cnt = 0
        while x > 0:
            cnt += self.bit[x]
            # 次の最下位桁はどこか
            x -= x&-x
        return cnt   
    
    def psum(self, a, b):
        """
        区間[a,b)(0-indexed)における和
        Input
            a,b: 半開区間
        Return
            [a,b)の和
        """
        return self.sum(b-1) - self.sum(a-1) BIT def __init__(self, n):
        """
        初期化
        Input:　
            n: 配列の大きさ
        """
        self.n = n
        self.bit = [0] * (n+10)

     __init__ """
        初期化
        Input:　
            n: 配列の大きさ
        """ self.n = n self.n self n n self.bit = [0] * (n+10) self.bit self bit [0] * (n+10) [0] 0 n+10 n 10 self self n n def add(self, x, w):
        """
        更新クエリ(add)
        Input:
            x: インデックス
            w: 加える値
        Note:
            self.bitが更新される
        """        
        while x <= self.n:
            self.bit[x] += w
            x += x&-x
    
     add """
        更新クエリ(add)
        Input:
            x: インデックス
            w: 加える値
        Note:
            self.bitが更新される
        """ while x <= self.n:
            self.bit[x] += w
            x += x&-x
    
     x <= self.n x self.n self n self.bit[x] += w self.bit[x] self.bit self bit x w x += x&-x x x&-x x -x x self self x x w w def sum(self, x):
        """
        部分和算出クエリ
        Input:
            x: インデックス
        Return:
            [1,a]の部分和
        """
        cnt = 0
        while x > 0:
            cnt += self.bit[x]
            # 次の最下位桁はどこか
            x -= x&-x
        return cnt   
    
     sum """
        部分和算出クエリ
        Input:
            x: インデックス
        Return:
            [1,a]の部分和
        """ cnt = 0 cnt 0 while x > 0:
            cnt += self.bit[x]
            # 次の最下位桁はどこか
            x -= x&-x
         x > 0 x 0 cnt += self.bit[x] cnt self.bit[x] self.bit self bit x x -= x&-x x x&-x x -x x return cnt cnt self self x x def psum(self, a, b):
        """
        区間[a,b)(0-indexed)における和
        Input
            a,b: 半開区間
        Return
            [a,b)の和
        """
        return self.sum(b-1) - self.sum(a-1) psum """
        区間[a,b)(0-indexed)における和
        Input
            a,b: 半開区間
        Return
            [a,b)の和
        """ return self.sum(b-1) - self.sum(a-1) self.sum(b-1) - self.sum(a-1) self.sum(b-1) self.sum self sum b-1 b 1 self.sum(a-1) self.sum self sum a-1 a 1 self self a a b b def str2num(s):
    return ord(s)-ord("a") str2num return ord(s)-ord("a") ord(s)-ord("a") ord(s) ord s ord("a") ord "a" s s BIT(n) for i in range(26) for i in range(26) i range(26) range 26 for i in range(26) BIT(n) BIT n bits = [BIT(n) for i in range(26)] bits [BIT(n) for i in range(26)] ans = [] ans [] for i, s in enumerate(S):
    ind = str2num(s)
    bits[ind].add(i+1, 1) i s enumerate(S) enumerate S ind = str2num(s) ind str2num(s) str2num s bits[ind].add(i+1, 1) [ind].add [ind] bits ind add i+1 i 1 1 S = list(S) S list(S) list S for _ in range(q):
    x,a,b = input().split()
    if x == "1":
        i = int(a)
        # 更新処理
        ind_before = str2num(S[i-1])
        ind = str2num(b)
        bits[ind_before].add(i,-1)
        bits[ind].add(i, 1)
        S[i-1] = b
    else:
        l = int(a)
        r = int(b)
        cnt = 0
        for bit in bits:
            if bit.psum(l,r+1) > 0:
                cnt += 1
        ans.append(cnt) _ range(q) range q x,a,b = input().split() x input().split() ().split () input split a b if x == "1":
        i = int(a)
        # 更新処理
        ind_before = str2num(S[i-1])
        ind = str2num(b)
        bits[ind_before].add(i,-1)
        bits[ind].add(i, 1)
        S[i-1] = b
    else:
        l = int(a)
        r = int(b)
        cnt = 0
        for bit in bits:
            if bit.psum(l,r+1) > 0:
                cnt += 1
        ans.append(cnt) x == "1" x "1" i = int(a) i int(a) int a ind_before = str2num(S[i-1]) ind_before str2num(S[i-1]) str2num S[i-1] S i-1 i 1 ind = str2num(b) ind str2num(b) str2num b bits[ind_before].add(i,-1) [ind_before].add [ind_before] bits ind_before add i -1 bits[ind].add(i, 1) [ind].add [ind] bits ind add i 1 S[i-1] = b S[i-1] S i-1 i 1 b l = int(a) l int(a) int a r = int(b) r int(b) int b cnt = 0 cnt 0 for bit in bits:
            if bit.psum(l,r+1) > 0:
                cnt += 1
         bit bits if bit.psum(l,r+1) > 0:
                cnt += 1
         bit.psum(l,r+1) > 0 bit.psum(l,r+1) bit.psum bit psum l r+1 r 1 0 cnt += 1 cnt 1 ans.append(cnt) ans.append ans append cnt print(*ans) print *ans ans b = input().split() input().split() b r = int(b) int(b) r i = int(a) int(a) i class BIT:
    def __init__(self, n):
        """
        初期化
        Input:　
            n: 配列の大きさ
        """
        self.n = n
        self.bit = [0] * (n+10)

    def add(self, x, w):
        """
        更新クエリ(add)
        Input:
            x: インデックス
            w: 加える値
        Note:
            self.bitが更新される
        """        
        while x <= self.n:
            self.bit[x] += w
            x += x&-x
    
    def sum(self, x):
        """
        部分和算出クエリ
        Input:
            x: インデックス
        Return:
            [1,a]の部分和
        """
        cnt = 0
        while x > 0:
            cnt += self.bit[x]
            # 次の最下位桁はどこか
            x -= x&-x
        return cnt   
    
    def psum(self, a, b):
        """
        区間[a,b)(0-indexed)における和
        Input
            a,b: 半開区間
        Return
            [a,b)の和
        """
        return self.sum(b-1) - self.sum(a-1) class BIT:
    def __init__(self, n):
        """
        初期化
        Input:　
            n: 配列の大きさ
        """
        self.n = n
        self.bit = [0] * (n+10)

    def add(self, x, w):
        """
        更新クエリ(add)
        Input:
            x: インデックス
            w: 加える値
        Note:
            self.bitが更新される
        """        
        while x <= self.n:
            self.bit[x] += w
            x += x&-x
    
    def sum(self, x):
        """
        部分和算出クエリ
        Input:
            x: インデックス
        Return:
            [1,a]の部分和
        """
        cnt = 0
        while x > 0:
            cnt += self.bit[x]
            # 次の最下位桁はどこか
            x -= x&-x
        return cnt   
    
    def psum(self, a, b):
        """
        区間[a,b)(0-indexed)における和
        Input
            a,b: 半開区間
        Return
            [a,b)の和
        """
        return self.sum(b-1) - self.sum(a-1) BIT ind = str2num(s) str2num(s) ind n = int(input()) int(input()) n bits = [BIT(n) for i in range(26)] [BIT(n) for i in range(26)] bits a,b = input().split() input().split() a cnt = 0 0 cnt def str2num(s):
    return ord(s)-ord("a") def str2num(s):
    return ord(s)-ord("a") str2num S = input() input() S ans = [] [] ans cnt += 1 1 cnt l = int(a) int(a) l x,a,b = input().split() input().split() x q = int(input()) int(input()) q S = list(S) list(S) S ind_before = str2num(S[i-1]) str2num(S[i-1]) ind_before ind = str2num(b) str2num(b) ind
n = int(input())
S = input()
q = int(input())


class BIT:
    def __init__(self, n):
        """
        初期化
        Input:　
            n: 配列の大きさ
        """
        self.n = n
        self.bit = [0] * (n+10)

    def add(self, x, w):
        """
        更新クエリ(add)
        Input:
            x: インデックス
            w: 加える値
        Note:
            self.bitが更新される
        """        
        while x <= self.n:
            self.bit[x] += w
            x += x&-x
    
    def sum(self, x):
        """
        部分和算出クエリ
        Input:
            x: インデックス
        Return:
            [1,a]の部分和
        """
        cnt = 0
        while x > 0:
            cnt += self.bit[x]
            # 次の最下位桁はどこか
            x -= x&-x
        return cnt   
    
    def psum(self, a, b):
        """
        区間[a,b)(0-indexed)における和
        Input
            a,b: 半開区間
        Return
            [a,b)の和
        """
        return self.sum(b-1) - self.sum(a-1)


def str2num(s):
    return ord(s)-ord("a")

bits = [BIT(n) for i in range(26)]
# 入力
ans = []
for i, s in enumerate(S):
    ind = str2num(s)
    bits[ind].add(i+1, 1)

S = list(S)
for _ in range(q):
    x,a,b = input().split()
    if x == "1":
        i = int(a)
        # 更新処理
        ind_before = str2num(S[i-1])
        ind = str2num(b)
        bits[ind_before].add(i,-1)
        bits[ind].add(i, 1)
        S[i-1] = b
    else:
        l = int(a)
        r = int(b)
        cnt = 0
        for bit in bits:
            if bit.psum(l,r+1) > 0:
                cnt += 1
        ans.append(cnt)
print(*ans)

        
