#include <bits/stdc++.h>
#define reg register
#define ll long long
#define maxn 500010
#define maxm 100010
#define inf (1<<30)
int read() {
    reg int s = 0, f = 1;
    reg char ch;

    for (; (ch = getchar()) < '0' || ch > '9'; ch == '-' ? f = -f : 0);

    for (; ch >= '0' && ch <= '9'; s = s * 10 + ch - '0', ch = getchar());

    return s * f;
}
void write(reg ll x) {
    x < 0 ? x = -x, putchar('-') : 0, x > 9 ? write(x / 10) : void(), putchar(x % 10 + '0');
}
int n, m, num, tim, N = 1, o = 1, dfn[maxn << 1], end[maxn << 1], sum[maxn << 3], f[maxn << 1];
ll ans[maxm];
char s[maxn << 1];
int max(reg int a, reg int b) {
    return a > b ? a : b;
}
int min(reg int a, reg int b) {
    return a < b ? a : b;
}
bool cmax(reg int &a, reg int b) {
    return a < b ? a = b, 1 : 0;
}
struct node {
    char *t;
    int n, l, r, id;
    bool operator<(reg node b)const {
        return r < b.r;
    }
} q[maxm];
struct SAM {
    int cnt, num, len[maxn << 1], link[maxn << 1], c[maxn << 1][26], first[maxn << 1], id[maxn << 1];
    struct edge {
        int next, to;
    } e[maxn * 3];
    void adde(reg int a, reg int b) {
        e[++num] = (edge) {first[a], b}, first[a] = num;
    }
    void build(reg char *s, reg int n) {
        link[0] = -1;

        for (reg int i = 1, x, y, p = 0, q, k; i <= n; p = x, ++i) {
            for (k = s[i] - 'a', len[id[i] = x = ++cnt] = len[p] + 1; ~p && !c[p][k]; p = link[p])
                c[p][k] = x;

            if (~p)
                if (len[q = c[p][k]] == len[p] + 1)
                    link[x] = q;
                else {
                    len[y = ++cnt] = len[p] + 1, link[y] = link[q], memcpy(c[y], c[q], 26 * sizeof(int));

                    for (link[x] = link[q] = y; ~p && c[p][k] == q; p = link[p])
                        c[p][k] = y;
                } else
                link[x] = 0;
        }
    }
} S, T;
void dfs1(reg int x) {
    dfn[x] = ++tim;

    for (reg int i = S.first[x]; i; i = S.e[i].next)
        dfs1(S.e[i].to);

    end[x] = tim;
}
void add(reg int x, reg int v) {
    for (x += N; x; x >>= 1)
        cmax(sum[x], v);
}
int query(reg int l, reg int r) {
    reg int ans = 0;

    for (l += N - 1, r += N + 1; l ^ r ^ 1; l >>= 1, r >>= 1)
        ~l & 1 ? cmax(ans, sum[l ^ 1]) : 0, r & 1 ? cmax(ans, sum[r ^ 1]) : 0;

    return ans;
}
void dfs2(reg int x) {
    for (reg int i = T.first[x], y; i; i = T.e[i].next)
        dfs2(y = T.e[i].to), f[x] = f[y];

    ans[q[o].id] += max(0, T.len[x] - max(T.len[T.link[x]], f[x]));
}
int main() {
            scanf("%s", s + 1), n = strlen(s + 1), S.build(s, n);

    for (reg int i = 1; i <= S.cnt; ++i)
        S.adde(S.link[i], i);

    dfs1(0), m = read();

    for (reg int i = 1, l = 1; i <= m; ++i)
        scanf("%s", s + l), q[i] = (node) {s + l - 1, strlen(s + l), read(), read(), i}, l += q[i].n;
    std::sort(q + 1, q + m + 1);

    for (; N <= tim + 1; N <<= 1);

    for (reg int i = 1; i <= n; ++i)
        for (add(dfn[S.id[i]], i); q[o].r == i; ++o) {
            for (reg int j = 0; j <= T.cnt; ++j)
                memset(T.c[j], 0, 26 * sizeof(int));

            memset(T.first, 0, (T.cnt + 1)*sizeof(int)), T.cnt = T.num = f[0] = 0, T.build(q[o].t, q[o].n);

            for (reg int j = 1; j <= T.cnt; ++j)
                T.adde(T.link[j], j);

            for (reg int j = 1, p = f[0] = 0, k, l, now; j <= q[o].n; ++j) {
                if (S.c[p][k = q[o].t[j] - 'a'])
                    l = f[T.id[j - 1]] + 1;
                else {
                    for (; ~p && !S.c[p][k]; p = S.link[p])
                        ;

                    l = S.len[p] + 1;
                }

                if (!(p = S.c[p][k])) {
                    f[T.id[j]] = 0;
                    continue;
                }

                if ((now = query(dfn[p], end[p])) - q[o].l + 1 >= l) {
                    f[T.id[j]] = l;
                    continue;
                }

                for (; p && (now = query(dfn[p], end[p])) - q[o].l < S.len[S.link[p]]; p = S.link[p]);

                f[T.id[j]] = p ? min(S.len[p], now - q[o].l + 1) : 0;
            }

            dfs2(0);
        }

    for (reg int i = 1; i <= m; ++i)
        write(ans[i]), puts("");

    return 0;
}