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

// 常量定义
const int L = 6e4 + 5;  // 字符串的最大长度
const int HASH_CNT = 2; // 使用的哈希函数个数

// 哈希函数的基数和模数
int hashBase[HASH_CNT] = {29, 31};
int hashMod[HASH_CNT] = {int(1e9 + 9), 998244353};

// 字符串哈希类
struct StringWithHash {
    char s[L];                // 存储字符串
    int ls;                   // 字符串的当前长度
    int hsh[HASH_CNT][L];     // 存储每个位置的哈希值
    int pwMod[HASH_CNT][L];   // 存储每个位置的哈希基数的幂值

    // 初始化哈希值和幂值
    void init() {
        ls = 0;
        for (int i = 0; i < HASH_CNT; ++i) {
            hsh[i][0] = 0;  // 哈希初始化为0
            pwMod[i][0] = 1; // 幂初始化为1
        }
    }

    StringWithHash() { init(); }

    // 扩展字符串并计算新的哈希值
    void extend(char c) {
        s[++ls] = c;  // 记录字符数和每个字符
        for (int i = 0; i < HASH_CNT; ++i) {
            // 计算当前字符位置的哈希值和幂值
            pwMod[i][ls] = 1ll * pwMod[i][ls - 1] * hashBase[i] % hashMod[i];  
            hsh[i][ls] = (1ll * hsh[i][ls - 1] * hashBase[i] + c) % hashMod[i];  // 双哈希的递推
        }
    }

    // 获取从l到r的哈希值（字符串从1开始计数）
    vector<int> getHash(int l, int r) {
        vector<int> res(HASH_CNT, 0);
        for (int i = 0; i < HASH_CNT; ++i) {
            // 计算该区间的哈希值，使用递推公式
            int t = (hsh[i][r] - 1ll * hsh[i][l - 1] * pwMod[i][r - l + 1]) % hashMod[i];
            t = (t + hashMod[i]) % hashMod[i]; // 保证哈希值非负
            res[i] = t; // 存储计算结果
        }
        return res;
    }
};

// 比较两个哈希值是否相等
bool equal(const vector<int>& h1, const vector<int>& h2) {
    assert(h1.size() == h2.size()); // 确保两者大小一致
    for (unsigned i = 0; i < h1.size(); i++)
        if (h1[i] != h2[i]) return false;  // 如果有任何不同，则不相等
    return true;  // 否则相等
}

int n, q, m, k;  // n为字符串个数，q为查询次数，m为字符串长度，k为允许的最大错位次数
StringWithHash s[310], t;  // 存储n个字符串及当前查询字符串

// 计算第i个字符串与查询字符串t的匹配结果
int calc(int i) {
    int l = 1, K = k;  // 从第1个字符开始，最多允许k次错位
    do {
        int L = l, R = m, ans = L - 1;  // 在L和R之间二分查找匹配的位置
        while (L <= R) {
            int M = L + R >> 1;  // 中点位置
            if (equal(t.getHash(L, M), s[i].getHash(L, M))) {
                ans = M;   // 如果字符串匹配，更新答案并继续往后匹配
                L = M + 1;
            } else {
                R = M - 1;  // 否则往前查找
            }
        }

        // 如果能匹配整个字符串，直接返回1
        if (ans == m) return 1;
        // 如果已经没有剩余的错位次数，返回0
        if (K == 0) return 0;
        l = ans + 2;  // 否则从下一个位置继续匹配
        if (l > m) return 1;  // 如果超出范围，表示匹配成功
        --K;  // 剩余错位次数减1
    } while (1);  // 重复直到找到匹配
    return 0;  // 如果没有匹配成功，返回0
}

int main() {
    // 输入字符串的数量n、查询次数q、字符串长度m和允许的最大错位次数k
    cin >> n >> q >> m >> k;

    // 输入n个字符串并计算它们的哈希值
    for (int i = 1; i <= n; i++) {
        string st;
        cin >> st;
        for (int j = 0; j < m; j++) {
            s[i].extend(st[j]);  // 扩展每个字符，计算哈希
        }
    }

    // 处理每个查询
    for (int i = 1; i <= q; i++) {
        string st;
        cin >> st;  // 输入查询字符串
        t.init();   // 初始化查询字符串的哈希
        for (int j = 0; j < m; j++) {
            t.extend(st[j]);  // 扩展查询字符串
        }

        int ans = 0;
        // 对每个字符串进行匹配，统计匹配成功的数量
        for (int j = 1; j <= n; j++) {
            int p = calc(j);  // 计算第j个字符串的匹配结果
            ans += p;         // 累加匹配的数量
        }

        // 输出查询结果
        cout << ans << endl;
    }

    return 0;
}
/*
6 4 4 1
kaki
kika
manu
nana
tepu
tero
kaka
mana
teri
anan
*/