%:pragma GCC optimize(3)
%:pragma GCC optimize("Ofast")
%:pragma GCC optimize("inline")
%:pragma GCC optimize("-fgcse")
%:pragma GCC optimize("-fgcse-lm")
%:pragma GCC optimize("-fipa-sra")
%:pragma GCC optimize("-ftree-pre")
%:pragma GCC optimize("-ftree-vrp")
%:pragma GCC optimize("-fpeephole2")
%:pragma GCC optimize("-ffast-math")
%:pragma GCC optimize("-fsched-spec")
%:pragma GCC optimize("unroll-loops")
%:pragma GCC optimize("-falign-jumps")
%:pragma GCC optimize("-falign-loops")
%:pragma GCC optimize("-falign-labels")
%:pragma GCC optimize("-fdevirtualize")
%:pragma GCC optimize("-fcaller-saves")
%:pragma GCC optimize("-fcrossjumping")
%:pragma GCC optimize("-fthread-jumps")
%:pragma GCC optimize("-funroll-loops")
%:pragma GCC optimize("-fwhole-program")
%:pragma GCC optimize("-freorder-blocks")
%:pragma GCC optimize("-fschedule-insns")
%:pragma GCC optimize("inline-functions")
%:pragma GCC optimize("-ftree-tail-merge")
%:pragma GCC optimize("-fschedule-insns2")
%:pragma GCC optimize("-fstrict-aliasing")
%:pragma GCC optimize("-fstrict-overflow")
%:pragma GCC optimize("-falign-functions")
%:pragma GCC optimize("-fcse-skip-blocks")
%:pragma GCC optimize("-fcse-follow-jumps")
%:pragma GCC optimize("-fsched-interblock")
%:pragma GCC optimize("-fpartial-inlining")
%:pragma GCC optimize("no-stack-protector")
%:pragma GCC optimize("-freorder-functions")
%:pragma GCC optimize("-findirect-inlining")
%:pragma GCC optimize("-fhoist-adjacent-loads")
%:pragma GCC optimize("-frerun-cse-after-loop")
%:pragma GCC optimize("inline-small-functions")
%:pragma GCC optimize("-finline-small-functions")
%:pragma GCC optimize("-ftree-switch-conversion")
%:pragma GCC optimize("-foptimize-sibling-calls")
%:pragma GCC optimize("-fexpensive-optimizations")
%:pragma GCC optimize("-funsafe-loop-optimizations")
%:pragma GCC optimize("inline-functions-called-once")
%:pragma GCC optimize("-fdelete-null-pointer-checks")


#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef double db;
typedef pair <int, int> pin;

#ifndef ONLINE_JUDGE
bool MEMORY_ST;
#endif

const int N = 2e5 + 5;
const int M = 205;
const int L = 64;
const int W = L - 1;
const ll P = 998244353LL;

int n, m, cnt, qn, ln[M], rn[M], bel[N], ans[N][M];
char sa[N], sb[N];

struct Bitset {
    int siz;
    ull bit[N >> 6];

    inline void build(char *s) {
        memset(bit, 0, sizeof(bit));
        int len = strlen(s);
        for (; len & W; len++) s[len] = '0';
        ull cur = 0;
        siz = 0;
        for (int i = 0; i < len; i++) {
            cur <<= 1;
            if (s[i] == '1') cur |= 1;
            if ((i & W) == W) {
                bit[siz++] = cur;
                cur = 0;   
            }
        }
        // printf("%d\n%llu\n", n, bit[0]);
    }

    inline ull get(int p, int len) {
        if (len == L) {
            if (!(p & W)) return bit[p >> 6];
            int s = p >> 6, r = p & W;
            ull mask = (1ULL << (L - r)) - 1, hmask = ULLONG_MAX ^ mask;
            return (bit[s] << r) | ((bit[s + 1] & hmask) >> (L - r));
        } else {
            assert(len < L);
            int d = L - len;
            ull res;
            if (!(p & W)) res = bit[p >> 6];
            else {
                int s = p >> 6, r = p & W;
                ull mask = (1ULL << (L - r)) - 1, hmask = ULLONG_MAX ^ mask;
                res = (bit[s] << r) | ((bit[s + 1] & hmask) >> (L - r)); 
            }
            res >>= d;
            return res;
        }  
    }

} a, b;

