//Andrzej Jabłoński
#include "bits/stdc++.h"
#define forx(i,b,e) for(std::common_type<decltype(b, e)>::type i = (b), ie = (e); i < ie; i++)
#define pow2(x) (1ll<<(x))
#define all(x) begin(x), end(x)
#define until(x) while(!(x))
#define len(x) (int)size(x)

using namespace std;
using llong = long long;

template<class T> void __echo(const T& x, string sep) { cerr << x << sep; }
void __echo(const string& x, string sep) { cerr << "\"" << x << "\"" << sep; }
void __echo(const char& x, string sep = ", ") { cerr << "\'" << x << "\'" << sep; }
template<class T>
void __echo(const vector<T>& x, string sep) {
    cerr << "{";
    for (size_t i = 0; i < x.size(); i++)
        __echo(x[i], i + 1 == x.size() ? "" : ", ");
    cerr << "}" << sep;
}

template<class T1, class T2>
void __echo(const pair<T1, T2>& x, string sep = ", ")
{
    cerr << "("; __echo(x.first, ", "); __echo(x.second, ""); cerr << ")" << sep;
}

void __echo(istringstream& stream) {
    cerr << "\n";
}
template<size_t> struct Int {};
template<class Tuple, size_t Pos> void print_tuple(const Tuple& x, Int<Pos>) {
    __echo(get<tuple_size<Tuple>::value - Pos>(x), ", ");
    print_tuple(x, Int<Pos - 1>());
}
template<class Tuple>
void print_tuple(const Tuple& x, Int<1>) { cerr << get<tuple_size<Tuple>::value - 1>(x); }
template<class... Args>
void print_tuple(const tuple<Args...>& x) { print_tuple(x, Int<sizeof... (Args)>()); }
template<class... Args>
void __echo(const tuple<Args...>& x, string sep) { cerr << "("; print_tuple(x); cerr << ")" << sep; }
template<class T>
bool _char_const(const T& x) { return false; }
bool _char_const(const char* x) { cerr << x; return true; }
template<class T>
bool isCharConst(const T& x) { return false; }
bool isCharConst(const char* x) { return true; }
string trim(string x) {
    return string(begin(x) + x.find_first_not_of(' '), begin(x) + x.find_last_not_of(' ') + 1);
}
template<class T, class... Args>
void __echo(istringstream& stream, const T& x, Args... args) {
    static int cnt[200] = { 0 };//no bo po co to tworzyc od nowa?
    string name;
    do {
        string s;
        getline(stream, s, ',');
        for (auto c : s)
            cnt[(int)c]++;
        name += s + ',';
    } while (not(cnt['('] == cnt[')']
        &&
        cnt['['] == cnt[']']
        &&
        cnt['{'] == cnt['}']
        &&
        cnt['\"'] % 2 == 0
        &&
        cnt['\''] % 2 == 0));
    name.pop_back();//usuwamy ','

    if (!_char_const(x)) {
        cerr << trim(name) << " = ";
        __echo(x, "; ");
    }

    __echo(stream, args...);
}
#define echo(...) if(DBG) {istringstream str(#__VA_ARGS__); __echo(str, __VA_ARGS__); }
/////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////

#define TESTSETS 0
#define DBG 0
constexpr int mod = int(1000'000'000 + 7);

map<string, bool> ok;
bool test(const string& s) {
    auto it = ok.find(s);
    if (it != ok.end()) return it->second;

    forx(i, 0, size(s) - 1) {
        if (s[i] == s[i + 1]) {
            string t = s.substr(0, i) + (s[i] == 'C' ? 'Z' : 'C') + s.substr(i + 2);
            if (test(t)) {
                ok[s] = true;
                return true;
            }
        }
    }

    ok[s] = false;
    return false;
}

int rnd(int a, int b) {
    return rand() % (b - a + 1) + a;
}

void brut_gen()
{
    ok["C"] = ok["Z"] = true;

    int a = 3, b = 8;

    int n = 1;
    while (n < 20) {
        string s = string(n, '#');
        forx(msk, 0, pow2(n)) {
            forx(b, 0, n) {
                s[b] = "CZ"[(msk & pow2(b)) == 0];
            }
            int c = (int)count(all(s), 'C');
            int z = n - c;
            bool git = test(s);
            if ((c - z) % 3 != 0 && !git)
                cout << s << ": " << git << "\n";
        }
        n++;
    }
}

void solve_n_1(int n, int q, string s)
{
    cout << 1 + (s[0] == 'N') << "\n";
    while (q--) {
        int k; cin >> k >> s[0];
        cout << 1 + (s[0] == 'N') << "\n";
    }
}

