#include <bits/stdc++.h>
#define int long long
#define x first
#define y second
#define pb push_back
void debug() {std::cerr << "\n";}
template<class T, class... OtherArgs>
void debug(T &&var, OtherArgs &&... args) {
    std::cerr << std::forward<T>(var) << " ";
    debug(std::forward<OtherArgs>(args)...);
}
#define SZ(x) (int)(x).size()
#define all(x) (x).begin(), (x).end()
using namespace std;
mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());
using i64 = long long;
using u64 = unsigned long long;
using LD = long double;
using PII = pair<int, int>;
constexpr int N = 200010;
constexpr int P = 1e9 + 7;

template<class T>
constexpr T power(T a, i64 b) { T res {1}; for (; b; b /= 2, a *= a) if (b % 2) res *= a; return res; }
constexpr i64 mul(i64 a, i64 b, i64 p) { i64 res = (LD)a * b - i64((LD)a * b / p) * p; res %= p; if (res < 0) res += p; return res; }
template<i64 P>
struct MInt {
    i64 x;
    constexpr MInt() : x {0} {}
    constexpr MInt(i64 x) : x {norm(x % getMod())} {}
    static i64 Mod;
    constexpr static i64 getMod() { return P ? P : Mod; }
    constexpr static void setMod(i64 Mod_) { Mod = Mod_; }
    constexpr i64 norm(i64 x) const { if (x < 0) x += getMod(); if (x >= getMod()) x -= getMod(); return x; }
    constexpr i64 val() const { return x; }
    explicit constexpr operator i64() const { return x; }
    constexpr MInt operator-() const { MInt res; res.x = norm(getMod() - x); return res; }
    constexpr MInt inv() const { return power(*this, getMod() - 2); }
    constexpr MInt &operator*=(MInt rhs) & { if (getMod() < (1ULL << 31)) { x = x * rhs.x % i64(getMod()); } else { x = mul(x, rhs.x, getMod()); } return *this; }
    constexpr MInt &operator+=(MInt rhs) & { x = norm(x + rhs.x); return *this; }
    constexpr MInt &operator-=(MInt rhs) & { x = norm(x - rhs.x); return *this; }
    constexpr MInt &operator/=(MInt rhs) & { return *this *= rhs.inv(); }
    friend constexpr MInt operator*(MInt lhs, MInt rhs) { MInt res = lhs; res *= rhs; return res; }
    friend constexpr MInt operator+(MInt lhs, MInt rhs) { MInt res = lhs; res += rhs; return res; }
    friend constexpr MInt operator-(MInt lhs, MInt rhs) { MInt res = lhs; res -= rhs; return res; }
    friend constexpr MInt operator/(MInt lhs, MInt rhs) { MInt res = lhs; res /= rhs; return res; }
    friend constexpr std::istream &operator>>(std::istream &is, MInt &a) { i64 v; is >> v; a = MInt(v); return is; }
    friend constexpr std::ostream &operator<<(std::ostream &os, const MInt &a) { return os << a.val(); }
    friend constexpr bool operator==(MInt lhs, MInt rhs) { return lhs.val() == rhs.val(); }
    friend constexpr bool operator!=(MInt lhs, MInt rhs) { return lhs.val() != rhs.val(); }
};
// using Z = MInt<0>;
using Z = MInt<P>;

void solve() {
    int n, q;
    cin >> n >> q;
    string s;
    cin >> s;

    int m = 0;
    vector f(3, vector(n + 1, vector(n + 1, vector<Z>(n + 1))));
    f[0][0][0][0] = f[1][0][0][0] = f[2][0][0][0] = 1;
    for (int i = 0; i < n; i++) {
        vector g(3, vector(n + 1, vector(n + 1, vector<Z>(n + 1))));
        if (s[i] == '?') {
            m++;
            for (int x = 0; x < m; x++) {
                for (int y = 0; x + y < m; y++) {
                    int z = m - 1 - x - y;
                    g[0][x + 1][y][z] += f[1][x][y][z];
                    g[0][x + 1][y][z] += f[2][x][y][z];
                    g[1][x][y + 1][z] += f[0][x][y][z];
                    g[1][x][y + 1][z] += f[2][x][y][z];
                    g[2][x][y][z + 1] += f[0][x][y][z];
                    g[2][x][y][z + 1] += f[1][x][y][z];
                }
            }
        } else {
            int t = s[i] - 'a';
            for (int x = 0; x <= m; x++) {
                for (int y = 0; x + y <= m; y++) {
                    int z = m - x - y;
                    g[t][x][y][z] += f[(t + 1) % 3][x][y][z];
                    g[t][x][y][z] += f[(t + 2) % 3][x][y][z];
                }
            }
        }
        f = move(g);
    }

    for (int t = 0; t < 3; t++) {
        for (int x = 1; x <= n; x++) {
            for (int y = 0; y <= n; y++) {
                for (int z = 0; z <= n; z++) {
                    f[t][x][y][z] += f[t][x - 1][y][z];
                }
            }
        }
        for (int x = 0; x <= n; x++) {
            for (int y = 1; y <= n; y++) {
                for (int z = 0; z <= n; z++) {
                    f[t][x][y][z] += f[t][x][y - 1][z];
                }
            }
        }
        for (int x = 0; x <= n; x++) {
            for (int y = 0; y <= n; y++) {
                for (int z = 1; z <= n; z++) {
                    f[t][x][y][z] += f[t][x][y][z - 1];
                }
            }
        }
    }

    while (q--) {
        int x, y, z;
        cin >> x >> y >> z;
        Z ans = 0;
        if (s.back() == '?') {
            ans += f[0][x][y][z] + f[1][x][y][z] + f[2][x][y][z];
        } else {
            ans = f[s.back() - 'a'][x][y][z];
        }
        cout << ans / 2 << '\n';
    }
}

signed main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    cout << fixed << setprecision(20);
    int _ = 1;
    // cin >> _;
    while (_--) {
        solve();
    }
}