import sys
input = sys.stdin.readline
from operator import or_


def read():
    N = int(input().strip())
    S = input().strip()
    Q = int(input().strip())
    return N, S, Q


class SegmentTree():
    
    def __init__(self, size, op=min, init_value=10**8):
        """初期化"""
        self.size = size
        self.op = op
        self.init_value = init_value
        n = 2 ** ((size-1).bit_length())
        treesize = n * 2
        st = [init_value for i in range(treesize)]
        self.st = st

    @classmethod
    def from_array(cls, a, op=min, init_value=10**8):
        st = cls(len(a), op=op, init_value=init_value)
        for i, x in enumerate(a):
            st.update(i, x)
        return st

    def update(self, key, value):
        """値の更新"""
        offset = len(self.st) // 2
        k = offset + key
        self.st[k] = value
        k >>= 1
        while k > 0:
            self.st[k] = self.op(self.st[k * 2], self.st[k * 2 + 1])
            k >>= 1

    def _query_bottomup(self, a, b):
        """区間[a, b) に対する累積操作
        """
        offset = len(self.st) // 2
        a += offset
        b += offset - 1
        s = self.init_value
        while a < b:
            if a & 1 == 1:
                s = self.op(s, self.st[a])
                a += 1
            a >>= 1
            if b & 1 == 0:
                s = self.op(s, self.st[b])
                b -= 1
            b >>= 1
        if a == b:
            s = self.op(s, self.st[a])
        return s

    def _query_topdown(self, a, b, k, l, r):
        """区間[a, b) に対する累積操作
        k: 着目しているノード (1-indexed)
        l: 探索区間 st[l, r) の左端 (0-indexed)
        r: 探索区間 st[l, r) の右端 (0-indexed)
        """
        if r <= a or b <= l:
            return self.init_value
        if a <= l and r <= b:
            return self.st[k]
        mid = (l + r) // 2
        lv = self._query_topdown(a, b, k * 2, l, mid)
        rv = self._query_topdown(a, b, k * 2 + 1, mid, r)
        return self.op(lv, rv)

    def query(self, a, b):
        """区間[a, b) に対する累積操作"""
        if a > b:
            raise ValueError("a must be less than equal b.")
        return self._query_topdown(a, b, k=1, l=0, r=len(self.st)//2)
        # return self._query_bottomup(a, b)


def solve_online(N, S, Q):
    tree = SegmentTree(N, op=or_, init_value=0)
    C = [ord(s) - ord("a") for s in S]
    for i in range(N):
        c = ord(S[i]) - ord("a")
        tree.update(i, 1 << c)

    for _ in range(Q):
        op, a, b = input().strip().split()
        if op == "1":
            i, c = int(a)-1, ord(b) - ord("a")
            tree.update(i, 1 << c)
        elif op == "2":
            l, r = int(a)-1, int(b)-1
            b = tree.query(l, r+1)
            s = 0
            while b > 0:
                if b & 1 == 1:
                    s += 1
                b >>= 1
            print(s)


if __name__ == '__main__':
    inputs = read()
    outputs = solve_online(*inputs)
    if outputs is not None:
        print("%s" % str(outputs)) import sys sys input = sys.stdin.readline input sys.stdin.readline sys.stdin sys stdin readline from operator import or_ def read():
    N = int(input().strip())
    S = input().strip()
    Q = int(input().strip())
    return N, S, Q read N = int(input().strip()) N int(input().strip()) int input().strip() ().strip () input strip S = input().strip() S input().strip() ().strip () input strip Q = int(input().strip()) Q int(input().strip()) int input().strip() ().strip () input strip return N, S, Q return N, S, Q N S Q class SegmentTree():
    
    def __init__(self, size, op=min, init_value=10**8):
        """初期化"""
        self.size = size
        self.op = op
        self.init_value = init_value
        n = 2 ** ((size-1).bit_length())
        treesize = n * 2
        st = [init_value for i in range(treesize)]
        self.st = st

    @classmethod
    def from_array(cls, a, op=min, init_value=10**8):
        st = cls(len(a), op=op, init_value=init_value)
        for i, x in enumerate(a):
            st.update(i, x)
        return st

    def update(self, key, value):
        """値の更新"""
        offset = len(self.st) // 2
        k = offset + key
        self.st[k] = value
        k >>= 1
        while k > 0:
            self.st[k] = self.op(self.st[k * 2], self.st[k * 2 + 1])
            k >>= 1

    def _query_bottomup(self, a, b):
        """区間[a, b) に対する累積操作
        """
        offset = len(self.st) // 2
        a += offset
        b += offset - 1
        s = self.init_value
        while a < b:
            if a & 1 == 1:
                s = self.op(s, self.st[a])
                a += 1
            a >>= 1
            if b & 1 == 0:
                s = self.op(s, self.st[b])
                b -= 1
            b >>= 1
        if a == b:
            s = self.op(s, self.st[a])
        return s

    def _query_topdown(self, a, b, k, l, r):
        """区間[a, b) に対する累積操作
        k: 着目しているノード (1-indexed)
        l: 探索区間 st[l, r) の左端 (0-indexed)
        r: 探索区間 st[l, r) の右端 (0-indexed)
        """
        if r <= a or b <= l:
            return self.init_value
        if a <= l and r <= b:
            return self.st[k]
        mid = (l + r) // 2
        lv = self._query_topdown(a, b, k * 2, l, mid)
        rv = self._query_topdown(a, b, k * 2 + 1, mid, r)
        return self.op(lv, rv)

    def query(self, a, b):
        """区間[a, b) に対する累積操作"""
        if a > b:
            raise ValueError("a must be less than equal b.")
        return self._query_topdown(a, b, k=1, l=0, r=len(self.st)//2)
        # return self._query_bottomup(a, b) SegmentTree def __init__(self, size, op=min, init_value=10**8):
        """初期化"""
        self.size = size
        self.op = op
        self.init_value = init_value
        n = 2 ** ((size-1).bit_length())
        treesize = n * 2
        st = [init_value for i in range(treesize)]
        self.st = st

     __init__ """初期化""" self.size = size self.size self size size self.op = op self.op self op op self.init_value = init_value self.init_value self init_value init_value n = 2 ** ((size-1).bit_length()) n 2 ** ((size-1).bit_length()) 2 (size-1).bit_length() size-1).bit_length size-1 size 1 bit_length treesize = n * 2 treesize n * 2 n 2 init_value for i in range(treesize) for i in range(treesize) i range(treesize) range treesize for i in range(treesize) init_value st = [init_value for i in range(treesize)] st [init_value for i in range(treesize)] self.st = st self.st self st st self self size size op=min op min init_value=10**8 init_value 10**8 10 8 def from_array(cls, a, op=min, init_value=10**8):
        st = cls(len(a), op=op, init_value=init_value)
        for i, x in enumerate(a):
            st.update(i, x)
        return st

     from_array st = cls(len(a), op=op, init_value=init_value) st cls(len(a), op=op, init_value=init_value) cls len(a) len a op=op op op init_value=init_value init_value init_value for i, x in enumerate(a):
            st.update(i, x)
         i x enumerate(a) enumerate a st.update(i, x) st.update st update i x return st st cls cls a a op=min op min init_value=10**8 init_value 10**8 10 8 @classmethod
     from_array classmethod from_array def update(self, key, value):
        """値の更新"""
        offset = len(self.st) // 2
        k = offset + key
        self.st[k] = value
        k >>= 1
        while k > 0:
            self.st[k] = self.op(self.st[k * 2], self.st[k * 2 + 1])
            k >>= 1

     update """値の更新""" offset = len(self.st) // 2 offset len(self.st) // 2 len(self.st) len self.st self st 2 k = offset + key k offset + key offset key self.st[k] = value self.st[k] self.st self st k value k >>= 1 k 1 while k > 0:
            self.st[k] = self.op(self.st[k * 2], self.st[k * 2 + 1])
            k >>= 1

     k > 0 k 0 self.st[k] = self.op(self.st[k * 2], self.st[k * 2 + 1]) self.st[k] self.st self st k self.op(self.st[k * 2], self.st[k * 2 + 1]) self.op self op self.st[k * 2] self.st self st k * 2 k 2 self.st[k * 2 + 1] self.st self st k * 2 + 1 k * 2 k 2 1 k >>= 1 k 1 self self key key value value def _query_bottomup(self, a, b):
        """区間[a, b) に対する累積操作
        """
        offset = len(self.st) // 2
        a += offset
        b += offset - 1
        s = self.init_value
        while a < b:
            if a & 1 == 1:
                s = self.op(s, self.st[a])
                a += 1
            a >>= 1
            if b & 1 == 0:
                s = self.op(s, self.st[b])
                b -= 1
            b >>= 1
        if a == b:
            s = self.op(s, self.st[a])
        return s

     _query_bottomup """区間[a, b) に対する累積操作
        """ offset = len(self.st) // 2 offset len(self.st) // 2 len(self.st) len self.st self st 2 a += offset a offset b += offset - 1 b offset - 1 offset 1 s = self.init_value s self.init_value self init_value while a < b:
            if a & 1 == 1:
                s = self.op(s, self.st[a])
                a += 1
            a >>= 1
            if b & 1 == 0:
                s = self.op(s, self.st[b])
                b -= 1
            b >>= 1
         a < b a b if a & 1 == 1:
                s = self.op(s, self.st[a])
                a += 1
             a & 1 == 1 a & 1 a 1 1 s = self.op(s, self.st[a]) s self.op(s, self.st[a]) self.op self op s self.st[a] self.st self st a a += 1 a 1 a >>= 1 a 1 if b & 1 == 0:
                s = self.op(s, self.st[b])
                b -= 1
             b & 1 == 0 b & 1 b 1 0 s = self.op(s, self.st[b]) s self.op(s, self.st[b]) self.op self op s self.st[b] self.st self st b b -= 1 b 1 b >>= 1 b 1 if a == b:
            s = self.op(s, self.st[a])
         a == b a b s = self.op(s, self.st[a]) s self.op(s, self.st[a]) self.op self op s self.st[a] self.st self st a return s s self self a a b b def _query_topdown(self, a, b, k, l, r):
        """区間[a, b) に対する累積操作
        k: 着目しているノード (1-indexed)
        l: 探索区間 st[l, r) の左端 (0-indexed)
        r: 探索区間 st[l, r) の右端 (0-indexed)
        """
        if r <= a or b <= l:
            return self.init_value
        if a <= l and r <= b:
            return self.st[k]
        mid = (l + r) // 2
        lv = self._query_topdown(a, b, k * 2, l, mid)
        rv = self._query_topdown(a, b, k * 2 + 1, mid, r)
        return self.op(lv, rv)

     _query_topdown """区間[a, b) に対する累積操作
        k: 着目しているノード (1-indexed)
        l: 探索区間 st[l, r) の左端 (0-indexed)
        r: 探索区間 st[l, r) の右端 (0-indexed)
        """ if r <= a or b <= l:
            return self.init_value
         r <= a or b <= l r <= a r a b <= l b l return self.init_value self.init_value self init_value if a <= l and r <= b:
            return self.st[k]
         a <= l and r <= b a <= l a l r <= b r b return self.st[k] self.st[k] self.st self st k mid = (l + r) // 2 mid (l + r) // 2 l + r l r 2 lv = self._query_topdown(a, b, k * 2, l, mid) lv self._query_topdown(a, b, k * 2, l, mid) self._query_topdown self _query_topdown a b k * 2 k 2 l mid rv = self._query_topdown(a, b, k * 2 + 1, mid, r) rv self._query_topdown(a, b, k * 2 + 1, mid, r) self._query_topdown self _query_topdown a b k * 2 + 1 k * 2 k 2 1 mid r return self.op(lv, rv) self.op(lv, rv) self.op self op lv rv self self a a b b k k l l r r def query(self, a, b):
        """区間[a, b) に対する累積操作"""
        if a > b:
            raise ValueError("a must be less than equal b.")
        return self._query_topdown(a, b, k=1, l=0, r=len(self.st)//2)
        # return self._query_bottomup(a, b) query """区間[a, b) に対する累積操作""" if a > b:
            raise ValueError("a must be less than equal b.")
         a > b a b raise ValueError("a must be less than equal b.") ValueError("a must be less than equal b.") ValueError "a must be less than equal b." return self._query_topdown(a, b, k=1, l=0, r=len(self.st)//2) self._query_topdown(a, b, k=1, l=0, r=len(self.st)//2) self._query_topdown self _query_topdown a b k=1 k 1 l=0 l 0 r=len(self.st)//2 r len(self.st)//2 len(self.st) len self.st self st 2 self self a a b b def solve_online(N, S, Q):
    tree = SegmentTree(N, op=or_, init_value=0)
    C = [ord(s) - ord("a") for s in S]
    for i in range(N):
        c = ord(S[i]) - ord("a")
        tree.update(i, 1 << c)

    for _ in range(Q):
        op, a, b = input().strip().split()
        if op == "1":
            i, c = int(a)-1, ord(b) - ord("a")
            tree.update(i, 1 << c)
        elif op == "2":
            l, r = int(a)-1, int(b)-1
            b = tree.query(l, r+1)
            s = 0
            while b > 0:
                if b & 1 == 1:
                    s += 1
                b >>= 1
            print(s) solve_online tree = SegmentTree(N, op=or_, init_value=0) tree SegmentTree(N, op=or_, init_value=0) SegmentTree N op=or_ op or_ init_value=0 init_value 0 ord(s) - ord("a") for s in S for s in S s S for s in S ord(s) - ord("a") ord(s) ord s ord("a") ord "a" C = [ord(s) - ord("a") for s in S] C [ord(s) - ord("a") for s in S] for i in range(N):
        c = ord(S[i]) - ord("a")
        tree.update(i, 1 << c)

     i range(N) range N c = ord(S[i]) - ord("a") c ord(S[i]) - ord("a") ord(S[i]) ord S[i] S i ord("a") ord "a" tree.update(i, 1 << c) tree.update tree update i 1 << c 1 c for _ in range(Q):
        op, a, b = input().strip().split()
        if op == "1":
            i, c = int(a)-1, ord(b) - ord("a")
            tree.update(i, 1 << c)
        elif op == "2":
            l, r = int(a)-1, int(b)-1
            b = tree.query(l, r+1)
            s = 0
            while b > 0:
                if b & 1 == 1:
                    s += 1
                b >>= 1
            print(s) _ range(Q) range Q op, a, b = input().strip().split() op input().strip().split() ().strip().split ().strip() ().strip () input strip split a b if op == "1":
            i, c = int(a)-1, ord(b) - ord("a")
            tree.update(i, 1 << c)
        elif op == "2":
            l, r = int(a)-1, int(b)-1
            b = tree.query(l, r+1)
            s = 0
            while b > 0:
                if b & 1 == 1:
                    s += 1
                b >>= 1
            print(s) op == "1" op "1" i, c = int(a)-1, ord(b) - ord("a") i int(a)-1 int(a) int a 1 c ord(b) - ord("a") ord(b) ord b ord("a") ord "a" tree.update(i, 1 << c) tree.update tree update i 1 << c 1 c elif op == "2":
            l, r = int(a)-1, int(b)-1
            b = tree.query(l, r+1)
            s = 0
            while b > 0:
                if b & 1 == 1:
                    s += 1
                b >>= 1
            print(s) op == "2" op "2" l, r = int(a)-1, int(b)-1 l int(a)-1 int(a) int a 1 r int(b)-1 int(b) int b 1 b = tree.query(l, r+1) b tree.query(l, r+1) tree.query tree query l r+1 r 1 s = 0 s 0 while b > 0:
                if b & 1 == 1:
                    s += 1
                b >>= 1
             b > 0 b 0 if b & 1 == 1:
                    s += 1
                 b & 1 == 1 b & 1 b 1 1 s += 1 s 1 b >>= 1 b 1 print(s) print s N N S S Q Q if __name__ == '__main__':
    inputs = read()
    outputs = solve_online(*inputs)
    if outputs is not None:
        print("%s" % str(outputs)) __name__ == '__main__' __name__ '__main__' inputs = read() inputs read() read outputs = solve_online(*inputs) outputs solve_online(*inputs) solve_online *inputs inputs if outputs is not None:
        print("%s" % str(outputs)) outputs is not None outputs None print("%s" % str(outputs)) print "%s" % str(outputs) "%s" str(outputs) str outputs def solve_online(N, S, Q):
    tree = SegmentTree(N, op=or_, init_value=0)
    C = [ord(s) - ord("a") for s in S]
    for i in range(N):
        c = ord(S[i]) - ord("a")
        tree.update(i, 1 << c)

    for _ in range(Q):
        op, a, b = input().strip().split()
        if op == "1":
            i, c = int(a)-1, ord(b) - ord("a")
            tree.update(i, 1 << c)
        elif op == "2":
            l, r = int(a)-1, int(b)-1
            b = tree.query(l, r+1)
            s = 0
            while b > 0:
                if b & 1 == 1:
                    s += 1
                b >>= 1
            print(s) def solve_online(N, S, Q):
    tree = SegmentTree(N, op=or_, init_value=0)
    C = [ord(s) - ord("a") for s in S]
    for i in range(N):
        c = ord(S[i]) - ord("a")
        tree.update(i, 1 << c)

    for _ in range(Q):
        op, a, b = input().strip().split()
        if op == "1":
            i, c = int(a)-1, ord(b) - ord("a")
            tree.update(i, 1 << c)
        elif op == "2":
            l, r = int(a)-1, int(b)-1
            b = tree.query(l, r+1)
            s = 0
            while b > 0:
                if b & 1 == 1:
                    s += 1
                b >>= 1
            print(s) solve_online class SegmentTree():
    
    def __init__(self, size, op=min, init_value=10**8):
        """初期化"""
        self.size = size
        self.op = op
        self.init_value = init_value
        n = 2 ** ((size-1).bit_length())
        treesize = n * 2
        st = [init_value for i in range(treesize)]
        self.st = st

    @classmethod
    def from_array(cls, a, op=min, init_value=10**8):
        st = cls(len(a), op=op, init_value=init_value)
        for i, x in enumerate(a):
            st.update(i, x)
        return st

    def update(self, key, value):
        """値の更新"""
        offset = len(self.st) // 2
        k = offset + key
        self.st[k] = value
        k >>= 1
        while k > 0:
            self.st[k] = self.op(self.st[k * 2], self.st[k * 2 + 1])
            k >>= 1

    def _query_bottomup(self, a, b):
        """区間[a, b) に対する累積操作
        """
        offset = len(self.st) // 2
        a += offset
        b += offset - 1
        s = self.init_value
        while a < b:
            if a & 1 == 1:
                s = self.op(s, self.st[a])
                a += 1
            a >>= 1
            if b & 1 == 0:
                s = self.op(s, self.st[b])
                b -= 1
            b >>= 1
        if a == b:
            s = self.op(s, self.st[a])
        return s

    def _query_topdown(self, a, b, k, l, r):
        """区間[a, b) に対する累積操作
        k: 着目しているノード (1-indexed)
        l: 探索区間 st[l, r) の左端 (0-indexed)
        r: 探索区間 st[l, r) の右端 (0-indexed)
        """
        if r <= a or b <= l:
            return self.init_value
        if a <= l and r <= b:
            return self.st[k]
        mid = (l + r) // 2
        lv = self._query_topdown(a, b, k * 2, l, mid)
        rv = self._query_topdown(a, b, k * 2 + 1, mid, r)
        return self.op(lv, rv)

    def query(self, a, b):
        """区間[a, b) に対する累積操作"""
        if a > b:
            raise ValueError("a must be less than equal b.")
        return self._query_topdown(a, b, k=1, l=0, r=len(self.st)//2)
        # return self._query_bottomup(a, b) class SegmentTree():
    
    def __init__(self, size, op=min, init_value=10**8):
        """初期化"""
        self.size = size
        self.op = op
        self.init_value = init_value
        n = 2 ** ((size-1).bit_length())
        treesize = n * 2
        st = [init_value for i in range(treesize)]
        self.st = st

    @classmethod
    def from_array(cls, a, op=min, init_value=10**8):
        st = cls(len(a), op=op, init_value=init_value)
        for i, x in enumerate(a):
            st.update(i, x)
        return st

    def update(self, key, value):
        """値の更新"""
        offset = len(self.st) // 2
        k = offset + key
        self.st[k] = value
        k >>= 1
        while k > 0:
            self.st[k] = self.op(self.st[k * 2], self.st[k * 2 + 1])
            k >>= 1

    def _query_bottomup(self, a, b):
        """区間[a, b) に対する累積操作
        """
        offset = len(self.st) // 2
        a += offset
        b += offset - 1
        s = self.init_value
        while a < b:
            if a & 1 == 1:
                s = self.op(s, self.st[a])
                a += 1
            a >>= 1
            if b & 1 == 0:
                s = self.op(s, self.st[b])
                b -= 1
            b >>= 1
        if a == b:
            s = self.op(s, self.st[a])
        return s

    def _query_topdown(self, a, b, k, l, r):
        """区間[a, b) に対する累積操作
        k: 着目しているノード (1-indexed)
        l: 探索区間 st[l, r) の左端 (0-indexed)
        r: 探索区間 st[l, r) の右端 (0-indexed)
        """
        if r <= a or b <= l:
            return self.init_value
        if a <= l and r <= b:
            return self.st[k]
        mid = (l + r) // 2
        lv = self._query_topdown(a, b, k * 2, l, mid)
        rv = self._query_topdown(a, b, k * 2 + 1, mid, r)
        return self.op(lv, rv)

    def query(self, a, b):
        """区間[a, b) に対する累積操作"""
        if a > b:
            raise ValueError("a must be less than equal b.")
        return self._query_topdown(a, b, k=1, l=0, r=len(self.st)//2)
        # return self._query_bottomup(a, b) SegmentTree outputs = solve_online(*inputs) solve_online(*inputs) outputs def read():
    N = int(input().strip())
    S = input().strip()
    Q = int(input().strip())
    return N, S, Q def read():
    N = int(input().strip())
    S = input().strip()
    Q = int(input().strip())
    return N, S, Q read input = sys.stdin.readline sys.stdin.readline input inputs = read() read() inputs
import sys
input = sys.stdin.readline
from operator import or_


def read():
    N = int(input().strip())
    S = input().strip()
    Q = int(input().strip())
    return N, S, Q


class SegmentTree():
    
    def __init__(self, size, op=min, init_value=10**8):
        """初期化"""
        self.size = size
        self.op = op
        self.init_value = init_value
        n = 2 ** ((size-1).bit_length())
        treesize = n * 2
        st = [init_value for i in range(treesize)]
        self.st = st

    @classmethod
    def from_array(cls, a, op=min, init_value=10**8):
        st = cls(len(a), op=op, init_value=init_value)
        for i, x in enumerate(a):
            st.update(i, x)
        return st

    def update(self, key, value):
        """値の更新"""
        offset = len(self.st) // 2
        k = offset + key
        self.st[k] = value
        k >>= 1
        while k > 0:
            self.st[k] = self.op(self.st[k * 2], self.st[k * 2 + 1])
            k >>= 1

    def _query_bottomup(self, a, b):
        """区間[a, b) に対する累積操作
        """
        offset = len(self.st) // 2
        a += offset
        b += offset - 1
        s = self.init_value
        while a < b:
            if a & 1 == 1:
                s = self.op(s, self.st[a])
                a += 1
            a >>= 1
            if b & 1 == 0:
                s = self.op(s, self.st[b])
                b -= 1
            b >>= 1
        if a == b:
            s = self.op(s, self.st[a])
        return s

    def _query_topdown(self, a, b, k, l, r):
        """区間[a, b) に対する累積操作
        k: 着目しているノード (1-indexed)
        l: 探索区間 st[l, r) の左端 (0-indexed)
        r: 探索区間 st[l, r) の右端 (0-indexed)
        """
        if r <= a or b <= l:
            return self.init_value
        if a <= l and r <= b:
            return self.st[k]
        mid = (l + r) // 2
        lv = self._query_topdown(a, b, k * 2, l, mid)
        rv = self._query_topdown(a, b, k * 2 + 1, mid, r)
        return self.op(lv, rv)

    def query(self, a, b):
        """区間[a, b) に対する累積操作"""
        if a > b:
            raise ValueError("a must be less than equal b.")
        return self._query_topdown(a, b, k=1, l=0, r=len(self.st)//2)
        # return self._query_bottomup(a, b)


def solve_online(N, S, Q):
    tree = SegmentTree(N, op=or_, init_value=0)
    C = [ord(s) - ord("a") for s in S]
    for i in range(N):
        c = ord(S[i]) - ord("a")
        tree.update(i, 1 << c)

    for _ in range(Q):
        op, a, b = input().strip().split()
        if op == "1":
            i, c = int(a)-1, ord(b) - ord("a")
            tree.update(i, 1 << c)
        elif op == "2":
            l, r = int(a)-1, int(b)-1
            b = tree.query(l, r+1)
            s = 0
            while b > 0:
                if b & 1 == 1:
                    s += 1
                b >>= 1
            print(s)


if __name__ == '__main__':
    inputs = read()
    outputs = solve_online(*inputs)
    if outputs is not None:
        print("%s" % str(outputs))
