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

#define MOD 1000000007

string S;
int tree[400005][26], lazy[400005], tmp[26];
long long two[100005], dp[27][2];

long long solve(vector<int> z)
{
    dp[0][0] = 1;
    
    //for(int i=0; i<26; i++)
    //    cout << z[i] << " ";
    //cout << endl;
    
    for(int i=1; i<=26; i++)
    {
        dp[i][0] = max(1LL, two[z[i-1]-1])*dp[i-1][0]%MOD;
        dp[i][1] = (two[z[i-1]-1]*dp[i-1][0] + max(1LL, two[z[i-1]-1])*dp[i-1][1])%MOD;
    }
    
    return (dp[26][0] + dp[26][1] - 1 + MOD)%MOD;
}

void shifter(int indx, int t)
{
    for(int i=0; i<26; i++)
        tmp[i] = tree[indx][i];
    
    for(int i=0; i<26; i++)
        tree[indx][(i+t)%26] = tmp[i];
}

void proLazy(int left, int right, int root)
{
    if(left>right)
        return;
    
    shifter(root, lazy[root]);
    
    if(left!=right)
    {
        lazy[root*2] = (lazy[root*2] + lazy[root])%26;
        lazy[root*2+1] = (lazy[root*2+1] + lazy[root])%26;
    }
    
    lazy[root] = 0;
}

vector<int> getAns(int left, int right, int L, int R, int root)
{
    if(lazy[root])
        proLazy(left, right, root);
    
    if(left>right || left>R || right<L)
    {
        vector<int> x(26, 0);
        return x;
    }
    
    if(left>=L && right<=R)
    {
        vector<int> x(26, 0);
        
        for(int i=0; i<26; i++)
            x[i] += tree[root][i];
        
        return x;
    }
    
    int mid = (left+right)/2;
    
    vector<int> x = getAns(left, mid, L, R, root*2);
    vector<int> y = getAns(mid+1, right, L, R, root*2+1);
    
    vector<int> z(26, 0);
    
    for(int i=0; i<26; i++)
        z[i] = x[i] + y[i];
    
    return z;
}

void update(int left, int right, int L, int R, int t, int root)
{
    if(lazy[root])
        proLazy(left, right, root);
    
    if(left>right || left>R || right<L)
        return;
    
    if(left>=L && right<=R)
    {
        shifter(root, t);
        
        if(left!=right)
        {
            lazy[root*2] = (lazy[root*2] + t)%26;
            lazy[root*2+1] = (lazy[root*2+1] + t)%26;
        }
        
        return;
    }
    
    int mid = (left+right)/2;
    
    update(left, mid, L, R, t, root*2);
    update(mid+1, right, L, R, t, root*2+1);
    
    for(int i=0; i<26; i++)
        tree[root][i] = tree[root*2][i] + tree[root*2+1][i];
}

void build(int left, int right, int root)
{
    if(left>right)
        return;
    
    if(left==right)
    {
        tree[root][S[left]-'a']++;
        return;
    }
    
    int mid = (left+right)/2;
    
    build(left, mid, root*2);
    build(mid+1, right, root*2+1);
    
    for(int i=0; i<26; i++)
        tree[root][i] = tree[root*2][i] + tree[root*2+1][i];
}

int main(){
    
    int N, Q;
    cin >> N >> Q;
    
    two[0] = 1;
    
    for(int i=1; i<=100000; i++)
        two[i] = two[i-1]*2%MOD;
    
    cin >> S;
    build(0, N-1, 1);
    
    while(Q--)
    {
        int type;
        cin >> type;
        
        if(type==1)
        {
            int i, j, t;
            cin >> i >> j >> t;
            
            update(0, N-1, i, j, t%26, 1);
        }
        else
        {
            int i, j;
            cin >> i >> j;
            
            cout << solve(getAns(0, N-1, i, j, 1)) << endl;
        }
    }
    
    return 0;
}