#include <cassert>
#include <cmath>
#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <functional>
#include <iostream>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>

using namespace std;

using Int = long long;

template <class T1, class T2> ostream &operator<<(ostream &os, const pair<T1, T2> &a) { return os << "(" << a.first << ", " << a.second << ")"; };
template <class T> ostream &operator<<(ostream &os, const vector<T> &as) { const int sz = as.size(); os << "["; for (int i = 0; i < sz; ++i) { if (i >= 256) { os << ", ..."; break; } if (i > 0) { os << ", "; } os << as[i]; } return os << "]"; }
template <class T> void pv(T a, T b) { for (T i = a; i != b; ++i) cerr << *i << " "; cerr << endl; }
template <class T> bool chmin(T &t, const T &f) { if (t > f) { t = f; return true; } return false; }
template <class T> bool chmax(T &t, const T &f) { if (t < f) { t = f; return true; } return false; }
#define COLOR(s) ("\x1b[" s "m")


// |as| = n ==> |rs| = 2 n + 1
// [i - rs[i], i + rs[i]] is palindrome for $ as[0] $ as[1] $ ... $ as[n-1] $
// as[i, j): palindrome <=> j - i <= rs[i + j]
template <class String> vector<int> manacher(const String &as) {
  const int n = as.size();
  vector<int> rs(2 * n + 1);
  for (int i = 0, j = 0, k; i <= 2 * n; i += k, j -= k) {
    for (; 0 < i - j && i + j < 2 * n &&
           (!((i + j + 1) & 1) || as[(i - j - 1) >> 1] == as[(i + j + 1) >> 1]);
         ++j) {}
    rs[i] = j;
    for (k = 1; k < j && k + rs[i - k] < j; ++k) rs[i + k] = rs[i - k];
  }
  return rs;
}


// point add, rectangle sum
constexpr int INF = 1001001001;
template <class X, class Y, class T> struct Bit2d {
  vector<X> xs;
  vector<pair<Y, X>> yxs;
  vector<vector<Y>> yss;
  int m;
  vector<int> ns;
  vector<vector<T>> bit;
  Bit2d() {}
  void book(X x, Y y) {
    xs.push_back(x);
    yxs.emplace_back(y, x);
  }
  void build() {
    sort(xs.begin(), xs.end());
    xs.erase(unique(xs.begin(), xs.end()), xs.end());
    m = xs.size();
    yss.assign(m, {});
    sort(yxs.begin(), yxs.end());
    for (const auto &yx : yxs) {
      const int x = yx.second, y = yx.first;
      const int a = lower_bound(xs.begin(), xs.end(), x) - xs.begin();
      assert(a < m); assert(xs[a] == x);
      for (int u = a; u < m; u |= u + 1) yss[u].push_back(y);
    }
    ns.assign(m, 0);
    bit.assign(m, {});
    for (int u = 0; u < m; ++u) {
      yss[u].erase(unique(yss[u].begin(), yss[u].end()), yss[u].end());
      ns[u] = yss[u].size();
      bit[u].assign(ns[u], 0);
    }
  }
  void add(int x, int y, T val) {
    const int a = lower_bound(xs.begin(), xs.end(), x) - xs.begin();
    assert(a < m); assert(xs[a] == x);
    for (int u = a; u < m; u |= u + 1) {
      const int b = lower_bound(yss[u].begin(), yss[u].end(), y) - yss[u].begin();
      assert(b < ns[u]); assert(yss[u][b] == y);
      for (int v = b; v < ns[u]; v |= v + 1) bit[u][v] += val;
    }
  }
  T get(int x0, int x1, int y0, int y1) const {
    const int a0 = lower_bound(xs.begin(), xs.end(), x0) - xs.begin();
    const int a1 = lower_bound(xs.begin(), xs.end(), x1) - xs.begin();
    T ret = 0;
    for (int u = a0; u; u &= u - 1) ret -= get(u - 1, y0, y1);
    for (int u = a1; u; u &= u - 1) ret += get(u - 1, y0, y1);
    return ret;
  }
 private:
  T get(int u, int y0, int y1) const {
    T ret = 0;
    const int b0 = lower_bound(yss[u].begin(), yss[u].end(), y0) - yss[u].begin();
    const int b1 = lower_bound(yss[u].begin(), yss[u].end(), y1) - yss[u].begin();
    for (int v = b0; v; v &= v - 1) ret -= bit[u][v - 1];
    for (int v = b1; v; v &= v - 1) ret += bit[u][v - 1];
    return ret;
  }
};


char S[200'010];
int N, Q;
vector<int> O, I, L, R;
vector<char> C;


namespace brute {
vector<int> run() {
cerr<<"[brute::run]"<<endl;
  string s = S;
  vector<int> anss;
  int lastans = 0;
  for (int q = 0; q < Q; ++q) {
    if (O[q] == 1) {
      const int i = (I[q] ^ lastans) - 1;
      s[i] = C[q];
    } else {
      const int l = (L[q] ^ lastans) - 1;
      const int r = R[q] ^ lastans;
      const auto rs = manacher(s);
      int ans = 0;
      for (int i = l; i < r; ++i) if (rs[i + r] >= r - i) {
        ++ans;
      }
      anss.push_back(ans);
      lastans = ans;
    }
  }
  return anss;
}
}  // brute


namespace sub2 {
vector<int> run() {
cerr<<"[sub2::run]"<<endl;
  const auto rs = manacher(string(S));
  Bit2d<int, int, int> bit;
  for (int i = 0; i <= 2 * N; ++i) bit.book(i, rs[i] + i);
  bit.build();
  for (int i = 0; i <= 2 * N; ++i) bit.add(i, rs[i] + i, 1);
  vector<int> anss;
  int lastans = 0;
  for (int q = 0; q < Q; ++q) {
    const int l = (L[q] ^ lastans) - 1;
    const int r = R[q] ^ lastans;
    /*
      l <= i < r && rs[i + r] >= r - i
      l + r <= j < 2 r && rs[j] + j >= 2 r
    */
    const int ans = bit.get(l + r, 2 * r, 2 * r, 3 * N);
    anss.push_back(ans);
    lastans = ans;
  }
  return anss;
}
}  // sub2


int main() {
  for (; ~scanf("%s", S); ) {
    N = strlen(S);
    scanf("%d", &Q);
    O.resize(Q, -1);
    I.resize(Q, -1);
    C.resize(Q, '?');
    L.resize(Q, -1);
    R.resize(Q, -1);
    for (int q = 0; q < Q; ++q) {
      scanf("%d", &O[q]);
      if (O[q] == 1) {
        scanf("%d %c", &I[q], &C[q]);
      } else {
        scanf("%d%d", &L[q], &R[q]);
      }
    }
    
    vector<int> anss;
    if (O == vector<int>(Q, 2)) {
      anss = sub2::run();
    } else if (N <= 5000 && Q <= 5000) {
      anss = brute::run();
    }
    for (const int ans : anss) {
      printf("%d\n", ans);
    }
  }
  return 0;
}