#include <bits/stdc++.h>
#ifdef LOCAL
#include "pprint.hpp"
#else
#define debug(...)
#endif

using ll = long long;

#ifndef __OY_STATICMODINT32__
#define __OY_STATICMODINT32__
/**
 * @brief 静态 32 位模数取余
 * @example using Z = OY::mint1000000007;
 */
namespace OY {
    template <uint32_t P, bool IsPrime, typename = typename std::enable_if<(P > 1 && P < uint32_t(1) << 31)>::type>
    struct StaticModInt32 {
        using mint = StaticModInt32<P, IsPrime>;
        using mod_type = uint32_t;
        mod_type m_val;
        static constexpr mod_type _reduce_norm(int32_t x) { return x < 0 ? x + mod() : x; }
        static constexpr mod_type _mul(mod_type a, mod_type b) { return uint64_t(a) * b % mod(); }
        constexpr StaticModInt32() = default;
        template <typename Tp, typename std::enable_if<std::is_signed<Tp>::value>::type * = nullptr>
        constexpr StaticModInt32(Tp val) : m_val(_reduce_norm(val % int32_t(mod()))) {}
        template <typename Tp, typename std::enable_if<std::is_unsigned<Tp>::value>::type * = nullptr>
        constexpr StaticModInt32(Tp val) : m_val(val % mod()) {}
        static constexpr mint raw(mod_type val) { mint res{}; res.m_val = val; return res; }
        static constexpr mod_type mod() { return P; }
        constexpr mod_type val() const { return m_val; }
        constexpr mint pow(uint64_t n) const {
            mod_type res = 1, b = m_val;
            while (n) {
                if (n & 1) res = _mul(res, b);
                b = _mul(b, b), n >>= 1;
            }
            return raw(res);
        }
        constexpr mint inv() const {
            if constexpr (IsPrime) return inv_Fermat();
            else return inv_exgcd();
        }
        constexpr mint inv_exgcd() const {
            mod_type x = mod(), y = m_val, m0 = 0, m1 = 1;
            while (y) {
                mod_type z = x / y;
                x -= y * z, m0 -= m1 * z, std::swap(x, y), std::swap(m0, m1);
            }
            if (m0 >= mod()) m0 += mod() / x;
            return raw(m0);
        }
        constexpr mint inv_Fermat() const { return pow(mod() - 2); }
        constexpr mint &operator++() { if (++m_val == mod()) m_val = 0; return *this; }
        constexpr mint &operator--() { if (!m_val) m_val = mod(); m_val--; return *this; }
        constexpr mint operator++(int) { mint old(*this); ++*this; return old; }
        constexpr mint operator--(int) { mint old(*this); --*this; return old; }
        constexpr mint &operator+=(const mint &rhs) { m_val += rhs.m_val; if (m_val >= mod()) m_val -= mod(); return *this; }
        constexpr mint &operator-=(const mint &rhs) { m_val += mod() - rhs.m_val; if (m_val >= mod()) m_val -= mod(); return *this; }
        constexpr mint &operator*=(const mint &rhs) { m_val = _mul(m_val, rhs.m_val); return *this; }
        constexpr mint &operator/=(const mint &rhs) { return *this *= rhs.inv(); }
        constexpr mint operator+() const { return *this; }
        constexpr mint operator-() const { return raw(m_val ? mod() - m_val : 0); }
        constexpr bool operator==(const mint &rhs) const { return m_val == rhs.m_val; }
        constexpr bool operator!=(const mint &rhs) const { return m_val != rhs.m_val; }
        constexpr bool operator<(const mint &rhs) const { return m_val < rhs.m_val; }
        constexpr bool operator>(const mint &rhs) const { return m_val > rhs.m_val; }
        constexpr bool operator<=(const mint &rhs) const { return m_val <= rhs.m_val; }
        constexpr bool operator>=(const mint &rhs) const { return m_val <= rhs.m_val; }
        template <typename Tp>
        constexpr explicit operator Tp() const { return Tp(m_val); }
        friend constexpr mint operator+(const mint &a, const mint &b) { return mint(a) += b; }
        friend constexpr mint operator-(const mint &a, const mint &b) { return mint(a) -= b; }
        friend constexpr mint operator*(const mint &a, const mint &b) { return mint(a) *= b; }
        friend constexpr mint operator/(const mint &a, const mint &b) { return mint(a) /= b; }
        constexpr static mint identity() { return 1; }
    };
    template <typename Istream, uint32_t P, bool IsPrime>
    Istream &operator>>(Istream &is, StaticModInt32<P, IsPrime> &x) { return is >> x.m_val; }
    template <typename Ostream, uint32_t P, bool IsPrime>
    Ostream &operator<<(Ostream &os, const StaticModInt32<P, IsPrime> &x) { return os << x.val(); }
    using mint998244353 = StaticModInt32<998244353, true>;
    using mint1000000007 = StaticModInt32<1'000'000'007, true>;
}

