#include <algorithm>
#include <array>
#include <cstdint>
#include <iostream>
#include <map>
#include <string>
#include <vector>

class Trie {
public:
    Trie(): children_(1, std::map<uint32_t, uint32_t>{}), hits_(1, 0) {}

    uint32_t make_node() {
        children_.push_back({});
        hits_.push_back(0);

        return children_.size() - 1;
    }

    void insert(const std::vector<uint32_t>& data) {
        uint32_t node = 0;
        for (uint32_t x : data) {
            auto it = children_[node].find(x);
            if (it == children_[node].end()) {
                children_[node][x] = make_node();
            }

            ++hits_[node];
            node = children_[node][x];
        }

        ++hits_[node];
    }

    int32_t query(const std::vector<uint32_t>& data) const {
        uint32_t node = 0;
        for (uint32_t x : data) {
            auto it = children_[node].find(x);
            if (it == children_[node].end()) {
                return 0;
            }

            node = it->second;
        }

        return hits_[node];
    }
private:
    std::vector<std::map<uint32_t, uint32_t>> children_;
    std::vector<int32_t> hits_;
};

std::vector<uint32_t> make_one(std::string_view s) {
    int32_t n = s.size();
    std::vector<uint32_t> keys;
    keys.reserve(n);
    for (int32_t i = 0; i < n; ++i) {
        keys.push_back(s[i] - 'a');
    }

    return keys;
}

std::vector<uint32_t> make_both(std::string_view s, std::string_view t) {
    int32_t n = s.size();
    std::vector<uint32_t> keys;
    keys.reserve(n);
    for (int32_t i = 0; i < n; ++i) {
        keys.push_back(26 * (s[i] - 'a') + (t[n - 1 - i] - 'a'));
    }

    return keys;
}

int main() {
    int32_t n, q;
    std::cin >> n >> q;

    Trie prefix, suffix;
    Trie and_trie;
    for (int32_t word_idx = 0; word_idx < n; ++word_idx) {
        std::string word;
        std::cin >> word;

        std::vector<uint32_t> forward = make_one(word);
        prefix.insert(forward);

        std::vector<uint32_t> backwards(forward.begin(), forward.end());
        std::reverse(backwards.begin(), backwards.end());
        suffix.insert(backwards);

        std::vector<uint32_t> both = make_both(word, word);
        and_trie.insert(both);
    }

    for (int32_t i = 0; i < q; ++i) {
        std::string op, l, r;
        std::cin >> op >> l >> r;

        std::vector<uint32_t> and_query = make_both(l, r);
        int32_t and_count = and_trie.query(and_query);

        int32_t ans;
        if (op == "AND") {
            ans = and_count;
        } else {
            int32_t pref_count = prefix.query(make_one(l));
            std::vector<uint32_t> backwards = make_one(r);
            std::reverse(backwards.begin(), backwards.end());
            int32_t suff_count = suffix.query(backwards);

            if (op == "OR") {
                ans = pref_count + suff_count - and_count;
            } else {
                ans = pref_count + suff_count - 2 * and_count;
            }
        }

        std::cout << ans << '\n';
    }
}