#include <bits/stdc++.h>

using namespace std;
#define PB push_back
#define LL long long
#define int LL
#define FOR(i,a,b) for (int i = (a); i <= (b); i++)
#define FORD(i,a,b) for (int i = (a); i >= (b); i--)
#define REP(i,n) FOR(i,0,(int)(n)-1)
#define st first
#define nd second
#define ALL(x) (x).begin(), (x).end()
#define SZ(x) ((int)(x).size())
#define VI vector<int>
#define PII pair<int,int>
#define LD long double


template<class T> ostream &operator<<(ostream &os, vector<T> V){
    os<<"[";for(auto vv:V)os<<vv<<",";return os<<"]";
}
template<class T, size_t N> ostream &operator<<(ostream &os, array<T, N> V){
    os<<"[";for(auto vv:V)os<<vv<<",";return os<<"]";
}


template<class L, class R> ostream &operator<<(ostream &os, pair<L,R> P) {
    return os << "(" << P.st << "," << P.nd << ")";
}



template<class C> void mini(C& a4, C b4) { a4 = min(a4, b4); }
template<class C> void maxi(C& a4, C b4) { a4 = max(a4, b4); }

template<class TH> void _dbg(const char *sdbg, TH h){cerr<<sdbg<<"="<<h<<"\n";}
template<class TH, class... TA> void _dbg(const char *sdbg, TH h, TA... a) {
    while(*sdbg!=',')cerr<<*sdbg++;cerr<<"="<<h<<","; _dbg(sdbg+1, a...);
}


#ifdef LOCAL
#define debug(...) _dbg(#__VA_ARGS__, __VA_ARGS__)
#else
#define debug(...) (__VA_ARGS__)
#define cerr if(0)cout
#endif

int n,q;
string s;
vector<int> cnt(3);
vector<int> matching(2);

const int mod = 1e9 + 7;

bool match(char c, int idx, bool option){
    switch(c){
        case 'N':
            return true;
        case 'C':
            return option ^ (idx & 1);
        case 'Z':
            return !option ^ (idx & 1);
        default:
            assert(false);
    }
}

int char2int(char c){
    switch(c){
        case 'N':
            return 0;
        case 'C':
            return 1;
        case 'Z':
            return 2;
        default:
            assert(false);
    }
}

char int2char(int idx){
    switch(idx){
        case 0:
            return 'N';
        case 1:
            return 'C';
        case 2:
            return 'Z';
        default:
            assert(false);
    }
}

void update(int idx, int diff){
    REP(j, 2){
        matching[j] += diff * match(s[idx], idx, j);
    }
    cnt[char2int(s[idx])] += diff;
}
// 3x3 array
typedef array<array<int, 3>, 3> State;

State get_basic(char c){
    State result;
    switch(c){
        case 'N':
            result = {{{0, 1, 1}, {1, 0, 1}, {1, 1, 0}}};
            break;
        case 'C':
            result = {{{0, 0, 1}, {1, 0, 0}, {0, 1, 0}}};
            break;
        case 'Z':
            result = {{{0, 1, 0}, {0, 0, 1}, {1, 0, 0}}};
            break;
        default:
            assert(false);
    }
    return result;
}

// matrix multiply State
State operator*(const State& a, const State& b){
    State result;
    REP(i, 3){
        REP(j, 3){
            result[i][j] = 0;
            REP(k, 3){
                result[i][j] += a[i][k] * b[k][j];
                result[i][j] %= mod;
            }
        }
    }
    return result;
}

// *= operator
State& operator*=(State& a, const State& b){
    a = a * b;
    return a;
}

State power(State a, int p){
    State result;
    REP(i, 3){
        REP(j, 3){
            result[i][j] = (i == j);
        }
    }
    while(p){
        if(p & 1){
            result = result * a;
        }
        a = a * a;
        p >>= 1;
    }
    return result;
}

vector<vector<State>> states(3, vector<State>(200 * 1000 + 1));

int get_ans() {
    State result = {
            {{1, 0, 0}, {0, 1, 0}, {0, 0, 1}}
    };
    REP(i, 3) {
//        result *= power(get_basic(int2char(i)), cnt[i]);
        result *= states[i][cnt[i]];
    }
    int answer = result[0][1] + result[0][2];
    answer %= mod;
    debug(matching);
    if (n & 1)
        answer -= (matching[0] == n) + (matching[1] == n);
    if (answer < 0) {
        answer += mod;
    }
    return answer;
}

void preproc(){
    REP(i, 3){
        State result = {
                {{1, 0, 0}, {0, 1, 0}, {0, 0, 1}}
        };
        states[i][0] = result;
        REP(j, 200 * 1000){
            states[i][j + 1] = states[i][j] * get_basic(int2char(i));;
        }
    }
};

int32_t main() {
    // initialize default random engine
    preproc();
    default_random_engine gen;
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    cout << fixed << setprecision(11);
    cerr << fixed << setprecision(6);
    cin >> n >> q;
    cin >> s;
    REP(i, n){
        update(i, 1);
    }
    cout << get_ans() << "\n";

    REP(_, q){
        int i;
        char c;
        cin >> i >> c;
        i--;
        update(i, -1);
        s[i] = c;
        update(i, 1);
        cout << get_ans() << "\n";
    }
}