#include <bits/stdc++.h>
#define up(i,a,b) for (int i = (int)a; i <= (int)b; i++)
#define pii pair<int, int>
#define f first
#define s second
#define all(x) x.begin(), x.end()
using namespace std;

const int maxn = 4e5 + 10;
const int maxq = 5e5 + 10;
const int LOG = log2(maxn)+2;
int n;

pair<pii, int> L[maxn]; //Lexicography order: of string at position have rank i -> start at position L[i].second
int R[LOG][maxn]; //Ranking of string start at position i, have length of 2^log -> have rank R[log][i]
int SA[maxn];

void build_SA(const string& s){
    up(i,1,n) R[0][i] = s[i];

    for (int POW = 1; (1 << (POW-1)) <= n; POW++){
        up(i,1,n){
            L[i].f.f = R[POW-1][i];
            int k = i + (1 << (POW-1));
            if (k <= n) L[i].f.s = R[POW-1][k];
            else L[i].f.s = -1;
            L[i].s = i;
        }
        sort(L+1, L+n+1);

        int cnt = 0;
        up(i,1,n){
            if (L[i].f == L[i-1].f) R[POW][L[i].s] = R[POW][L[i-1].s];
            else R[POW][L[i].s] = ++cnt;
        }
    }

    up(i,1,n) SA[i] = L[i].s;
}

int LCP[maxn];
int pos[maxn];
void Kasai(const int SA[], const string& s){
    up(i,1,n) pos[SA[i]] = i;

    int k = 0;
    up(i,1,n){
        int& cur = pos[i];
        int j = SA[cur-1];
        //if suffix pair at position (i, j), have rank (cur, cur-1) and LCP equal to k
        //then suffix pair at position (i+1, j'), have rank(cur', cur'-1) should have LCP at least k-1, and at most...
        //find at at most on this line :)
        while (i+k <= n && j+k <= n && s[i+k] == s[j+k]) ++k;
        LCP[cur] = k;
        if (k) --k;
    }
}

int sp[LOG][maxn];
int logg[maxn];
void build_sparse(){
    up(i,1,n) sp[0][i] = LCP[i];
    up(i,2,n) logg[i] = logg[(i >> 1)] + 1;
    for (int i = 1; (1 << i) <= n; i++){
        for (int j = 1; j + (1 << i) - 1 <= n; j++){
            sp[i][j] = min(sp[i-1][j], sp[i-1][j + (1 << (i-1))]);
        }
    }
}

int RMQ(const int& l, const int& r){
    int k = logg[r - l + 1];
    return min(sp[k][l], sp[k][r - (1 << k) + 1]);
}

int get_left(int u, const int& need){
    int l = 0;
    int r = u;
    while (r - l > 1){
        int mid = (l+r) >> 1;
        if (RMQ(mid, u) >= need) r = mid;
        else l = mid;
    }
    if (LCP[r] >= need) return r-1;
    return r;
} // Find from [1 -> u]

int get_right(int u, const int& need){
    ++u;
    int l = u;
    int r = n+1;
    while (r - l > 1){
        int mid = (l+r) >> 1;
        if (RMQ(u, mid) >= need) l = mid;
        else r = mid;
    }

    if (LCP[l] >= need) return l;
    return l-1;
} // Find from [u+1 -> n]

int BIT[maxn];
void update(int x, const int val){
    while (x <= n){
        BIT[x] += val;
        x += (x & (-x));
    }
}

int get(int x){
    int res = 0;
    while (x){
        res += BIT[x];
        x -= (x & (-x));
    }
    return res;
}

struct event{
    int L,R,id,SIGN;
    event(int L, int R, int id, int SIGN):
        L(L), R(R), id(id), SIGN(SIGN)
    {}
};
vector<event> E[maxn];

int ans[maxq];
void solve(){
    up(i,1,n){
        update(SA[i], 1);
        for (auto e : E[i]){
            int L = e.L;
            int R = e.R;
            int id = e.id;
            int SIGN = e.SIGN;
            ans[id] += SIGN * (get(R) - get(L-1));
        }
    }
}

signed main(){
    ios_base::sync_with_stdio(false);
    cin.tie(0);
    #define Task "A"
    if (fopen(Task".inp", "r")){
        freopen(Task".inp", "r", stdin);
        freopen(Task".out", "w", stdout);
    }

    string s,t;
    cin >> s >> t;
    int SSIZE = s.size();

    string g = "@" + s + t;
    n = g.size() - 1;

    build_SA(g);
    Kasai(SA, g);

    build_sparse();

    int q;
    cin >> q;
    up(i,1,q){
        int sl, sr, tl, tr;
        cin >> sl >> sr >> tl >> tr;
        int slen = sr - sl + 1;
        int L = get_left(pos[sl], slen);
        int R = get_right(pos[sl], slen);
        int A = tl + SSIZE;
        int B = tr + SSIZE - slen + 1;

        if (B < A || R < L) continue;
        E[L-1].emplace_back(event(A, B, i, -1));
        E[R].emplace_back(event(A, B, i, 1));
    }

    solve();
    up(i,1,q) cout << ans[i] << "\n";
}