inline void bp(ull x) {
    vector <int> t;
    for (int i = 0; i < 64; i++, x >>= 1) t.emplace_back(x & 1);
    reverse(t.begin(), t.end());
    for (int i = 0; i < t.size(); i++)
        printf("%d", t[i]);
    puts("");
}

inline int shiftxor(int p1, int p2, int len) {
    int res = 0;
    for (; len > 0; ) {
        if (len >= L) {
            ull cur1 = a.get(p1, L), cur2 = b.get(p2, L);
            // printf("%llu %llu\n", cur1, cur2);
            // bp(cur1), bp(cur2);
            res += __builtin_popcountll(cur1 ^ cur2);
            p1 += L, p2 += L, len -= L;
        } else {
            ull cur1 = a.get(p1, len), cur2 = b.get(p2, len);
            // bp(cur1), bp(cur2);
            // printf("%llu %llu\n", cur1, cur2);
            res += __builtin_popcountll(cur1 ^ cur2);
            p1 += len, p2 += len, len = 0;
        }
    }
    return res;
}

inline int solve(int p1, int p2, int len) {
    int l = p2, r = p2 + len - 1;
    if (bel[l] == bel[r]) return shiftxor(p1, p2, len);
    else {
        int res = 0;
        res += shiftxor(p1, p2, rn[bel[l]] - l + 1);
        p1 += rn[bel[l]] - l + 1, p2 += rn[bel[l]] - l + 1;
        for (int i = bel[l] + 1; i <= bel[r] - 1; i++) {
            assert(p2 == ln[i]);
            res += ans[p1][i];
            p1 += rn[i] - ln[i] + 1, p2 += rn[i] - ln[i] + 1;
        }
        assert(p2 == ln[bel[r]]);
        res += shiftxor(p1, p2, r - ln[bel[r]] + 1);
        p1 += r - ln[bel[r]] + 1, p2 += r - ln[bel[r]] + 1;
        assert(p2 == r + 1);
        return res;
    }
}

#ifndef ONLINE_JUDGE
bool MEMORY_ED;
#endif

int main() {
#ifndef ONLINE_JUDGE
    freopen("sample.in", "r", stdin);
    freopen("sample.out", "w", stdout);
    clock_t st_clock = clock();
#endif

    scanf("%s", sa);
    scanf("%s", sb);
    a.build(sa), b.build(sb);
    n = a.siz * L, m = b.siz * L;
    const int block = 8000;
    cnt = m / block;
    for (int i = 1; i <= cnt; i++) {
        ln[i] = rn[i - 1] + 1;
        rn[i] = i * block;
    }
    if (m % block != 0) {
        ++cnt;
        ln[cnt] = rn[cnt - 1] + 1;
        rn[cnt] = m;
    }
    for (int i = 1; i <= cnt; i++) {
        --ln[i], --rn[i];
        for (int j = ln[i]; j <= rn[i]; j++) 
            bel[j] = i;
    }
    // for (int i = 1; i <= cnt; i++)
    //     printf("%d %d\n", ln[i], rn[i]);
    for (int i = 0; i < n; i++)
        for (int j = 1; j <= cnt; j++) {
            ans[i][j] = shiftxor(i, ln[j], min(rn[j] - ln[j] + 1, n - i));
        }
    // for (int i = 1; i <= cnt; i++)
    //     printf("%d %d\n", ln[i], rn[i]);

    scanf("%d", &qn);
    for (int p1, p2, len; qn--; ) {
        scanf("%d%d%d", &p1, &p2, &len);
        printf("%d\n", solve(p1, p2, len));
    }

#ifndef ONLINE_JUDGE
    clock_t ed_clock = clock();
    printf("time = %f ms\n", (double)(ed_clock - st_clock) / CLOCKS_PER_SEC * 1000);
    printf("memory = %.2f MB\n", (&MEMORY_ED - &MEMORY_ST) / 1024.0 / 1024.0);
#endif
    return 0;
}