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

vector<int> zfunc(const string &s) {
    int n = s.size();
    vector<int> z(n);
    int l = 0, r = 0;
    for (int i = 1; i < n; i++) {
        if (i <= r) z[i] = min(r - i + 1, z[i - l]);
        while (i + z[i] < n && s[z[i]] == s[i + z[i]]) z[i]++;
        if (i + z[i] - 1 > r) {
            l = i;
            r = i + z[i] - 1;
        }
    }
    return z;
}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    string s;
    cin >> s;
    int n = s.size();

    // Đảo ngược xâu s
    string t = s;
    reverse(t.begin(), t.end());

    // Tạo xâu u = t + '#' + t
    // '#' là ký tự phân cách để đảm bảo không có hậu tố nào vượt qua ranh giới
    string u = t + "#" + t;
    vector<int> z = zfunc(u);

    int m;
    cin >> m;
    while (m--) {
        int i;
        cin >> i;
        // Vị trí cần kiểm tra trong xâu u
        // Tiền tố t[0...i-1] tương ứng với hậu tố s[n-i...n-1]
        // Trong u, vị trí bắt đầu của phần thứ hai (t) nằm ở index n+1
        // Ta cần so sánh tiền tố độ dài i của t với hậu tố của t
        // Đây là bài toán tìm Z-value tại vị trí n+1 của u
        // Tuy nhiên, theo cách giải thích trong code mẫu:
        // pos = n + 1 + (n - i) là vị trí bắt đầu của đoạn t[i-1...] trong phần thứ hai của u
        // Z[pos] sẽ cho độ dài tiền tố chung của u (bắt đầu từ pos) với u (bắt đầu từ 0)
        // u[0...] là t. u[pos...] là t[n-i...]
        // Z-value tại pos cho biết độ dài khớp giữa t và t[n-i...]
        // Điều này chính xác là f(i).

        int pos = n + 1 + (n - i);
        cout << z[pos] << (m ? ' ' : '\n');
    }
    return 0;
}

#include <iostream>
#include <vector>
#include <string>
#include <algorithm>

using namespace std;

vector<int> z_function(string s) {
    int n = (int) s.length();
    vector<int> z(n);
    for (int i = 1, l = 0, r = 0; i < n; ++i) {
        if (i <= r)
            z[i] = min(r - i + 1, z[i - l]);
        while (i + z[i] < n && s[z[i]] == s[i + z[i]])
            ++z[i];
        if (i + z[i] - 1 > r) {
            l = i;
            r = i + z[i] - 1;
        }
    }
    return z;
}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(0);

    string s;
    cin >> s;
    int n = s.length();

    // Tạo xâu u = s + '#' + reverse(s)
    // Cần reverse string
    string rev_s = s;
    reverse(rev_s.begin(), rev_s.end());
    string u = s + "#" + rev_s;

    vector<int> z = z_function(u);

    int m;
    cin >> m;
    vector<int> res;
    res.reserve(m);

    for (int k = 0; k < m; ++k) {
        int i;
        cin >> i;
        // f(i) là độ dài tiền tố chung của s và reverse(s)[n-i...]
        // Trong u, reverse(s) bắt đầu từ index n+1.
        // Đoạn reverse(s)[n-i...] bắt đầu từ index n+1 + (n-i).
        // Z-value tại index đó cho biết độ dài khớp với prefix của u (s).
        // Prefix của u là s. Suffix của s là reverse(s)[n-i...].
        // Wait, logic này bị sai.
        // Logic đúng (như Solution 1): u = reverse(s) + '#' + reverse(s).
        // Logic sai (Attempt): u = s + '#' + reverse(s).
        // Ta phải dùng Solution 1 cho chắc chắn.
        // Code này minh họa cho cách tiếp cận sai để làm rõ.
        // Thực tế Solution 1 là tối ưu nhất.

        // Để minh họa cách khác: Dùng Z-function trên s + '#' + reverse(s) không trực tiếp giải quyết được bài toán này.
        // Bài toán yêu cầu so sánh hậu tố của s với tiền tố của s.
        // Hậu tố của s là tiền tố của reverse(s).
        // Vậy cần so sánh s với reverse(s).
        // Nhưng Z-function yêu cầu so sánh với tiền tố của xâu.
        // Vậy ta cần đưa reverse(s) vào vị trí prefix.
        // Xâu u = reverse(s) + '#' + reverse(s).
        // Z[i] tại phần thứ hai cho biết độ dài tiền tố chung của reverse(s) với suffix của reverse(s).
        // Tức là độ dài tiền tố chung của reverse(s) và reverse(s)[i...].
        // Nếu i = n - k, ta có reverse(s)[n-k...] là tiền tố của reverse(s) độ dài k.
        // Đảo lại: tiền tố của reverse(s) là hậu tố của s.
        // Vậy Z[n+1 + (n-k)] cho biết độ dài tiền tố chung của reverse(s) và reverse(s)[n-k...]
        // Tức là độ dài hậu tố chung của s và tiền tố s[1..k].
        // Đây chính là f(k).

        // Logic code mẫu:
        int pos = n + 1 + (n - i);
        // u = t + '#' + t. t = reverse(s).
        // Z[pos] la ket qua.
        cout << z[pos] << " ";
    }
    cout << endl;
    return 0;
}