#include <bits/stdc++.h>
using namespace std;

#ifdef CKISEKI
#define safe cerr << __PRETTY_FUNCTION__ << " line " << __LINE__ << " safe\n"
#define debug(a...) debug_(#a, a)
#define orange(a...) orange_(#a, a)
template <typename ...T>
void debug_(const char *s, T ...a) {
    cerr << "\e[1;32m(" << s << ") = (";
    int cnt = sizeof...(T);
    (..., (cerr << a << (--cnt ? ", " : ")\e[0m\n")));
}
template <typename I>
void orange_(const char *s, I L, I R) {
    cerr << "\e[1;32m[ " << s << " ] = [ ";
    for (int f = 0; L != R; ++L)
        cerr << (f++ ? ", " : "") << *L;
    cerr << " ]\e[0m\n";
}
#else
#define safe ((void)0)
#define debug(...) safe
#define orange(...) safe
#endif

namespace {

constexpr int MOD = 998244353;

int modadd(int a, int b) {
    return a + b >= MOD ? a + b - MOD : a + b;
}

int modsub(int a, int b) {
    return a - b < 0 ? a - b + MOD : a - b;
}

int modmul(int64_t a, int64_t b) {
    return static_cast<int>(a * b % MOD);
}

int modpow(int a, int64_t k) {
    int r = 1;
    while (k) {
        if (k & 1) r = modmul(r, a);
        k >>= 1; a = modmul(a, a);
    }
    return r;
}

int modinv(int a) {
    return modpow(a, MOD - 2);
}

struct NTT {
    static constexpr int maxn = 1 << 22;
    int roots[maxn];
    NTT() {
        int r = modpow(3, (MOD - 1) / maxn);
        for (int i = maxn >> 1; i; i >>= 1) {
            roots[i] = 1;
            for (int j = 1; j < i; ++j)
                roots[i + j] = modmul(roots[i + j - 1], r);
            r = modmul(r, r);
        }
    }
    void operator()(int F[], int n, bool inv = false) {
        for (int i = 0, j = 0; i < n; ++i) {
            if (i < j) swap(F[i], F[j]);
            for (int k = n >> 1; (j ^= k) < k; k >>= 1);
        }
        for (int s = 1; s < n; s *= 2) {
            for (int i = 0; i < n; i += s * 2) {
                for (int j = 0; j < s; ++j) {
                    int a = F[i + j];
                    int b = modmul(F[i + j + s], roots[s + j]);
                    F[i + j] = modadd(a, b);
                    F[i + j + s] = modsub(a, b);
                }
            }
        }
        if (inv) {
            int invn = modinv(n);
            for (int i = 0; i < n; ++i)
                F[i] = modmul(F[i], invn);
            reverse(F + 1, F + n);
        }
    }
} ntt;

vector<int> calc(string_view s1, string_view s2) {
    static int a[NTT::maxn], b[NTT::maxn];

    vector<int> ans(s1.size());

    for (int x : {'o', 'k'}) {
        int y = 'o' ^ 'k' ^ x;
        
        memset(a, 0, sizeof(a));
        memset(b, 0, sizeof(b));
        for (size_t i = 0; i < s1.size(); ++i)
            a[i] = s1[i] == x;
        for (size_t i = 0; i < s2.size(); ++i)
            b[i] = s2[i] == y;
        reverse(b, b + s2.size());

        ntt(a, NTT::maxn);
        ntt(b, NTT::maxn);
        for (int i = 0; i < NTT::maxn; ++i)
            a[i] = modmul(a[i], b[i]);
        ntt(a, NTT::maxn, true);
        for (size_t i = s2.size() - 1; i < s1.size(); ++i)
            ans[i] += a[i];
    }
    
    return ans;
}

} // namespace

int main() {
    cin.tie(nullptr)->sync_with_stdio(false);

    int o, k;
    cin >> o >> k;
    string s1, s2;
    cin >> s1 >> s2;

    auto to_v = [o, k](char c) {
        if (c == 'o') return o;
        return k;
    };

    vector<uint64_t> val(s1.size());
    for (size_t i = 0; i < s1.size(); ++i) {
        if (i) val[i] = val[i - 1];
        val[i] += to_v(s1[i]);
        if (i >= s2.size())
            val[i] -= to_v(s1[i - s2.size()]);
    }

    auto n_match = calc(s1, s2);

    uint64_t pre = 0;
    vector<uint64_t> dp(s1.size());
    for (size_t i = s2.size() - 1; i < s1.size(); ++i) {
        if (n_match[i] < 31) {
            dp[i] = val[i] >> n_match[i];
        }
        dp[i] += pre;
        pre = max(pre, dp[i - (s2.size() - 1)]);
    }

    cout << *max_element(dp.begin(), dp.end()) << '\n';
    return 0;
}