#include <iostream>
using namespace std;
#include <set>
#include <algorithm>
#include <cmath>
#include <map>
#include <cstdio>
#include <string>
#include <cstring>
#include <string.h>
#include <stdlib.h>
#include <iomanip>
#include <fstream>
#include <stdio.h>
#include <stack>
#include <queue>
#include <ctype.h>
#include <vector>
#include <random>
#include<list> 
#define ll long long
#define ull unsigned long long
#define pb push_back
#define rep(i, a, n) for (int i = a; i <= n; i++)
#define per(i, a, n) for (int i = n; i >= a; i--)
#define pii pair<int, int>
#define pli pair<ll, int>
#define pil pair<int, ll>
#define pll pair<ll, ll>
#define lowbit(x) ((x)&(-x))
ll extend_gcd(ll a, ll b, ll &x, ll &y)
{
    if (b == 0)
    {
        x = 1;
        y = 0;
        return a;
    }
    ll d = extend_gcd(b, a % b, y, x);
    y -= a / b * x;
    return d;
}
ll fastpow(ll a, ll n, ll mod)
{
    ll ans = 1;
    a %= mod;
    while (n)
    {
        if (n & 1)
            ans = (ans * a) % mod; //% mod
        a = (a * a) % mod;         //% mod
        n >>= 1;
    }
    return ans;
}

inline void write(__int128 x)
{
    if (x > 9)
    {
        write(x / 10);
    }
    putchar(x % 10 + '0');
}
__int128 sqrt(__int128 m)
{
    __int128 leftt = 0, rightt = ((__int128)1) << 51, ret = -1, mid;
    while (leftt < rightt)
    {
        mid = (leftt + rightt) / 2;
        if (mid * mid > m)
        {
            rightt = mid;
        }    
        else
        {
            leftt = mid + 1;
            ret = mid;
        }
    }
    return ret;
}

const double eps = 1e-6;
int sgn(double x)
{
    if(fabs(x)<eps)
    {
        return 0;
    }
    else return x<0?-1:1;
}

struct Point
{
    double x,y;
    Point()
    {

    }
    Point(double x,double y):x(x),y(y)
    {

    }
    Point operator + (Point B)
    {
        return Point(x+B.x,y+B.y);
    }
    Point operator - (Point B)
    {
        return Point(x-B.x,y-B.y);
    }
    bool operator == (Point B)
    {
        return sgn(x-B.x)==0&&sgn(y-B.y)==0;
    }
    bool operator < (Point B)
    {
        return sgn(x-B.x)<0||(sgn(x-B.x)==0&&sgn(y-B.y)<0);
    }
};
typedef Point Vector;
double Cross(Vector A,Vector B)//叉积
{
    return A.x*B.y-A.y*B.x;
}
double Distance(Point A,Point B)
{
    return hypot(A.x-B.x,A.y-B.y);
}
int Convex_hull(Point *p,int n,Point *ch)
{
    n=unique(p,p+n)-p;
    sort(p,p+n);
    int v=0;

    for(int i=0;i<n;i++)
    {
        while (v>1&&sgn(Cross(ch[v-1]-ch[v-2],p[i]-ch[v-1]))<=0)
        {
            v--;
        }
        ch[v++]=p[i];
    }

    int j=v;

    for(int i=n-2;i>=0;i--)
    {
        while (v>j&&sgn(Cross(ch[v-1]-ch[v-2],p[i]-ch[v-1]))<=0)
        {
            v--;
        }
        ch[v++]=p[i];
    }
    if(n>1)
    {
        v--;
    }
    return v;
}

int kmp(string s, string p)
{
    int ans = 0, lastt = -1;
    int lenp = p.size();
    vector<int > Next(lenp+3,0);
    rep(i, 1, lenp - 1)
    {
        int j = Next[i];
        while (j && p[j] != p[i])
        {
            j = Next[j];
        }
        if (p[j] == p[i])
        {
            Next[i + 1] = j + 1;
        }
        else
        {
            Next[i + 1] = 0;
        }
    }
    int lens = s.size();
    int j = 0;
    rep(i, 0, lens - 1)
    {
        while (j && s[i] != p[j])
        {
            j = Next[j];
        }
        if (s[i] == p[j])
        {
            j++;
        }
        if (j == lenp)
        {
            ans++;
        }
    }
    return ans;
}

int dir[4][2] =
    {
        {-1, 0}, {0, 1}, {1, 0}, {0, -1}}; // 左右上下
// int dir[8][2]={
//         {-1, 0}, {0, 1}, {1, 0}, {0, -1},{-1,-1},{-1,1},{1,-1},{1,1}
// };

#define endl '\n'//交互题请删除本行
const ll inf = 1000000000000000000ll;
const ll mod1 = 1e9+7ll, P1 = 131, mod2 = 1e9 + 7ll, P2 = 13331;
ll inverse(ll x)
{
    return fastpow(x,mod1-2,mod1);
}

const int N = 300 + 10, M = 1e6 + 10;

///////////////////////////////////

int tt;

int n,qq;

string s;
int lens;

ll dp[N][N][N][4];

ll a[N][N][N],sum[N][N][N];

ll f[N][N][N];

int cnt[N];

bool flag=1;

///////////////////////////////////



///////////////////////////////////

void init()
{

}

///////////////////////////////////

