#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("Ofast")
typedef long long ll;
typedef long double ld;
#define sz(x) int32_t(x.size())
#define all(x) x.begin(),x.end()
#define pb push_back
#define F first
#define S second
const int N = 1e6+6e5+1e5+2;

struct SuffixArray {
    vector<int> sa, lcp;
    SuffixArray(string& s, int lim=256) {
        int n = s.size() + 1, k = 0, a, b;
        vector<int> x(s.begin(), s.end()), y(n), ws(max(n, lim));
        x.push_back(0), sa = lcp = y, iota(sa.begin(), sa.end(), 0);
        for (int j = 0, p = 0; p < n; j = max(1, j * 2), lim = p) {
            p = j, iota(y.begin(), y.end(), n - j);
            for (int i = 0; i < n; i++) {
                if (sa[i] >= j) {
                    y[p++] = sa[i] - j;
                }
            }
            fill(ws.begin(), ws.end(), 0);
            for (int i = 0; i < n; i++) {
                ws[x[i]]++;
            }
            for (int i = 1; i < lim; i++) {
                ws[i] += ws[i - 1];
            }
            for (int i = n; i--;) {
                sa[--ws[x[y[i]]]] = y[i];
            }
            swap(x, y), p = 1, x[sa[0]] = 0;
            for (int i = 1; i < n; i++) {
                a = sa[i - 1], b = sa[i], x[b] = (y[a] == y[b] && y[a + j] == y[b + j]) ? p - 1 : p++;
            }
        }
        for (int i = 0, j; i < n - 1; lcp[x[i++]] = k) {
            for (k && k--, j = sa[x[i] - 1];
                    s[i + k] == s[j + k]; k++){};
        }
    }
};

string s;
int q;
char smx = char('a'-1);
int cmn[N], id[N];

int mn[(1 << 21)], mx[(1 << 21)];

void upd_mn(int l, int r, int x, int i, int v) {
    mn[x] = min(mn[x], v);
    if (l == r)return;
    int m = (l + r) >> 1;
    if (i <= m)upd_mn(l, m, x*2+1, i, v);
    else upd_mn(m+1, r, x*2+2, i, v);
}

void upd_mx(int l, int r, int x, int i, int v) {
    mx[x] = max(mx[x], v);
    if (l == r)return;
    int m = (l + r) >> 1;
    if (i <= m)upd_mx(l, m, x*2+1, i, v);
    else upd_mx(m+1, r, x*2+2, i, v);
}

int get_mn(int li, int ri, int x, int l, int r) {
    if (li >= l && ri <= r)return mn[x];
    if (li > r || ri < l)return 1e9;
    int m = (li + ri) >> 1;
    return min(get_mn(li, m, x*2+1, l, r), get_mn(m+1, ri, x*2+2, l, r));
}

int get_mx(int li, int ri, int x, int l, int r) {
    if (li >= l && ri <= r)return mx[x];
    if (li > r || ri < l)return -1e9;
    int m = (li + ri) >> 1;
    return max(get_mx(li, m, x*2+1, l, r), get_mx(m+1, ri, x*2+2, l, r));
}

pair<int, int> rng[int(1e5)], rq[N];
int mini[N][21], lg[N];

int lcp(int i, int j) {
    if (i > j)swap(i, j);
    ++i;
    return min(mini[i][lg[j-i+1]], mini[j - (1 << lg[j-i+1]) + 1][lg[j-i+1]]);
}

bool cmp(int i, int j) {
    return (id[i] < id[j]);
}
int moxo[N];
int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr);
    for (int i = 0; i < (1 << 21); i++) {
        mn[i] = 1e9;
        mx[i] = -1e9;
        if (i < N) {
            lg[i] = __lg(i);
        }
    }
    cin >> s;
    int tmp = sz(s);
    cin >> q;
    for (int i = 0; i < q; i++) {
        string x;
        int l, r;
        cin >> x >> l >> r;
        --l, --r;
        s.push_back(smx);
        rng[i].F = sz(s);
        for (int j = 0; j < sz(x); j++) {
            rq[sz(s)] = {l, r};
            moxo[sz(s)] = min(r-l+1, sz(x)-j);
            s.push_back(x[j]);
        }
        rng[i].S = sz(s)-1;
    }
    SuffixArray sar(s);
    for (int i = 0; i <= sz(s); i++) {
        mini[i][0] = sar.lcp[i];
    }
    for (int j = 1; j < 21; j++) {
        for (int i = 0; i + (1 << j) - 1 <= sz(s); i++) {
            mini[i][j] = min(mini[i][j-1], mini[i + (1 << (j-1))][j-1]);
        }
    }
    for (int i = 0; i <= sz(s); i++) {
        int cur = sar.sa[i];
        id[cur] = i;
        if (cur == sz(s))continue;
        if (cur < tmp) {
            upd_mx(0, tmp-1, 0, cur, i);
        } else if (s[cur] != smx) {
            int l = cmn[cur]+1, r = moxo[cur];
            while (l <= r) {
                int m = (l + r) >> 1;
                int zz = get_mx(0, tmp-1, 0, rq[cur].F, rq[cur].S-m+1);
                if (zz != -1e9 && lcp(zz, i) >= m) {
                    cmn[cur] = m;
                    l = m+1;
                } else {
                    r = m-1;
                }
            }
        }
    }
    for (int i = sz(s); i >= 0; i--) {
        int cur = sar.sa[i];
        if (cur == sz(s))continue;
        if (cur < tmp) {
            upd_mn(0, tmp-1, 0, cur, i);
        } else if (s[cur] != smx) {
            int l = cmn[cur]+1, r = moxo[cur];
            while (l <= r) {
                int m = (l + r) >> 1;
                int zz = get_mn(0, tmp-1, 0, rq[cur].F, rq[cur].S-m+1);
                if (zz != 1e9 && lcp(zz, i) >= m) {
                    cmn[cur] = m;
                    l = m+1;
                } else {
                    r = m-1;
                }
            }
        }
    }
    for (int jj = 0; jj < q; jj++) {
        vector<int> v(rng[jj].S - rng[jj].F + 1);
        for (int i = 0; i < sz(v); i++) {
            v[i] = rng[jj].F + i;
        }
        sort(all(v), cmp);
        ll ans = 0;
        for (int i = 0; i < sz(v); i++) {
            int l = cmn[v[i]] + 1, r = rng[jj].S - v[i] + 1;
            if (l > r)continue;
            ans += r-l+1;
            if (i) {
                r = min(r, lcp(id[v[i-1]], id[v[i]]));
                if (l <= r)ans -= r-l+1;
            }
        }
        cout << ans << "\n";
    }
}