#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#define ssize(x) int(x.size())
#define pb push_back
#define mp make_pair
#define all(a) begin(a),end(a)
// #define FOR(i, l, r) for(int i = (l); i <= (r); ++i)
#define FOR(i, l, r) for(int i = (l); i < (r); ++i)
#define FORE(i, l, r) for(int i = (l); i <= (r); ++i)
// # define REP(i, n) FOR(i, 0, (n) - 1)
# define REP(i, n) FORE(i, 0, (n) - 1)
#define FORR(x,arr) for(auto &x: arr)
#define REE(s_) {cout<<s_<<'\n';exit(0);}
#define GET(arr) for(auto &i: (arr)) sc(i)
#define e1 first
#define e2 second
#define INF 0x7f7f7f7f
#define debug(x...) cerr << "[" #x "]: ", [](auto... $) {((cerr << $ << "; "),...); }(x), cerr << '\n'
typedef std::pair<int,int> pi;
typedef std::vector<int> vi;
typedef std::vector<std::string> vs;
typedef int64_t ll;
typedef uint64_t ull;
using namespace std;
using namespace __gnu_pbds;

#ifdef ONLINE_JUDGE
#define debug(...) {}
#endif
#ifdef _WIN32
#define getchar_unlocked() _getchar_nolock()
#define _CRT_DISABLE_PERFCRIT_LOCKS
#endif
template<class A, class B> auto& operator<<(ostream &o, pair<A, B> p) { return o << '(' << p.first << ", " << p.second << ')'; }
template<class T> auto operator<<(ostream &o, T x) -> decltype(x.end(), o) { o << '{'; int i = 0; for(auto e : x) o << (", ")+2*!i++ << e; return o << '}'; }
inline int fstoi(const string &str){auto it=str.begin();bool neg=0;int num=0;if(*it=='-')neg=1;else num=*it-'0';++it;while(it<str.end()) num=num*10+(*it++-'0');if(neg)num*=-1;return num;}
inline void getch(char &x){while(x = getchar_unlocked(), x < 33){;}}
inline void getstr(string &str){str.clear(); char cur;while(cur=getchar_unlocked(),cur<33){;}while(cur>32){str+=cur;cur=getchar_unlocked();}}
template<typename T> inline bool sc(T &num){ bool neg=0; int c; num=0; while(c=getchar_unlocked(),c<33){if(c == EOF) return false;} if(c=='-'){ neg=1; c=getchar_unlocked(); } for(;c>47;c=getchar_unlocked()) num=num*10+c-48; if(neg) num*=-1; return true;}template<typename T, typename ...Args> inline void sc(T &num, Args &...args){ bool neg=0; int c; num=0; while(c=getchar_unlocked(),c<33){;} if(c=='-'){ neg=1; c=getchar_unlocked(); } for(;c>47;c=getchar_unlocked()) num=num*10+c-48; if(neg) num*=-1; sc(args...); }
template<typename T> using ordered_set = tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>; //s.find_by_order(), s.order_of_key() <- works like lower_bound
template<typename T> using ordered_map = tree<T, int, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
// 1 << 19 if segtree where merges matter.
#define N 1000001

constexpr int64_t mod = 1000000007;
inline int64_t fastpow(int64_t a, int64_t b){
    if(b == 0)
        return 1;
    if(b&1){
        return (a * fastpow(a,b^1)) % mod;
    }
    a = fastpow(a,b >> 1);
    return (a*a)%mod;
}

ll fac[N];
ll facinv[N];

// constexpr btw?
// -> operation limit that can't be changed by a pragma is too low. (agc051a.cpp tried on pc)
void pre(){
    fac[0] = 1;
    FOR(i,1,N)
        fac[i] = fac[i - 1] * i % mod;
    if constexpr (mod == 1000000007 && N == 1000001)
        facinv[N - 1] = 397802501;
    else
        facinv[N - 1] = fastpow(fac[N - 1], mod - 2);
    for(int i = N - 2; i >= 0; --i)
        facinv[i] = facinv[i + 1] * (i + 1) % mod;
    // Also i^-1 = facinv[i] * fac[i - 1] (i in 1..n)
    // Similary idea can be used to get invs of any n numbers in O(n + logp).
    // -> zamiast *1, *2, *3... do *a[0], *a[1], *a[2]...
}

ll binom(ll n, ll k){
    if(n < k || n < 0)
        return 0;
    return fac[n] * facinv[k] % mod * facinv[n - k] % mod;
}

