#include <iostream>
#include <vector>
#include <string>
#include <algorithm>

using namespace std;

const int MOD = 1000000007;

// ??????
long long power(long long base, long long exp) {
    long long res = 1;
    base %= MOD;
    if (base < 0) base += MOD;
    while (exp > 0) {
        if (exp % 2 == 1) res = (res * base) % MOD;
        base = (base * base) % MOD;
        exp /= 2;
    }
    return res;
}

long long modInverse(long long n) {
    return power(n, MOD - 2);
}

const int MAX = 200005;
long long fact[MAX];
long long invFact[MAX];

void precompute() {
    fact[0] = 1;
    invFact[0] = 1;
    for (int i = 1; i < MAX; i++) {
        fact[i] = (fact[i - 1] * i) % MOD;
    }
    invFact[MAX - 1] = modInverse(fact[MAX - 1]);
    for (int i = MAX - 2; i >= 1; i--) {
        invFact[i] = (invFact[i + 1] * (i + 1)) % MOD;
    }
}

// ??????
long long f(long long l) {
    if (l == 0) return 1;
    return power(l + 1, l - 1) * invFact[l] % MOD;
}

// ?? [w^n] F(w)^m ??
long long get_c(long long m, long long n) {
    if (m == 0) return (n == 0) ? 1 : 0;
    if (n == 0) return 1;
    long long base = (n + m) % MOD;
    long long p = power(base, n - 1);
    long long ans = m % MOD * p % MOD;
    ans = ans * invFact[n] % MOD;
    return ans;
}

int main() {
    // ???????IO??
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
    precompute();

    long long N, M;
    if (!(cin >> N >> M)) return 0;
    string S;
    cin >> S;

    int c = 0;
    bool has_o = false;
    for (char ch : S) {
        if (ch == '-') c++;
        if (ch == 'o') has_o = true;
    }

    int V = N - M;
    long long ans = 0;

    if (has_o) {
        // ?? 1: ?? S ????? 'o'
        int first_o = -1, last_o = -1;
        for (int i = 0; i < M; ++i) {
            if (S[i] == 'o') {
                if (first_o == -1) first_o = i;
                last_o = i;
            }
        }

        int a = first_o;
        int b = M - 1 - last_o;

        long long Win = 1;
        int current_dash = 0;
        for (int i = first_o + 1; i <= last_o; ++i) {
            if (S[i] == '-') {
                current_dash++;
            } else {
                Win = Win * f(current_dash) % MOD;
                current_dash = 0;
            }
        }

        vector<long long> Pa(a, 0), Pb(b, 0);
        for (int i = 0; i < a; ++i) Pa[i] = f(i);
        for (int i = 0; i < b; ++i) Pb[i] = f(i);

        int degR = max(a, b) - 1;
        vector<long long> R(degR + 1, 0);
        for (int i = 0; i < a; ++i) R[i] = (R[i] + Pa[i]) % MOD;
        for (int i = 0; i < b; ++i) R[i] = (R[i] + Pb[i]) % MOD;

        int degQ = -1;
        vector<long long> Q;
        if (a > 0 && b > 0) {
            degQ = a + b - 2;
            Q.assign(degQ + 1, 0);
            for (int i = 0; i < a; ++i) {
                for (int j = 0; j < b; ++j) {
                    Q[i + j] = (Q[i + j] + Pa[i] * Pb[j]) % MOD;
                }
            }
        }

        for (int k = 0; k <= V; ++k) {
            long long Wk = 0;
            if (k == V) {
                Wk = f(a + V + b) * Win % MOD;
            } else {
                long long T1 = get_c(V - k + 1, k + a + b);
                long long T2 = 0;
                for (int i = 0; i <= degR; ++i) {
                    if (R[i]) T2 = (T2 + R[i] * get_c(V - k, k + a + b - i)) % MOD;
                }
                long long T3 = 0;
                if (degQ >= 0) {
                    for (int j = 0; j <= degQ; ++j) {
                        if (Q[j]) T3 = (T3 + Q[j] * get_c(V - k - 1, k + a + b - j)) % MOD;
                    }
                }
                Wk = (T1 - T2 + T3) % MOD;
                if (Wk < 0) Wk += MOD;
                Wk = Wk * Win % MOD;
            }

            long long K = c + k;
            long long term = Wk * fact[K] % MOD;
            term = term * power(N, N - K) % MOD;
            ans = (ans + term) % MOD;
        }

    } else {
        // ?? 2: ?? S ???? '-'???????????
        for (int k = 0; k <= V; ++k) {
            if (k == V) {
                // [?????]?? K = N (? k = V)????????????????
                // ?????????????? S ?? '-'??? N^N ???????
                ans = (ans + power(N, N)) % MOD;
            } else {
                long long K = M + k;
                long long m = V - k - 1; 
                
                // ????????
                long long TermAB_coef = (K - (M - 1) * (m + 1) % MOD + MOD) % MOD;
                long long TermAB = 0;
                if (K > 0) {
                    TermAB = TermAB_coef * power(K + m + 1, K - 1) % MOD * invFact[K] % MOD;
                }

                long long TermC = 0;
                for (int n = 0; n < M; ++n) {
                    long long coef = (M - 1 - n + MOD) % MOD;
                    long long val = coef * f(n) % MOD;
                    val = val * get_c(m, K - n) % MOD;
                    TermC = (TermC + val) % MOD;
                }

                long long Wk = (TermAB + TermC) % MOD;
                long long ways = Wk * fact[K] % MOD;
                ways = ways * power(N, N - K) % MOD;
                ans = (ans + ways) % MOD;
            }
        }
    }

    ans = ans * (N - M + 1) % MOD;
    cout << ans << "\n";

    return 0;
}