class SegmentTree():
    '''
    非再帰
    segment tree
    '''

    def __init__(self, n, func, init=float('inf')):
        '''
        n->配列の長さ
        func:func(a,b)->val,　func=minだとRMQになる
        木の高さhとすると,
        n:h-1までのノード数。h段目のノードにアクセスするために使う。
        data:ノード。
        parent:k->child k*2+1とk*2+2
        '''
        self.n = 2**(n-1).bit_length()
        self.init = init
        self.data = [init]*(2*self.n)
        self.func = func

    def set(self, k, v):
        '''
        あたいの初期化
        '''
        self.data[k+self.n-1] = v

    def build(self):
        '''
        setの後に一斉更新
        '''
        for k in reversed(range(self.n-1)):
            self.data[k] = self.func(self.data[k*2+1], self.data[k*2+2])

    def update(self, k, a):
        '''
        list[k]=aに更新する。
        更新ぶんをrootまで更新
        '''
        k += self.n-1
        self.data[k] = a

        while k > 0:
            k = (k-1)//2
            self.data[k] = self.func(self.data[k*2+1], self.data[k*2+2])

    def query(self, l, r):
        '''
        [l,r)のfuncを求める
        '''
        L = l+self.n
        R = r+self.n
        ret = self.init
        while L < R:
            if R & 1:
                R -= 1
                ret = self.func(ret, self.data[R-1])
            if L & 1:
                ret = self.func(ret, self.data[L-1])
                L += 1
            L >>= 1
            R >>= 1
        return ret


N = int(input())
S = input()
Q = int(input())
queries = [list(input().split()) for _ in range(Q)]


def a2n(a):
    return ord(a)-ord("a")


def createInp(a):
    return 1 << a2n(a)


Seg = SegmentTree(len(S), lambda x, y: x | y, init=0)
for i, s in enumerate(S):
    Seg.set(i, createInp(s))
Seg.build()

