#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <cmath>
#include <ctime>
#include <cctype>

#include <algorithm>
#include <random>
#include <bitset>
#include <queue>
#include <functional>
#include <set>
#include <map>
#include <vector>
#include <chrono>
#include <iostream>
#include <limits>
#include <numeric>

#define LOG(FMT...) fprintf(stderr, FMT)

using namespace std;

typedef long long ll;
typedef unsigned long long ull;

// mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());

template<class T>
istream &operator>>(istream &is, vector<T> &v) {
  for (T &x : v)
    is >> x;
  return is;
}

template<class T>
ostream &operator<<(ostream &os, const vector<T> &v) {
  if (!v.empty()) {
    os << v.front();
    for (int i = 1; i < v.size(); ++i)
      os << ' ' << v[i];
  }
  return os;
}

const int N = 500010;
const int TOTN = 1500010, A = 26;

namespace SAM {

  int len[TOTN * 2], fail[TOTN * 2], ch[TOTN * 2][A];

  int top;

  int extend(int root, int o, int c) {
    int p = ++top;

    len[p] = len[o] + 1;
    while (o && !ch[o][c]) {
      ch[o][c] = p;
      o = fail[o];
    }
    if (!o) {
      fail[p] = root;
    } else {
      int q = ch[o][c];
      if (len[q] == len[o] + 1) {
        fail[p] = q;
      } else {
        int nq = ++top;
        memcpy(ch[nq], ch[q], sizeof(int) * A);
        len[nq] = len[o] + 1;
        fail[nq] = fail[q];
        fail[p] = fail[q] = nq;
        while (ch[o][c] == q) {
          ch[o][c] = nq;
          o = fail[o];
        }
      }
    }
    return p;
  }

}

namespace SEG {

  struct Node {
    int v, ls, rs;
  } P[N * 25];

  int top;

  int build(int l, int r) {
    int o = ++top;
    if (l == r) return o;
    int mid = (l + r) >> 1;
    P[o].ls = build(l, mid);
    P[o].rs = build(mid + 1, r);
    return o;
  }

  int change(int o, int l, int r, int k, int x) {
    int p = ++top;
    memcpy(P + p, P + o, sizeof(Node));
    P[p].v = x;
    if (l == r) return p;
    int mid = (l + r) >> 1;
    if (k <= mid) P[p].ls = change(P[p].ls, l, mid, k, x);
    else P[p].rs = change(P[p].rs, mid + 1, r, k, x);
    return p;
  }

  int query(int o, int l, int r, int ql, int qr) {
    if (l == ql && r == qr) return P[o].v;
    int mid = (l + r) >> 1;
    if (qr <= mid) return query(P[o].ls, l, mid, ql, qr);
    if (ql > mid) return query(P[o].rs, mid + 1, r, ql, qr);
    return max(query(P[o].ls, l, mid, ql, mid), query(P[o].rs, mid + 1, r, mid + 1, qr));
  }

}

int n;
char s[N], t[N];

int lc[N], cl[N], nod[N];
bool vis[TOTN * 2];

int pseg[N], dfn[N * 2], dfnr[N * 2];
int rev[N * 2], pos[N * 2];
vector<int> g[N * 2];

void dfs(int u) {
  static int t;
  dfn[u] = t + 1;
  if (pos[u]) rev[pos[u]] = ++t;
  for (int v : g[u])
    dfs(v);
  dfnr[u] = t;
}

int query(int o, int l, int r) {
  int dep = SEG::query(pseg[r], 1, n, dfn[o], dfnr[o]);
  return dep - (l - 1);
}

int main() {
#ifdef ELEGIA
  freopen("test.in", "r", stdin);
  int nol_cl = clock();
#endif
  ios::sync_with_stdio(false);
  cin.tie(nullptr);

  cin >> (s + 1);
  n = strlen(s + 1);
  int sroot = ++SAM::top;
  {
    int o = sroot;
    for (int i = 1; i <= n; ++i) {
      o = SAM::extend(sroot, o, s[i] - 'a');
      nod[i] = o;
      pos[o] = i;
    }
  }
  int send = SAM::top;

  for (int i = sroot + 1; i <= send; ++i)
    g[SAM::fail[i]].push_back(i);
  dfs(sroot);

  pseg[0] = SEG::build(1, n);
  for (int i = 1; i <= n; ++i)
    pseg[i] = SEG::change(pseg[i - 1], 1, n, rev[i], i);

  int q;
  cin >> q;
  while (q--) {
    int l, r;
    cin >> (t + 1) >> l >> r;
    int m = strlen(t + 1);
    int troot = ++SAM::top;
    {
      int o = troot;
      for (int i = 1; i <= m; ++i) {
        o = SAM::extend(troot, o, t[i] - 'a');
      }
    }
    int tend = SAM::top;
    int o = sroot, clen = 0;
    for (int i = 1; i <= m; ++i) {
      while (o != sroot && !SAM::ch[o][t[i] - 'a']) {
        o = SAM::fail[o];
        clen = SAM::len[o];
      }
      if (SAM::ch[o][t[i] - 'a']) {
        o = SAM::ch[o][t[i] - 'a'];
        ++clen;
        while (true) {
          int cur = query(o, l, r);
          if (cur >= clen)
            break;
          if (cur > SAM::len[SAM::fail[o]]) {
            clen = cur;
            break;
          } else {
            o = SAM::fail[o];
            clen = SAM::len[o];
          }
        }
      }
      cl[i] = clen;
    }
    vis[troot] = true;
    ll ans = 0;
    o = troot;
    for (int i = 1; i <= m; ++i) {
      o = SAM::ch[o][t[i] - 'a'];
      int x = o;
      while (!vis[x]) {
        vis[x] = true;
        x = SAM::fail[x];
      }
      lc[i] = SAM::len[x];
      ans += max(i - max(cl[i], lc[i]), 0);
    }
    cout << ans << '\n';
  }

#ifdef ELEGIA
  LOG("Time: %dms\n", int ((clock()
          -nol_cl) / (double)CLOCKS_PER_SEC * 1000));
#endif
  return 0;
}