int main()
{
    ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);//交互题请删除本行
   // freopen("ain.txt", "r", stdin); freopen("aout.txt", "w", stdout);
    
    cin>>n>>qq>>s;
    lens=s.size();
    
    s=' '+s;
    rep(i,2,lens)
    {
        if(s[i]==s[i-1]&&s[i]!='?')
        {
            while (qq--)
            {
                cout<<0<<endl;
            }
            exit(0);
           
        }

        cnt[i]=cnt[i-1];
        if(s[i]=='?')
        {
            cnt[i]++;
        }

    }

    if(s[1]=='?')
    {
        dp[1][1][0][0]=dp[1][0][1][1]=dp[1][0][0][2]=1;
    }
    else
    {
        dp[1][0][0][s[1]-'a']=1;
    }

    

    rep(i,2,lens)
    {
        rep(ca,0,cnt[i])
        {
            rep(cb,0,cnt[i]-ca)
            {
                if(s[i]!='?')
                {
                    ll add=0;
                    rep(j,0,2)
                    {
                        add+=dp[i-1][ca][cb][j];
                        add%=mod1;
                    }
                    add-=dp[i-1][ca][cb][s[i]-'a'];
                    add+=mod1;
                    add%=mod1;
                    dp[i][ca][cb][s[i]-'a']=add;
                }
                else
                {
                    if(ca)
                    {
                        dp[i][ca][cb][0]=dp[i-1][ca-1][cb][1]+dp[i-1][ca-1][cb][2];
                        dp[i][ca][cb][0]%=mod1;
                    }

                    if(cb)
                    {
                        dp[i][ca][cb][1]=dp[i-1][ca][cb-1][0]+dp[i-1][ca][cb-1][2];
                        dp[i][ca][cb][1]%=mod1;
                    }

                    if(cnt[i]-ca-cb)
                    {
                        dp[i][ca][cb][2]=dp[i-1][ca][cb][0]+dp[i-1][ca][cb][1];
                        dp[i][ca][cb][2]%=mod1;
                    }
                }
            }
        }
    }

    rep(i,0,300)
    {
        rep(j,0,cnt[lens]-i)
        {
            ll num=0;
            rep(ii,0,2)
            {
                num+=dp[lens][i][j][ii];
                num%=mod1;
            }

            f[i][j][cnt[lens]-i-j]=num;   
            //
            //cout<<i<<" "<<j<<" "<<cnt[lens]-i-j<<" "<<a[i][j][cnt[lens]-i-j]<<endl;
        }
    }

    // rep(i,0,300)
    // {
    //     rep(j,0,300)
    //     {
    //         rep(ii,0,300)
    //         {
    //             sum[i][j][ii]=a[i][j][ii];
    //             vector<int > zhi;
    //             zhi.resize(4);

    //             vector<int > shiji;
    //             shiji.resize(4);
    //             rep(jj,0,6)
    //             {
    //                 zhi[0]=jj/4;
    //                 zhi[1]=jj/2%2;
    //                 zhi[2]=jj%2;

    //                 shiji[0]=i;
    //                 shiji[1]=j;
    //                 shiji[2]=ii;

    //                 bool fla=1;
    //                 int num=0;
    //                 rep(iii,0,2)
    //                 {
    //                     num+=zhi[iii];
    //                     if(zhi[iii]&&shiji[iii]==0)
    //                     {
    //                         fla=0;
    //                         break;
    //                     }
    //                 }

    //                 if(fla==0)
    //                 {
    //                     continue;
    //                 }

    //                 if(num%2==1)
    //                 {
    //                     sum[i][j][ii]+=sum[i-zhi[0]][j-zhi[1]][ii-zhi[2]];
    //                     sum[i][j][ii]%=mod1;
    //                     //
    //                     cout<<sum[i-zhi[0]][j-zhi[1]][ii-zhi[2]]<<endl;
    //                 }
    //                 else
    //                 {
    //                     sum[i][j][ii]-=sum[i-zhi[0]][j-zhi[1]][ii-zhi[2]];
    //                     //
    //                     cout<<sum[i-zhi[0]][j-zhi[1]][ii-zhi[2]]<<endl;
    //                     sum[i][j][ii]+=mod1;
    //                     sum[i][j][ii]%=mod1;
    //                 }
                    

    //             }
    //         }
    //     }
    // }

    for (int i = 0; i <= 300; i++)
    {
        for (int j = 0; j <= 300; j++)
        {
            for (int k = 0; k <= 300; k++)
            {
                if (i > 0)
                    f[i][j][k] += f[i - 1][j][k];
                if (j > 0)
                    f[i][j][k] += f[i][j - 1][k];
                if (k > 0)
                    f[i][j][k] += f[i][j][k - 1];
                if (i && j)
                    f[i][j][k] += mod1 - f[i - 1][j - 1][k];
                if (k && j)
                    f[i][j][k] += mod1 - f[i][j - 1][k - 1];
                if (i && k)
                    f[i][j][k] += mod1 - f[i - 1][j][k - 1];
                if (i && j && k)
                    f[i][j][k] += f[i - 1][j - 1][k - 1];
                f[i][j][k] %= mod1;
            }
        }
    }

    

    
    while (qq--)
    {
        int a,b,c;
        cin>>a>>b>>c;
        if(flag==0)
        {
            cout<<0<<endl;
        }
        else
        {
            cout<<f[a][b][c]<<endl;
        }
    }
    

    return 0;
}