#ifndef SorahISA
#define SorahISA
#include SorahISA __FILE__ SorahISA

const int mod = 1'000'000'007;
const int p = 257;

void solve() {
    int N, K; cin >> N >> K;
    string S, T; cin >> S >> T;
    
    vector<int> prehash_S(N+1, 0), prehash_T(N+1, 0), pow_p(N+1, 1);
    for (int i = 1; i <= N; ++i) {
        prehash_S[i] = (prehash_S[i-1] * p + S[i-1]) % mod;
        prehash_T[i] = (prehash_T[i-1] * p + T[i-1]) % mod;
        pow_p[i] = pow_p[i-1] * p % mod;
    }
    
    auto get_hash = [&](int tp, int st, int len) -> int {
        if (tp == 0) return (prehash_S[st+len] - prehash_S[st] * pow_p[len] % mod + mod) % mod;
        if (tp == 1) return (prehash_T[st+len] - prehash_T[st] * pow_p[len] % mod + mod) % mod;
        return -1;
    };
    
    int ans = 0;
    
    function<pair<set<int>, set<int>>(set<int>, set<int>, int, int)>
    recur = [&](set<int> start_S, set<int> start_T, int kL, int kR) {
        int kM = (kL + kR + 1) >> 1;
        
        vector<pii> roll_S, roll_T;
        for (int x : start_S) roll_S.eb(get_hash(0, x, kM), x);
        for (int x : start_T) roll_T.eb(get_hash(1, x, kM), x);
        sort(ALL(roll_S)), sort(ALL(roll_T));
        
        set<int> tmp_S, tmp_T;
        int n = SZ(roll_S), m = SZ(roll_T);
        
        if (kL == kR) {
            for (int i = 0, j = 0; i < n and j < m; ++i) {
                while (j < m and roll_T[j].first < roll_S[i].first) ++j;
                if (roll_T[j].first == roll_S[i].first) {
                    start_S.erase(roll_S[i].second), start_T.erase(roll_T[j].second);
                    debug(roll_S[i].second, roll_T[j].second, kM);
                    ans += K - kM;
                    ++j;
                }
            }
            return pair{start_S, start_T};
        }
        
        for (int i = 0, j = 0; i < n and j < m; ) {
            int chk = roll_S[i].first;
            while (j < m and roll_T[j].first < chk) ++j;
            while (i < n and roll_S[i].first == chk) {
                tmp_S.ee(roll_S[i].second);
                start_S.erase(roll_S[i].second);
                ++i;
            }
            while (j < m and roll_T[j].first == chk) {
                tmp_T.ee(roll_T[j].second);
                start_T.erase(roll_T[j].second);
                ++j;
            }
        }
        
        auto [res_S, res_T] = recur(tmp_S, tmp_T, kM, kR);
        for (int x : res_S) start_S.ee(x);
        for (int x : res_T) start_T.ee(x);
        
        return recur(start_S, start_T, kL, kM-1);
    };
    
    set<int> st_S, st_T;
    for (int i = 0; i <= N-K; ++i) st_S.ee(i), st_T.ee(i);
    recur(st_S, st_T, 0, K);
    
    cout << ans << "\n";
}

int32_t main() {
    fastIO();
    
    int t = 1; // cin >> t;
    for (int _ = 1; _ <= t; ++_) {
        solve();
    }
    
    return 0;
}

#else

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

#define int int64_t
#define double __float80
using pii = pair<int, int>;
template <typename T> using Prior = std::priority_queue<T>;
template <typename T> using prior = std::priority_queue<T, vector<T>, greater<T>>;

#define eb emplace_back
#define ef emplace_front
#define ee emplace
#define pb pop_back
#define pf pop_front
#define ALL(x) begin(x), end(x)
#define RALL(x) rbegin(x), rend(x)
#define SZ(x) ((int)(x).size())

#ifdef local
#define fastIO() void()
#define debug(...) \
    fprintf(stderr, "%s", "\u001b[33m"), \
    fprintf(stderr, "At [%s], line %d: (%s) = ", __FUNCTION__, __LINE__, #__VA_ARGS__), \
    _do(__VA_ARGS__), \
    fprintf(stderr, "%s", "\u001b[0m")
template <typename T> void _do(T &&_t) {cerr << _t << "\n";}
template <typename T, typename ...U> void _do(T &&_t, U &&..._u) {cerr << _t << ", ", _do(_u...);}
#else
#define fastIO() ios_base::sync_with_stdio(0), cin.tie(0)
#define debug(...) void()
#endif

template <typename T, typename U> bool chmin(T &lhs, U rhs) {return lhs > rhs ? lhs = rhs, 1 : 0;}
template <typename T, typename U> bool chmax(T &lhs, U rhs) {return lhs < rhs ? lhs = rhs, 1 : 0;}

#endif