int main(){
    ios_base::sync_with_stdio(0);cin.tie(0);
    pre();
    int n, q;
    sc(n, q);
    ll pw2[n + 1];
    pw2[0] = 1;
    FORE(i,1,n)
        pw2[i] = pw2[i - 1] * 2 % mod;
    vector<pi> bads;
    // n == 1 edge.
    if(n >= 2)
        bads.push_back({1, 1});
    FORE(crn,3,n){
        vector<pi> nwbads;
        FORR(i,bads){
            auto tryadd = [&](int f, int s){
                if(s < 0 || f < 0)
                    return;
                if(f > s)
                    swap(f,s);
                nwbads.emplace_back(f, s);
            };
            tryadd(i.e1 + 2, i.e2 - 1);
            if(nwbads.size() == 1)
                break;
            tryadd(i.e1 - 1, i.e2 + 2);
            if(nwbads.size() == 1)
                break;
        }
        bads = nwbads;
        bads.erase(unique(all(bads)), bads.end());
        /* debug(crn, bads.size()); */
    }
    /* exit(0); */
    sort(all(bads));
    /* int pre[3][n + 1]; */
    /* REP(md,3){ */
    /*     pre[md][]; */
    /* } */
    /* debug(bads); */
    string s;
    getstr(s);
    int mdcnts[2]{};
    int cnt[128]{};
    int it = 0;
    FORR(i,s){
        ++cnt[i];
    // rip jane street
        if(i == 'C'){
            ++mdcnts[it & 1];
        }
        else if(i == 'Z'){
            ++mdcnts[(it ^ 1) & 1];
        }
        ++it;
    }
    // EZZZZZZZZZZ clutch 1h przed końcem.
    // (rozpisanie binomial coeffów trzeba zachować na ostateczność, wcześniej można tylko googlować)
    ll sums[n+1][3];
    sums[0][0] = 1;
    sums[0][1] = 0;
    sums[0][2] = 0;
    FORE(i,1,n){
        REP(x,3){
            sums[i][x] = sums[i - 1][x] + sums[i - 1][(x - 1 + 3) % 3];
            sums[i][x] %= mod;
            /* debug(i, x, sums[i][x]); */
        }
    }
    int whcmod = bads[0].e1 % 3;
    // yes jane street.
    auto calc_res = [&](){
        if(n == 1){
            return (long ) (1 + (s[0] == 'N'));
        }
        ll res = 0;
        res = pw2[cnt['N']];
        REP(ile,cnt['N'] + 1){
            /* pi wh = {cnt['C'] + ile, cnt['Z'] + cnt['N'] - ile}; */
            /* if(wh.e1 > wh.e2) */
            /*     swap(wh.e1, wh.e2); */
            /* if(binary_search(all(bads), wh)){ */
            /*     /1* debug(ile); *1/ */
            /*     /1* res -= binom(cnt['N'], ile); *1/ */
            /*     res -= sums[cnt['N']][ile % 3]; */
            /*     break; */
            /* } */
            /* int sthhhh = whcmod - cnt['C']; */

            // EZZZZZZZZZZZZZZZZZZZZZZZZZZZZ.
            // Zakomentowanie 10 linijek i dodanie trzech to obtain the speeed.
            // Like it's 2020.

            int sthhhh = bads[0].e1 - cnt['C'];
            sthhhh %= 3;
            sthhhh += 3;
            sthhhh %= 3;
            res -= sums[cnt['N']][sthhhh % 3];
            break;
        }
        pi sth = {n / 2, n / 2};
        if(sth.e1 + sth.e2 < n)
            ++sth.e2;
        assert(sth.e1 + sth.e2 == n);
        // Czej WTF. how is that not bugged?
        // -> somehow jak breakuje po pierwszym, to zawsze mam closest do siebie, ale fart xddddd.
        if(!binary_search(all(bads), sth)){
            res -= mdcnts[0] == 0;
            res -= mdcnts[1] == 0;
        }
        /* REP(_,2){ */
        /*     FORR(i,bads){ */
        /*         res -= binom(cnt['N'], ); */
        /*     } */
        /*     swap(cnt['C'], cnt['Z']); */
        /* } */
        res %= mod;
        res += mod;
        res %= mod;
        return res;
    };
    cout << calc_res() << '\n';
    while(q--){
        int wh; char c;
        sc(wh);
        getch(c);
        --wh;
        int it = wh;
        --cnt[s[wh]];
        char i = s[wh];
    // rip jane street
        if(i == 'C'){
            --mdcnts[it & 1];
        }
        else if(i == 'Z'){
            --mdcnts[(it ^ 1) & 1];
        }
        s[wh] = c;
        i = s[wh];
    // rip jane street
        if(i == 'C'){
            ++mdcnts[it & 1];
        }
        else if(i == 'Z'){
            ++mdcnts[(it ^ 1) & 1];
        }
        ++cnt[s[wh]];
        cout << calc_res() << '\n';
    }
}