#include <bits/stdc++.h>
struct segment_tree {
  void build(std::string const &a) {
    t.resize(4 * a.size());
    build(0, 0, a.size(), a);
  }
  void update(size_t pos, char new_value) {
    update(0, 0, t.size() / 4, pos, new_value);
  }
  int32_t get(size_t l, size_t r) {
    return get(0, 0, t.size() / 4, l, r + 1).size();
  }

 private:
  std::vector<std::set<char>> t;
  void build(size_t v, size_t l, size_t r, std::string const &a) {
    if (l + 1 == r) {
      std::set<char> m;
      m.insert(a[l]);
      t[v] = m;
    } else {
      size_t mid = (l + r) / 2;
      build(2 * v + 1, l, mid, a);
      build(2 * v + 2, mid, r, a);
      for (auto elem : t[2 * v + 1]) {
        t[v].insert(elem);
      }
      for (auto elem : t[2 * v + 2]) {
        t[v].insert(elem);
      }
    }
  }
  void update(size_t v, size_t l, size_t r, size_t pos, char new_value) {
    if (l + 1 == r) {
      std::set<char> m;
      m.insert(new_value);
      t[v] = m;
    } else {
      size_t mid = (l + r) / 2;
      if (pos < mid) {
        update(2 * v + 1, l, mid, pos, new_value);
      } else {
        update(2 * v + 2, mid, r, pos, new_value);
      }
      for (auto elem : t[2 * v + 1]) {
        t[v].insert(elem);
      }
      for (auto elem : t[2 * v + 2]) {
        t[v].insert(elem);
      }
    }
  }
  std::set<char> get(size_t v, size_t l, size_t r, size_t req_l, size_t req_r) {
    if (req_l >= req_r) {
      return std::set<char>();
    } else if (l == req_l && r == req_r) {
      return t[v];
    } else {
      size_t mid = (l + r) / 2;
      std::set<char> cur = get(2 * v + 1, l, mid, req_l, std::min(mid, req_r));
      for (auto elem : get(2 * v + 2, mid, r, std::max(mid, req_l), req_r)) {
        cur.insert(elem);
      }
      return cur;
    }
  }
};
int main() {
  std::ios_base::sync_with_stdio(false);
  segment_tree chr;
  size_t n;
  char current_n;
  std::cin >> n >> current_n;
  std::string a;
  std::cin >> a;
  chr.build(a);
  size_t k;
  std::cin >> k;
  while (k-- > 0) {
    size_t type;
    std::cin >> type;
    if (type == 1) {
      size_t pos;
      char ch;
      std::cin >> pos >> ch;
      chr.update(pos - 1, ch);
    } else {
      size_t l, r;
      std::cin >> l >> r;
      std::cout << chr.get(l - 1, r - 1) << '\n';
    }
  }
  return 0;
}
