#include <bits/stdc++.h>
using namespace std;
#define sim template < class c
#define ris return * this
#define dor > debug & operator <<
#define eni(x) sim > typename \
  enable_if<sizeof dud<c>(0) x 1, debug&>::type operator<<(c i) {
sim > struct rge { c b, e; };
sim > rge<c> range(c i, c j) { return rge<c>{i, j}; }
sim > auto dud(c* x) -> decltype(cerr << *x, 0);
sim > char dud(...);
struct debug {
#ifdef LOCAL
~debug() { cerr << endl; }
eni(!=) cerr << boolalpha << i; ris; }
eni(==) ris << range(begin(i), end(i)); }
sim, class b dor(pair < b, c > d) {
  ris << "(" << d.first << ", " << d.second << ")";
}
sim dor(rge<c> d) {
  *this << "[";
  for (auto it = d.b; it != d.e; ++it)
    *this << ", " + 2 * (it == d.b) << *it;
  ris << "]";
}
#else
sim dor(const c&) { ris; }
#endif
};
#define imie(...) " [" << #__VA_ARGS__ ": " << (__VA_ARGS__) << "] "
// debug & operator << (debug & dd, P p) { dd << "(" << p.x << ", " << p.y << ")"; return dd; }

// ALCS, https://www.sciencedirect.com/science/article/pii/S0166218X07002727
vector<vector<int>> get_ih(string a, string b) {
    int na = a.length();
    int nb = b.length();
    vector<vector<int>> ih(na + 1, vector<int>(nb + 1));
    auto iv = ih;
    for(int j = 0; j <= nb; ++j) {
        ih[0][j] = j;
    }
    for(int l = 0; l <= na; ++l) {
        iv[l][0] = 0;
    }
    for(int l = 1; l <= na; ++l) {
        for(int j = 1; j <= nb; ++j) {
            if(a[l-1] != b[j-1]) {
                ih[l][j] = max(iv[l][j-1], ih[l-1][j]);
                iv[l][j] = min(iv[l][j-1], ih[l-1][j]);
            }
            else {
                ih[l][j] = iv[l][j-1];
                iv[l][j] = ih[l-1][j];
            }
        }
    }
    return ih;
}

int one[3005], two[3005];
int last_size;
void get_row(int A, int b_high, const vector<vector<int>>& ih, int ans[]) {
    // a[0..A] with b[low..]
    A++;
    b_high++;
    for(int i = 0; i <= b_high; ++i) {
        ans[i] = 0;
    }
    for(int j = 1; j <= b_high; ++j) {
        int L = ih[A][j];
        int R = j - 1;
        if(L <= R) {
            ans[L]++;
            if(R + 1 < b_high) {
                ans[R+1]--;
            }
            // for(int i = L; i <= R; ++i) {
                // ans[i]++;
            // }
        }
        // in[A][j] .. j - 1
    }
    for(int i = 1; i < b_high; ++i) {
        ans[i] += ans[i-1];
    }
    /*for(int b_low = 0; b_low < b_high; ++b_low) {
        int pref = 0;
        for(int j = b_low + 1; j <= b_high; ++j) {
            if(b_low >= ih[A][j]) {
                pref++;
            }
        }
        ans.push_back(pref);
    }*/
    ans[b_high] = 0;
    last_size = b_high + 1;
    reverse(ans, ans + last_size);
    // reverse(ans.begin(), ans.end());
    // return ans;
    // return answer;
};

string read() {
    static char s[3005];
    scanf("%s", s);
    return string(s);
}
struct Query {
    int la, ra, lb, rb, id;
    void read(int _id) {
        id = _id;
        scanf("%d%d%d%d", &la, &ra, &lb, &rb);
        la--; ra--; lb--; rb--;
    }
};

vector<int> print;

void rec_solve(string a, string b, vector<Query>& queries) {
    if(/*(int) a.length() < 5 && */ queries.empty()) {
        return;
    }
    if(a.length() < b.length()) {
        swap(a, b);
        for(Query& query : queries) {
            swap(query.la, query.lb);
            swap(query.ra, query.rb);
        }
    }

    int na = a.length();
    int nb = b.length();

    const int mid = na / 2;
    string a_left = a.substr(0, mid);
    string a_right = a.substr(mid);
    // debug() << imie(a_left) imie(a_right);
    vector<vector<int>> ih_right = get_ih(a_right, b);
    reverse(a_left.begin(), a_left.end());
    reverse(b.begin(), b.end());
    vector<vector<int>> ih_left = get_ih(a_left, b);
    // vector<vector<int>> ih_right = get_ih(a_right, b);
    reverse(a_left.begin(), a_left.end());
    reverse(b.begin(), b.end());

    vector<Query> left_queries, right_queries;

    for(Query query : queries) {
        int la = query.la, ra = query.ra, lb = query.lb, rb = query.rb;
        if((ra - la + 1) * (rb - lb + 1) <= 1000 || (int) queries.size() <= 10) {
            int len_a = ra - la + 1;
            int len_b = rb - lb + 1;
            vector<int> dp(len_b + 1);
            for(int i = 0; i < len_a; ++i) {
                for(int j = len_b - 1; j >= 0; --j) {
                    if(a[la+i] == b[lb+j]) {
                        dp[j+1] = dp[j] + 1;
                    }
                }
                for(int j = 0; j < len_b; ++j) {
                    dp[j+1] = max(dp[j+1], dp[j]);
                }
            }
            print[query.id] = dp.back();
            continue;
        }
        if(ra < mid) {
            left_queries.push_back(query);
            continue;
        }
        if(la >= mid) {
            query.la -= mid;
            query.ra -= mid;
            right_queries.push_back(query);
            continue;
        }
        // if(la < mid && ra >= mid) {
        get_row(mid - 1 - la, nb - 1 - lb, ih_left, one);
        int one_size = last_size;
        get_row(ra - mid, rb, ih_right, two);
        int two_size = last_size;
        // debug() << imie(one) imie(two);
        int answer = 0;
        for(int i = 0; i < one_size; ++i) {
            int j = rb-lb+1 - i;
            if(0 <= j && j < two_size) {
                answer = max(answer, one[i] + two[j]);
            }
        }
        print[query.id] = answer;
            // printf("%d\n", answer);
        // }
        /*
        else { // brute force
            assert(false);
            // puts("?");
            // continue;
            vector<vector<int>> ih = get_ih(a.substr(la), b);
            int A = ra - la;
            int b_low = lb, b_high = rb;

            // a[0..A] with b[low..]
            A++;
            b_high++;
            int answer = 0;
            for(int j = b_low + 1; j <= b_high; ++j) {
                if(b_low >= ih[A][j]) {
                    answer++;
                }
            }
            print[query.id] = answer;
            // printf("%d\n", answer);
        }*/
    }
    rec_solve(a_left, b, left_queries);
    rec_solve(a_right, b, right_queries);
}

int main() {
    // string a = "yxxyzyzx";
    // string b = "yxxyzxyzxyxzx";

    int na, nb, q;
    scanf("%d%d%d", &na, &nb, &q);
    string a = read();
    string b = read();

    vector<Query> queries(q);
    for(int i = 0; i < q; ++i) {
        queries[i].read(i);
    }
    print.resize(q, -1);

    rec_solve(a, b, queries);

    for(int x : print) {
        printf("%d\n", x);
    }
}