void solve() {
    int n, q; string s;
    cin >> n >> q >> s;

    if (n == 1) {
        solve_n_1(n, q, s);
        return;
    }

    int cCZ = 0; //liczba dobrze ustawionych pozycji do ciagu CZCZCZCZC
    int cZC = 0;
    int free = 0; //liczba wolnych pozycji, czyli liczba czastek N
    int cntC = 0;
    int cntZ = 0;

    auto ok_CZ = [&](int idx, char value)->bool {
        if (idx % 2 == 0 && value != 'Z') return true;
        if (idx % 2 == 1 && value != 'C') return true;
        return false;
    };

    auto ok_ZC = [&](int idx, char value)->bool {
        if (idx % 2 == 0 && value != 'C') return true;
        if (idx % 2 == 1 && value != 'Z') return true;
        return false;
    };

    auto update_s = [&](int i, char c) {
        if (s[i] == c)
            return;

        // Na pozycje i wpisz znak c 
        // i zaktualizuj info o CZCZC... i ZCZCZ...

        if (ok_CZ(i, s[i]) && !ok_CZ(i, c))
            cCZ--;
        if (!ok_CZ(i, s[i]) && ok_CZ(i, c))
            cCZ++;

        if (ok_ZC(i, s[i]) && !ok_ZC(i, c))
            cZC--;
        if (!ok_ZC(i, s[i]) && ok_ZC(i, c))
            cZC++;

        // oraz o ilosci N (free), Z (cntZ), C (cntC)
        if (s[i] == 'N')
            free--;
        if (s[i] == 'Z')
            cntZ--;
        if (s[i] == 'C')
            cntC--;

        if (c == 'N')
            free++;
        if (c == 'Z')
            cntZ++;
        if (c == 'C')
            cntC++;

        s[i] = c;
    };

    forx(i, 0, n) {
        if (s[i] == 'N')
            free++;
        if (s[i] == 'Z')
            cntZ++;
        if (s[i] == 'C')
            cntC++;

        if (ok_CZ(i, s[i]))
            cCZ++;
        if (ok_ZC(i, s[i]))
            cZC++;
    }

    auto seqCZ = [&]() { return cCZ == n; };//czy da sie stworzyc ciag CZC...
    auto seqZC = [&]() { return cZC == n; };

    // ------------- preprocessing [3][3] ---------------
    vector<int> p2mod(n + 42, 1);
    forx(i, 1, n + 42) p2mod[i] = (p2mod[i - 1] * 2ll) % mod;

    constexpr int inv3 = 333333336;
    constexpr int inv2 = 500000004;

    auto n1p = [&](int n) {
        return (n % 2 ? mod - 1 : 1); //(-1)^n modulo
    };

    auto mmul = [&](int a, int b)->int {
        a %= mod; b %= mod;
        llong res = (((llong)a * b) % mod + mod) % mod;
        return res % mod;
    };

    auto madd = [&](int a, int b)->int {
        a %= mod; b %= mod;
        return (((llong)a + b) % mod + mod) % mod;
    };

    auto seq = [&](int N, int r) {
        int n = N / 3; //podloga
        int magic = 0;

        if (N % 3 == 0) {
            if (r % 3 == 0) {
                magic = mmul(inv3, madd(mmul(2, n1p(n)), p2mod[3 * n]));
            }
            else if (r % 3 == 1) {
                magic = mmul(inv3, madd(n1p(n + 1), p2mod[3 * n]));
            }
            else {
                magic = mmul(inv3, madd(n1p(n + 1), p2mod[3 * n]));
            }
        }
        else if (N % 3 == 1) {
            if (r % 3 == 0) {
                magic = mmul(inv3, madd(n1p(n), p2mod[3 * n + 1]));
            }
            else if (r % 3 == 1) {
                magic = mmul(inv3, madd(n1p(n), p2mod[3 * n + 1]));
            }
            else {
                magic = mmul(mmul(-2, inv3), madd(n1p(n), -p2mod[3 * n]));
            }
        }
        else {
            if (r % 3 == 0) {
                magic = mmul(inv3, madd(n1p(n + 1), p2mod[3 * n + 2]));
            }
            else if (r % 3 == 1) {
                magic = mmul(mmul(2, inv3), madd(n1p(n), p2mod[3 * n + 1]));
            }
            else {
                magic = mmul(inv3, madd(n1p(n + 1), p2mod[3 * n + 2]));
            }
        }
        if (DBG) echo(N, r, p2mod[N], magic);

        return madd(p2mod[N], -magic);
    };

    auto good_seq = [&]()->int {
        if (free == 0) {
            // odpowiedz to zawsze 1 lub 0
            return ((cntC - cntZ) % 3 != 0) && !seqCZ() && !seqZC();
        }
        else {
            int bad_mod = (2 * (cntZ - cntC + free) % 3 + 3) % 3;// r (bad_mod) 
            int special_combinations = (n % 2 == 1 ? seqCZ() + seqZC() : 0); //moze byc jednak dwie na raz (NNNN)
            int good_mod_combinations = seq(free, bad_mod);
            int ans = madd(good_mod_combinations, -special_combinations);
            return ans;
        }
    };



    // -------------------- odpowiedzi na zapytania ---------------------
    int ans0 = good_seq();
    cout << ans0 << "\n";

    forx(query, 0, q) {
        int idx; char c; cin >> idx >> c; idx -= 1;
        update_s(idx, c);
        int ans = good_seq();
        cout << ans << "\n";
    }
}

int main()
{
    ios::sync_with_stdio(0); cin.tie(0);
    int t = 1;
    if (TESTSETS)
        cin >> t;

    while (t--)
        solve();
}