for q, l, r in queries:
    if q == "1":
        Seg.update(int(l)-1, createInp(r))
    else:
        print(bin(Seg.query(int(l)-1, int(r))).count('1')) class SegmentTree():
    '''
    非再帰
    segment tree
    '''

    def __init__(self, n, func, init=float('inf')):
        '''
        n->配列の長さ
        func:func(a,b)->val,　func=minだとRMQになる
        木の高さhとすると,
        n:h-1までのノード数。h段目のノードにアクセスするために使う。
        data:ノード。
        parent:k->child k*2+1とk*2+2
        '''
        self.n = 2**(n-1).bit_length()
        self.init = init
        self.data = [init]*(2*self.n)
        self.func = func

    def set(self, k, v):
        '''
        あたいの初期化
        '''
        self.data[k+self.n-1] = v

    def build(self):
        '''
        setの後に一斉更新
        '''
        for k in reversed(range(self.n-1)):
            self.data[k] = self.func(self.data[k*2+1], self.data[k*2+2])

    def update(self, k, a):
        '''
        list[k]=aに更新する。
        更新ぶんをrootまで更新
        '''
        k += self.n-1
        self.data[k] = a

        while k > 0:
            k = (k-1)//2
            self.data[k] = self.func(self.data[k*2+1], self.data[k*2+2])

    def query(self, l, r):
        '''
        [l,r)のfuncを求める
        '''
        L = l+self.n
        R = r+self.n
        ret = self.init
        while L < R:
            if R & 1:
                R -= 1
                ret = self.func(ret, self.data[R-1])
            if L & 1:
                ret = self.func(ret, self.data[L-1])
                L += 1
            L >>= 1
            R >>= 1
        return ret SegmentTree '''
    非再帰
    segment tree
    ''' def __init__(self, n, func, init=float('inf')):
        '''
        n->配列の長さ
        func:func(a,b)->val,　func=minだとRMQになる
        木の高さhとすると,
        n:h-1までのノード数。h段目のノードにアクセスするために使う。
        data:ノード。
        parent:k->child k*2+1とk*2+2
        '''
        self.n = 2**(n-1).bit_length()
        self.init = init
        self.data = [init]*(2*self.n)
        self.func = func

     __init__ '''
        n->配列の長さ
        func:func(a,b)->val,　func=minだとRMQになる
        木の高さhとすると,
        n:h-1までのノード数。h段目のノードにアクセスするために使う。
        data:ノード。
        parent:k->child k*2+1とk*2+2
        ''' self.n = 2**(n-1).bit_length() self.n self n 2**(n-1).bit_length() 2 (n-1).bit_length() n-1).bit_length n-1 n 1 bit_length self.init = init self.init self init init self.data = [init]*(2*self.n) self.data self data [init]*(2*self.n) [init] init 2*self.n 2 self.n self n self.func = func self.func self func func self self n n func func init=float('inf') init float('inf') float 'inf' def set(self, k, v):
        '''
        あたいの初期化
        '''
        self.data[k+self.n-1] = v

     set '''
        あたいの初期化
        ''' self.data[k+self.n-1] = v self.data[k+self.n-1] self.data self data k+self.n-1 k+self.n k self.n self n 1 v self self k k v v def build(self):
        '''
        setの後に一斉更新
        '''
        for k in reversed(range(self.n-1)):
            self.data[k] = self.func(self.data[k*2+1], self.data[k*2+2])

     build '''
        setの後に一斉更新
        ''' for k in reversed(range(self.n-1)):
            self.data[k] = self.func(self.data[k*2+1], self.data[k*2+2])

     k reversed(range(self.n-1)) reversed range(self.n-1) range self.n-1 self.n self n 1 self.data[k] = self.func(self.data[k*2+1], self.data[k*2+2]) self.data[k] self.data self data k self.func(self.data[k*2+1], self.data[k*2+2]) self.func self func self.data[k*2+1] self.data self data k*2+1 k*2 k 2 1 self.data[k*2+2] self.data self data k*2+2 k*2 k 2 2 self self def update(self, k, a):
        '''
        list[k]=aに更新する。
        更新ぶんをrootまで更新
        '''
        k += self.n-1
        self.data[k] = a

        while k > 0:
            k = (k-1)//2
            self.data[k] = self.func(self.data[k*2+1], self.data[k*2+2])

     update '''
        list[k]=aに更新する。
        更新ぶんをrootまで更新
        ''' k += self.n-1 k self.n-1 self.n self n 1 self.data[k] = a self.data[k] self.data self data k a while k > 0:
            k = (k-1)//2
            self.data[k] = self.func(self.data[k*2+1], self.data[k*2+2])

     k > 0 k 0 k = (k-1)//2 k (k-1)//2 k-1 k 1 2 self.data[k] = self.func(self.data[k*2+1], self.data[k*2+2]) self.data[k] self.data self data k self.func(self.data[k*2+1], self.data[k*2+2]) self.func self func self.data[k*2+1] self.data self data k*2+1 k*2 k 2 1 self.data[k*2+2] self.data self data k*2+2 k*2 k 2 2 self self k k a a def query(self, l, r):
        '''
        [l,r)のfuncを求める
        '''
        L = l+self.n
        R = r+self.n
        ret = self.init
        while L < R:
            if R & 1:
                R -= 1
                ret = self.func(ret, self.data[R-1])
            if L & 1:
                ret = self.func(ret, self.data[L-1])
                L += 1
            L >>= 1
            R >>= 1
        return ret query '''
        [l,r)のfuncを求める
        ''' L = l+self.n L l+self.n l self.n self n R = r+self.n R r+self.n r self.n self n ret = self.init ret self.init self init while L < R:
            if R & 1:
                R -= 1
                ret = self.func(ret, self.data[R-1])
            if L & 1:
                ret = self.func(ret, self.data[L-1])
                L += 1
            L >>= 1
            R >>= 1
         L < R L R if R & 1:
                R -= 1
                ret = self.func(ret, self.data[R-1])
             R & 1 R 1 R -= 1 R 1 ret = self.func(ret, self.data[R-1]) ret self.func(ret, self.data[R-1]) self.func self func ret self.data[R-1] self.data self data R-1 R 1 if L & 1:
                ret = self.func(ret, self.data[L-1])
                L += 1
             L & 1 L 1 ret = self.func(ret, self.data[L-1]) ret self.func(ret, self.data[L-1]) self.func self func ret self.data[L-1] self.data self data L-1 L 1 L += 1 L 1 L >>= 1 L 1 R >>= 1 R 1 return ret ret self self l l r r N = int(input()) N int(input()) int input() input S = input() S input() input Q = int(input()) Q int(input()) int input() input list(input().split()) for _ in range(Q) for _ in range(Q) _ range(Q) range Q for _ in range(Q) list(input().split()) list input().split() ().split () input split queries = [list(input().split()) for _ in range(Q)] queries [list(input().split()) for _ in range(Q)] def a2n(a):
    return ord(a)-ord("a") a2n return ord(a)-ord("a") ord(a)-ord("a") ord(a) ord a ord("a") ord "a" a a def createInp(a):
    return 1 << a2n(a) createInp return 1 << a2n(a) 1 << a2n(a) 1 a2n(a) a2n a a a Seg = SegmentTree(len(S), lambda x, y: x | y, init=0) Seg SegmentTree(len(S), lambda x, y: x | y, init=0) SegmentTree len(S) len S lambda x, y: x | y x | y x y x y init=0 init 0 for i, s in enumerate(S):
    Seg.set(i, createInp(s)) i s enumerate(S) enumerate S Seg.set(i, createInp(s)) Seg.set Seg set i createInp(s) createInp s Seg.build() Seg.build Seg build for q, l, r in queries:
    if q == "1":
        Seg.update(int(l)-1, createInp(r))
    else:
        print(bin(Seg.query(int(l)-1, int(r))).count('1')) q l r queries if q == "1":
        Seg.update(int(l)-1, createInp(r))
    else:
        print(bin(Seg.query(int(l)-1, int(r))).count('1')) q == "1" q "1" Seg.update(int(l)-1, createInp(r)) Seg.update Seg update int(l)-1 int(l) int l 1 createInp(r) createInp r print(bin(Seg.query(int(l)-1, int(r))).count('1')) print bin(Seg.query(int(l)-1, int(r))).count('1') (Seg.query(int(l)-1, int(r))).count (Seg.query(int(l)-1, int(r))) bin Seg.query(int(l)-1, int(r)) Seg.query Seg query int(l)-1 int(l) int l 1 int(r) int r count '1' Q = int(input()) int(input()) Q queries = [list(input().split()) for _ in range(Q)] [list(input().split()) for _ in range(Q)] queries S = input() input() S N = int(input()) int(input()) N Seg = SegmentTree(len(S), lambda x, y: x | y, init=0) SegmentTree(len(S), lambda x, y: x | y, init=0) Seg def a2n(a):
    return ord(a)-ord("a") def a2n(a):
    return ord(a)-ord("a") a2n def createInp(a):
    return 1 << a2n(a) def createInp(a):
    return 1 << a2n(a) createInp class SegmentTree():
    '''
    非再帰
    segment tree
    '''

    def __init__(self, n, func, init=float('inf')):
        '''
        n->配列の長さ
        func:func(a,b)->val,　func=minだとRMQになる
        木の高さhとすると,
        n:h-1までのノード数。h段目のノードにアクセスするために使う。
        data:ノード。
        parent:k->child k*2+1とk*2+2
        '''
        self.n = 2**(n-1).bit_length()
        self.init = init
        self.data = [init]*(2*self.n)
        self.func = func

    def set(self, k, v):
        '''
        あたいの初期化
        '''
        self.data[k+self.n-1] = v

    def build(self):
        '''
        setの後に一斉更新
        '''
        for k in reversed(range(self.n-1)):
            self.data[k] = self.func(self.data[k*2+1], self.data[k*2+2])

    def update(self, k, a):
        '''
        list[k]=aに更新する。
        更新ぶんをrootまで更新
        '''
        k += self.n-1
        self.data[k] = a

        while k > 0:
            k = (k-1)//2
            self.data[k] = self.func(self.data[k*2+1], self.data[k*2+2])

    def query(self, l, r):
        '''
        [l,r)のfuncを求める
        '''
        L = l+self.n
        R = r+self.n
        ret = self.init
        while L < R:
            if R & 1:
                R -= 1
                ret = self.func(ret, self.data[R-1])
            if L & 1:
                ret = self.func(ret, self.data[L-1])
                L += 1
            L >>= 1
            R >>= 1
        return ret class SegmentTree():
    '''
    非再帰
    segment tree
    '''

    def __init__(self, n, func, init=float('inf')):
        '''
        n->配列の長さ
        func:func(a,b)->val,　func=minだとRMQになる
        木の高さhとすると,
        n:h-1までのノード数。h段目のノードにアクセスするために使う。
        data:ノード。
        parent:k->child k*2+1とk*2+2
        '''
        self.n = 2**(n-1).bit_length()
        self.init = init
        self.data = [init]*(2*self.n)
        self.func = func

    def set(self, k, v):
        '''
        あたいの初期化
        '''
        self.data[k+self.n-1] = v

    def build(self):
        '''
        setの後に一斉更新
        '''
        for k in reversed(range(self.n-1)):
            self.data[k] = self.func(self.data[k*2+1], self.data[k*2+2])

    def update(self, k, a):
        '''
        list[k]=aに更新する。
        更新ぶんをrootまで更新
        '''
        k += self.n-1
        self.data[k] = a

        while k > 0:
            k = (k-1)//2
            self.data[k] = self.func(self.data[k*2+1], self.data[k*2+2])

    def query(self, l, r):
        '''
        [l,r)のfuncを求める
        '''
        L = l+self.n
        R = r+self.n
        ret = self.init
        while L < R:
            if R & 1:
                R -= 1
                ret = self.func(ret, self.data[R-1])
            if L & 1:
                ret = self.func(ret, self.data[L-1])
                L += 1
            L >>= 1
            R >>= 1
        return ret SegmentTree
