#include<iostream>
#include<cstring>
#include<vector>
#include<algorithm>
#include<cassert>
using namespace std;
using LL = long long;

// rad[i]表示以i为回文中心的最长回文串的长度
// rad[i](i 为偶数) 奇数长度回文串中心 i / 2 + 1 (1 based)
// rad[i](i 为奇数) 偶数回文串中心 i / 2 + 1 后面的空隙 (1 based)
// 判断[l, r] (1 based) 是否是回文串 : rad[l + r - 2] >= r - l + 1;
template<typename S>
vector<int> manacher(S s, bool calc_even = true) {
    if (calc_even) {
        int n = (int) s.size();
        assert(n > 0);
        s.resize(2 * n - 1);
        for(int i = n - 1; i >= 0; i--) {
            s[2 * i] = s[i];
        }
        auto d = *min_element(begin(s), end(s));
        for(int i = 0; i < n - 1; i++) {
            s[2 * i + 1] = d;
        }
    }
    int n = (int) s.size();
    vector<int> rad(n);
    {
        int i = 0, j = 0;
        while(i < n) {
            while(i - j >= 0 && i + j < n && s[i - j] == s[i + j]) ++j;
            rad[i] = j;
            int k = 1;
            while(i - k >= 0 && i + k < n && k + rad[i - k] < j) {
                rad[i + k] = rad[i - k];
                ++k;
            }
            i += k, j -= k;
        }
    }
    if (calc_even) {
        for(int i = 0; i < n; i++) {
            if(((i ^ rad[i]) & 1) == 0) rad[i]--;
        }
    } 
    else {
        for(auto &&x: rad) x = 2 * x - 1;
    }
    return rad;
}

const int maxn = 2e6 + 5;
struct SuffixAutomaton{
    struct Node{
        int len, fa;
        int ch[26];
    }node[maxn];
    int tot = 1, last = 1;
    LL f1[maxn], f2[maxn];
    int c[maxn], id[maxn];

    SuffixAutomaton(){
        clear();
    }

    int new_node(){
        ++tot;
        node[tot].len = node[tot].fa = 0;
        memset(node[tot].ch, 0, sizeof node[tot].ch);
        f1[tot] = f2[tot] = 0;
        return tot;
    }

    void clear(){
        tot = 0;
        last = new_node();
    }

    void extend(int c){
        int p = last, np = last = new_node();
        node[np].len = node[p].len + 1;
        for(; p && !node[p].ch[c]; p = node[p].fa) node[p].ch[c] = np;
        if (!p) node[np].fa = 1;
        else{
            int q = node[p].ch[c];
            if (node[q].len == node[p].len + 1) node[np].fa = q;
            else{
                int nq = new_node();
                node[nq] = node[q], node[nq].len = node[p].len + 1;
                node[q].fa = node[np].fa = nq;
                for(; p && node[p].ch[c] == q; p = node[p].fa) node[p].ch[c] = nq;
            }
        }
        // f[last] += 1;
    }   

    void topsort(){
        for(int i = 1; i <= tot; i++) c[i] = 0;
        for(int i = 1; i <= tot; i++) c[node[i].len]++;
        for(int i = 1; i <= tot; i++) c[i] += c[i - 1];
        for(int i = tot; i >= 1; i--) id[c[node[i].len]--] = i;
        for(int i = tot; i >= 2; i--){
            f1[node[id[i]].fa] += f1[id[i]];
            f2[node[id[i]].fa] += f2[id[i]];
        }
    }

    // clear & build
    void build(const string &s){
        clear();
        for(auto c : s) extend(c - 'a');
    }

}sam;

int main(){

#ifdef LOCAL
    freopen("data.in", "r", stdin);
    freopen("data.out", "w", stdout);
#endif

    cin.tie(0);
    cout.tie(0);
    ios::sync_with_stdio(0);

    int n, m;
    cin >> n >> m;
    string s;
    cin >> s;
    auto rad = manacher(s);
    vector<int> d(n + 1);
    for(int i = 0; i < rad.size(); i += 2){
        int pos = i / 2 + 1;
        d[pos] += 1;
        int r = (rad[i] + 1) / 2;
        if (pos + r <= n) d[pos + r] -= 1;
    }
    for(int i = 1; i < rad.size(); i += 2){
        int pos = i / 2 + 1;
        d[pos + 1] += 1;
        int r = (rad[i] + 1) / 2;
        if (pos + 1 + r <= n) d[pos + 1 + r] -= 1;
    }
    for(int i = 1; i <= n; i++){
        d[i] += d[i - 1];
    }
    s = " " + s;
    for(int i = n; i >= 1; i--){
        sam.extend(s[i] - 'a');
        sam.f1[sam.last] += 1;
        sam.f2[sam.last] += d[i - 1];
    }
    sam.topsort();
    while(m--){
        string t;
        cin >> t;
        const int s = t.size();
        LL ans = 0;
        auto rad = manacher(t);
        t = " " + t;

        auto check = [&](int l, int r){
            if (l > r) return true;
            return rad[l + r - 2] >= r - l + 1;
        };

        int p = 1;

        for(int i = 1; i <= s; i++){
            p = sam.node[p].ch[t[i] - 'a'];
            if (p == 0) break;
            if (check(i + 1, s)){
                ans += sam.f1[p];
            }
        }
        if (p != 0) ans += sam.f2[p];
        cout << ans << '\n';
    }

}