#include <cmath>
#include <cstdio>
#include <vector>
#include <iostream>
#include <algorithm>
using namespace std;

unsigned long long MOD = 1E9+7; 

unsigned long long fastPower(unsigned long long  base , unsigned long long  power){
    if ( power == 0 )
        return 1 ;
    else if((power & 1) == 0 )
        return fastPower(base*base,power/2)%MOD;
    else
        return base * fastPower(base,power-1)%MOD;
}

unsigned long long countPalindroms(int t[26]){
    unsigned long long odd = 1, even = 0;
    
    for(int i=0; i<26; i++){
        if(t[i] == 0) continue;
        unsigned long long newValue = fastPower(2, t[i]-1);
        even = (even+odd) * newValue;
        odd = (odd) * newValue;
        
        even %= MOD;
        odd %= MOD;
    }
    
    return (odd+even-1)%MOD;
}

class element{
public:
    int t[26];
    int shift; 
    element(){
        for(int i=0; i<26; i++){
            t[i] = 0;
        }
        shift = 0;
    }
};

element sum(element & A, element & B){
    element el;
    for(int i=0; i<26; i++){
        el.t[i] = A.t[i]+B.t[i];
    }
    return el;
}

class segment{
    element * T;
    int size;
    int first_leaf;
    
    int left_son(int i){return 2*i;}
    int right_son(int i){return 2*i+1;}
    int parent(int i){return i/2;}
    int brother(int i){return 4*parent(i)+1 - i;}
    bool has_children(int i){return i<first_leaf;}
    bool is_left_son(int i){return (i&1) == 0;}
    bool is_right_son(int i){return (i&1) == 1;}
    bool is_root(int i){return i==1;}
    bool are_brothers(int i, int j){return i/2 == j/2;}
    
public:
    segment(string s){
        int len = s.length();
        size = 1;
        while(size<len) size <<= 1;
        first_leaf = size;
        size <<= 1;
        T = new element[size+1];
        
        for(int i=0; i<len; i++){
            T[first_leaf+i].t[s[i]-'a']++;
        }
        
        for(int i=first_leaf-1; i>0; i--){
            T[i] = sum(T[left_son(i)], T[right_son(i)]);
        }
    }
    
    element count(int i, int j){
        if (i>j) swap(i,j);
        i += first_leaf;
        j += first_leaf;
        
        element el;
        el = sum(el, T[i]);
        if(i != j){
            el = sum(el, T[j]);
        }
        
        while(!are_brothers(i, j)){
            if(is_left_son(i)){
                el = sum(el, T[brother(i)]);
            }
            i = parent(i);
            if(is_right_son(j)){
                el = sum(el, T[brother(j)]);
            }
            j = parent(j);
        }
        return el;
    }
};


int main() {
    int n, q;
    cin >> n >> q;
    string s;
    cin >> s;
    segment tree(s);
    
    while(q--){
        int a, i, j, t;
        cin >> a;
        if (a==1){
            cin >> i >> j >> t;
        }
        else{
            cin >> i >> j;
            element el = tree.count(i, j);
            cout << countPalindroms(el.t) << endl;
        }
    }
    
    return 0;
}

int mainn(){
    element el;
    el.t[1] = 2;
    element el2;
    el2.t[0] = 3;
    el2.t[1] = 4;
    
    element el3 = sum(el, el2);
    
    for(int i=0; i<3; i++){
        cout << el3.t[i] << " ";
    }
    return 0;
}