class SegmentTree():
    '''
    非再帰
    segment tree
    '''

    def __init__(self, n, func, init=float('inf')):
        '''
        n->配列の長さ
        func:func(a,b)->val,　func=minだとRMQになる
        木の高さhとすると,
        n:h-1までのノード数。h段目のノードにアクセスするために使う。
        data:ノード。
        parent:k->child k*2+1とk*2+2
        '''
        self.n = 2**(n-1).bit_length()
        self.init = init
        self.data = [init]*(2*self.n)
        self.func = func

    def set(self, k, v):
        '''
        あたいの初期化
        '''
        self.data[k+self.n-1] = v

    def build(self):
        '''
        setの後に一斉更新
        '''
        for k in reversed(range(self.n-1)):
            self.data[k] = self.func(self.data[k*2+1], self.data[k*2+2])

    def update(self, k, a):
        '''
        list[k]=aに更新する。
        更新ぶんをrootまで更新
        '''
        k += self.n-1
        self.data[k] = a

        while k > 0:
            k = (k-1)//2
            self.data[k] = self.func(self.data[k*2+1], self.data[k*2+2])

    def query(self, l, r):
        '''
        [l,r)のfuncを求める
        '''
        L = l+self.n
        R = r+self.n
        ret = self.init
        while L < R:
            if R & 1:
                R -= 1
                ret = self.func(ret, self.data[R-1])
            if L & 1:
                ret = self.func(ret, self.data[L-1])
                L += 1
            L >>= 1
            R >>= 1
        return ret


N = int(input())
S = input()
Q = int(input())
queries = [list(input().split()) for _ in range(Q)]


def a2n(a):
    return ord(a)-ord("a")


def createInp(a):
    return 1 << a2n(a)


Seg = SegmentTree(len(S), lambda x, y: x | y, init=0)
for i, s in enumerate(S):
    Seg.set(i, createInp(s))
Seg.build()

for q, l, r in queries:
    if q == "1":
        Seg.update(int(l)-1, createInp(r))
    else:
        print(bin(Seg.query(int(l)-1, int(r))).count('1'))