#endif
using Z = OY::mint1000000007;

const int N = 300;
Z ans[N + 1][N + 1][N + 1];

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

    int n, q;
    std::cin >> n >> q;
    std::string s;
    std::cin >> s;

    std::vector dp(n + 1, std::vector(n + 1, std::vector<Z>(3)));
    if (s[0] == '?') {
        dp[1][0][0] = 1;
        dp[0][1][1] = 1;
        dp[0][0][2] = 1;
    } else {
        dp[0][0][s[0] - 'a'] = 1;
    }
    for (int i = 1; i < n; i++) {
        std::vector ndp(n + 1, std::vector(n + 1, std::vector<Z>(3)));
        if (s[i] == 'a') {
            for (int j = 0; j <= n; j++) {
                for (int k = 0; k <= n; k++) {
                    ndp[j][k][0] += dp[j][k][1] + dp[j][k][2];
                }
            }
        } else if (s[i] == 'b') {
            for (int j = 0; j <= n; j++) {
                for (int k = 0; k <= n; k++) {
                    ndp[j][k][1] += dp[j][k][0] + dp[j][k][2];
                }
            }
        } else if (s[i] == 'c') {
            for (int j = 0; j <= n; j++) {
                for (int k = 0; k <= n; k++) {
                    ndp[j][k][2] += dp[j][k][0] + dp[j][k][1];
                }
            }
        } else {
            for (int j = 0; j <= n; j++) {
                for (int k = 0; k <= n; k++) {
                    if (j + 1 <= n) {
                        ndp[j + 1][k][0] += dp[j][k][1] + dp[j][k][2];
                    }
                    if (k + 1 <= n) {
                        ndp[j][k + 1][1] += dp[j][k][0] + dp[j][k][2];
                    } 
                    ndp[j][k][2] += dp[j][k][0] + dp[j][k][1];
                }
            }
        }
        dp = ndp;
    }

    int cnt = std::count(s.begin(), s.end(), '?');
    for (int i = 0; i <= cnt; i++) {
        for (int j = 0; i + j <= cnt; j++) {
            ans[i][j][cnt - i - j] += dp[i][j][0] + dp[i][j][1] + dp[i][j][2];
        }
    }

    for (int i = 0; i <= N; i++) {
        for (int j = 0; j <= N; j++) {
            for (int k = 0; k <= N; k++) {
                if (i) ans[i][j][k] += ans[i - 1][j][k];
                if (j) ans[i][j][k] += ans[i][j - 1][k];
                if (k) ans[i][j][k] += ans[i][j][k - 1];
                if (i && j) ans[i][j][k] -= ans[i - 1][j - 1][k];
                if (i && k) ans[i][j][k] -= ans[i - 1][j][k - 1];
                if (j && k) ans[i][j][k] -= ans[i][j - 1][k - 1];
                if (i && j && k) ans[i][j][k] += ans[i - 1][j - 1][k - 1];
            }
        }
    }

    while (q--) {
        int a, b, c;
        std::cin >> a >> b >> c;
        std::cout << ans[a][b][c] << '\n';
    }

    return 0;
}