#include <iostream>
#include <algorithm>
#include <vector>
#include <string>
using namespace std;
 
#define DEBUG(x) cerr << #x << " = " << x << endl
 
const int INF = (int)1e9;
struct RMQ {
    vector<int> data;
    int N;
    RMQ(int size) {
        N = 1;
        while(N < size) N *= 2;
        data.assign(2*N-1, INF);
    }
    void update(int k, int a) {
        k += N - 1;
        data[k] = a;
        while(k > 0) {
            k = (k - 1) / 2;
            data[k] = min(data[2*k + 1], data[2*k + 2]);
        }
    }
 
    int minimum(int a, int b) {
        return minimum_sub(a,b,0,0,N);
    }
 
    int minimum_sub(int a, int b, int k, int l, int r) {
        if(r <= a || b <= l) return INF;
        if(a <= l && r <= b) return data[k];
        return min(minimum_sub(a,b,2*k+1,l,(l+r)/2),
                minimum_sub(a,b,2*k+2,(l+r)/2,r));
    }
};
 
const int MAX_N = 200000;
int Rank[MAX_N+1];
int tmp[MAX_N+1];
int n,k;
bool compare_sa(int i, int j) {
    if(Rank[i] != Rank[j]) return Rank[i] < Rank[j];
    else {
        int ri = i + k <= n ? Rank[i + k] : -1;
        int rj = j + k <= n ? Rank[j + k] : -1;
        return ri < rj;
    }
}
void construct_sa(const string &S, int *sa) {
    n = S.length();
    for(int i = 0; i <= n; ++i) {
        sa[i] = i;
        Rank[i] = i < n ? S[i] : -1;
    }
 
    for(k = 1; k <= n; k *= 2) {
        sort(sa, sa + n + 1, compare_sa);
        tmp[sa[0]] = 0;
        for(int i = 1; i <= n; ++i) {
            tmp[sa[i]] = tmp[sa[i - 1]] + (compare_sa(sa[i - 1], sa[i]) ? 1 : 0);
        }
        for(int i = 0; i <= n; ++i) {
            Rank[i] = tmp[i];
        }
    }
}
 
bool contain(const string &S, int *sa, const string &T) {
    int a = 0, b = S.length();
    while(b - a > 1) {
        int c = (a + b) / 2;
        if(S.compare(sa[c], T.length(), T) < 0) a = c;
        else b = c;
    }
    return S.compare(sa[b], T.length(), T) == 0;
}
 
int lower_bound(const string &S, int *sa, const string &T) {
    int a = 0, b = S.length();
    while(b - a > 1) {
        int c = (a + b) / 2;
        if(S.compare(sa[c], T.length(), T) < 0) a = c;
        else b = c;
    }
    return b;
}
 
int main() {
    string S; cin >> S;
    S = "^" + S;
    S.push_back('z'+1);
    string revS(S.rbegin(), S.rend());
    const int n1 = S.size()+1;
    vector<int> SA(n1);
    construct_sa(S, SA.data());
    vector<int> revSA(n1);
    construct_sa(revS, revSA.data());
    RMQ rmq(n1);
    RMQ revrmq(n1);
    for(int i = 0; i < n1; ++i) {
        rmq.update(i, SA[i]);
        revrmq.update(i, revSA[i]);
    }
#if 0
    for(int i = 0; i <= (int)S.size(); ++i) {
        cerr << i << " : " << SA[i] << " " << S.substr(SA[i]) << endl;
    }
    for(int i = 0; i <= (int)S.size(); ++i) {
        cerr << i << " : " << revSA[i] << " " << revS.substr(revSA[i]) << endl;
    }
#endif
 
    int M; cin >> M;
    for(int i = 0; i < M; ++i) {
        string prefix,suffix;
        cin >> prefix >> suffix;
        reverse(suffix.begin(), suffix.end());
        if(contain(S,SA.data(),prefix) == false || contain(revS,revSA.data(),suffix) == false) {
            cout << 0 << endl;
            continue;
        }
        int lbprefix = lower_bound(S,SA.data(),prefix);
        string prefix2 = prefix;
        *prefix2.rbegin() += 1;
        int ubprefix = lower_bound(S,SA.data(),prefix2);
 
        int lbsuffix = lower_bound(revS,revSA.data(),suffix);
        string suffix2 = suffix;
        *suffix2.rbegin() += 1;
        int ubsuffix = lower_bound(revS,revSA.data(),suffix2);
 
        int end = S.size() - revrmq.minimum(lbsuffix,ubsuffix);
        int begin = rmq.minimum(lbprefix,ubprefix);
        if(begin + prefix.size() - 1 <= end && begin <= end - suffix.size() + 1) {
            cout << max<int>(0, (S.size() - revrmq.minimum(lbsuffix,ubsuffix) - rmq.minimum(lbprefix,ubprefix))) << endl;
        }
        else {
            cout << "0" << endl;
        }
 
#if 0
        DEBUG(lbprefix);
        DEBUG(ubprefix);
        DEBUG(lbsuffix);
        DEBUG(ubsuffix);
#endif
 
    }
}

Measured memory_bytes: 9132