#include <bits/stdc++.h>
using namespace std;

const int MAXN = 202020;
const int MAXA = 26;

int n, q, k[MAXN], nn[MAXN];
string s; 
string t[MAXN]; 

struct aho_corasick {
    int go[MAXA][MAXN];
    int fail[MAXN];
    int par[MAXN], t[MAXN];
    int sz = 0;

    int new_node() {
        for (int i = 0; i < MAXA; i++) go[i][sz] = -1;
        return sz++;
    }   
    void init() {
        new_node();
    }
    void insert(string S, int qn) {
        int v = 0;
        for (char ch : S) {
            int c = ch - 'a';
            if (go[c][v] == -1) {
                go[c][v] = new_node();
                par[go[c][v]] = v;
                t[go[c][v]] = c;
            }
            v = go[c][v];
        }
        nn[qn] = v;
    }
    void build() {
        queue<int> q;
        q.push(0);
        while (!q.empty()) {
            int v = q.front(); q.pop();
            int c = t[v];
            int p = par[v];
            while (p != 0) {
                p = fail[p];
                if (go[c][p] != -1) {
                    fail[v] = go[c][p];
                    break;
                }
            }
            for (int i = 0; i < MAXA; i++)
                if (go[i][v] != -1) q.push(go[i][v]);
        }
    }
} t1;

vector<int> g[MAXN];

int ln[MAXN], rn[MAXN], dn;
void dfs(int v) {
    ln[v] = ++dn;
    for (int x : g[v]) {
        dfs(x);
    }
    rn[v] = dn;
}

struct seg {
    int tree[4 * MAXN];

    void init() {
        for (int i = 0; i < 4 * MAXN; i++) tree[i] = 0;
    }
    void update(int a, int v, int l, int r, int x) {
        if (l == r) {
            tree[x] += v; return;
        }
        int m = (l + r) / 2;
        if (a <= m) update(a, v, l, m, 2 * x);
        else update(a, v, m + 1, r, 2 * x + 1);
        tree[x] = tree[2 * x] + tree[2 * x + 1];
    }
    int query(int a, int b, int l, int r, int x) {
        if (b < l || a > r) return 0;
        if (a <= l && r <= b) return tree[x];
        int m = (l + r) / 2;
        return query(a, b, l, m, 2 * x) + query(a, b, m + 1, r, 2 * x + 1);
    }
} t2;

int L[MAXN], R[MAXN]; bool B[MAXN];
vector<int> qv[MAXN];

int main() {
    cin.tie(0); ios_base::sync_with_stdio(0);
    cin >> s; n = s.size();
    t1.init();
    cin >> q;
    for (int i = 0; i < q; i++) {
        cin >> t[i] >> k[i];
        t1.insert(t[i], i);
    }
    t1.build();

    for (int i = 1; i < t1.sz; i++) {
        g[t1.fail[i]].push_back(i);
    }
    dfs(0);

    int cnt = 0;
    for (int i = 0; i < q; i++) {
        L[i] = 0;
        R[i] = n;
        qv[(L[i] + R[i]) / 2].push_back(i);
        ++cnt;
    }
    while (cnt > 0) {
        int v = 0;
        for (int i = 0; i < n; i++) {
            int c = s[i] - 'a';
            while (t1.go[c][v] == -1) {
                if (v == 0) break;
                v = t1.fail[v];
            }
            if (t1.go[c][v] != -1)
                v = t1.go[c][v];

            t2.update(ln[v], 1, 1, t1.sz, 1);
            for (int qn : qv[i]) {
                int l = ln[nn[qn]];
                int r = rn[nn[qn]];
                if (t2.query(l, r, 1, t1.sz, 1) < k[qn]) {
                    B[qn] = 1;
                }
                else B[qn] = 0;
            }
            qv[i].clear();
        }
        cnt = 0;
        for (int i = 0; i < q; i++) {
            if (L[i] == R[i]) continue;
            if (B[i]) {
                L[i] = (L[i] + R[i]) / 2 + 1;
            }
            else {
                R[i] = (L[i] + R[i]) / 2;
            }
            if (L[i] != R[i]) {
                qv[(L[i] + R[i]) / 2].push_back(i);
                ++cnt;
            }
            B[i] = 0;
        }
        t2.init();
    }
    for (int i = 0; i < q; i++) {
        if (L[i] == n) cout << -1 << '\n';
        else cout << L[i] - t[i].size() + 2 << '\n';
    }
}