#include <map>
#include <set>
#include <list>
#include <cmath>
#include <ctime>
#include <deque>
#include <queue>
#include <stack>
#include <string>
#include <bitset>
#include <cstdio>
#include <limits>
#include <vector>
#include <climits>
#include <cstring>
#include <cstdlib>
#include <fstream>
#include <numeric>
#include <sstream>
#include <iostream>
#include <algorithm>
#include <unordered_map>

using namespace std;

struct Node {
  int sum[26];
  int rotate;
};

const int maxn = 100010;
const int maxit = 1 << 17;

Node it[maxit * 2];

void shift ( int u, int rotate ) {
  int sum[26];
  for (int i = 0; i < 26; i++)
    sum[i] = it[u].sum[i];
  it[u].rotate += rotate;
  it[u].rotate %= 26;
  for (int i = 0; i < 26; i++)
    it[u].sum[(i + rotate) % 26] = sum[i];
}

void push ( int u ) {
  if (it[u].rotate == 0)
    return;
  if (u < maxit) {
    shift (2 * u, it[u].rotate);
    shift (2 * u + 1, it[u].rotate);
    for (int i = 0; i < 26; i++)
      it[u].sum[i] = it[2 * u].sum[i] + it[2 * u + 1].sum[i];
  }
  it[u].rotate = 0;
}

void update ( int u ) {
  push (u);
  for (int i = 0; i < 26; i++)
    it[u].sum[i] = it[2 * u].sum[i] + it[2 * u + 1].sum[i];
}

void it_shift ( int u, int L, int R, int l, int r, int rotate ) {
  if (r < L || l > R)
    return;
  if (l <= L && R <= r) {
    shift (u, rotate);
    return;
  }
  push (u);
  it_shift (2 * u, L, (L + R) / 2, l, r, rotate);
  it_shift (2 * u + 1, (L + R + 1) / 2, R, l, r, rotate);
  update (u);
}

void it_sum ( int u, int L, int R, int l, int r, int *sum ) {
  // fprintf (stderr, "it_sum (u=%d, LR = %d-%d, lr=%d-%d ...)\n", u, L, R, l, r);
  if (r < L || l > R)
    return;
  if (l <= L && R <= r) {
    for (int i = 0; i < 26; i++)
      sum[i] += it[u].sum[i];
    return;
  }
  push (u);
  it_sum (2 * u, L, (L + R) / 2, l, r, sum);
  it_sum (2 * u + 1, (L + R + 1) / 2, R, l, r, sum);
}

const long long modulo = (int)1e9 + 7;
long long d0[maxn], d1[maxn];

int main(){
  d0[0] = 1;
  d1[0] = 0;
  for (int i = 1; i < maxn; i++) {
    d1[i] = (d0[i - 1] + d1[i - 1]) % modulo;
    d0[i] = (d0[i - 1] + d1[i - 1]) % modulo;
  }
    int n;
    int q;
    cin >> n >> q;
    string s;
    cin >> s;
    memset (it, 0, sizeof (it));
    for (int i = 0; i < n; i++) {
      it[maxit + i].rotate = s[i] - 'a';
      it[maxit + i].sum[s[i] - 'a']++;
    }
    for (int i = maxit - 1; i >= 1; i--)
      update (i);
    for(int a0 = 0; a0 < q; a0++){
      int t, a, b, r;
      cin >> t;
      if (t == 1) {
        cin >> a >> b >> r;
        it_shift (1, 0, maxit - 1, a, b, r % 26);
      } else if (t == 2) {
        int sum[26];
        long long p1[27], p2[27], res = 0;
        for (int i = 0; i < 26; i++)
          sum[i] = 0;
        cin >> a >> b;
        // fprintf (stderr, "!!!\n");
        it_sum (1, 0, maxit - 1, a, b, sum);
        /*
        fprintf (stderr, "query #%d\n", a0);
        for (int i = 0; i < 26; i++)
          if (sum[i])
            fprintf (stderr, "sum[i=%d:%c] = %d\n", i, 'a' + i, sum[i]);
        //*/
        p1[0] = p2[26] = 1;
        for (int i = 0; i < 26; i++)
          p1[i + 1] = (p1[i] * d0[sum[i]]) % modulo;
        for (int i = 25; i >= 0; i--)
          p2[i] = (p2[i + 1] * d0[sum[i]]) % modulo;
        for (int i = 0; i < 26; i++) {
          res += (p1[i] * d1[sum[i]]) % modulo * p2[i + 1];
          res %= modulo;
        }
        res = (res + p1[26]) % modulo; // even palyndrome
        res = (res + modulo - 1) % modulo; // empty string
        cout << res << endl;
      }
    }
    return 0;
}