#include <bits/stdc++.h>
#include <immintrin.h> // For AVX instructions
using namespace std;

using ll = long long;
using Type = unsigned short;

const int N = 5e4 + 100;

#pragma GCC push_options
#pragma GCC target("avx2")
int solve(const Type* a, const Type* b, Type n, Type m)
{
    Type cnt = 0, ans = 0;

    // Loop unrolling and vectorization using AVX2
    __m256i v_cnt = _mm256_set1_epi16(0); // Vector for cnt
    __m256i v_m = _mm256_set1_epi16(m); // Vector for m

    const int step = 16; // AVX2 processes 16 unsigned shorts at a time
    int i = 0;
    for (; i + step <= n; i += step) {
        // Load 16 elements from a and b
        __m256i v_a = _mm256_loadu_si256((__m256i*)(a + i));
        __m256i v_b = _mm256_loadu_si256((__m256i*)(b + i));

        // Compare a[i] < b[i]
        __m256i v_ok = _mm256_cmpgt_epi16(v_b, v_a); // v_ok = b[i] > a[i] -> a[i] < b[i]

        // cnt = (cnt + 1) * ok
        __m256i v_one = _mm256_set1_epi16(1);
        v_cnt = _mm256_add_epi16(v_cnt, v_one);
        v_cnt = _mm256_and_si256(v_cnt, v_ok);

        // ans += (cnt >= m)
        __m256i v_ge_m = _mm256_cmpgt_epi16(v_cnt, _mm256_sub_epi16(v_m, v_one));
        ans += _mm_popcnt_u32(_mm256_movemask_epi8(v_ge_m)) / 2; // 16-bit elements are considered, hence divide by 2
    }

    // Process remaining elements
    for (; i < n; i++) {
        bool ok = a[i] < b[i];
        cnt = (cnt + 1) * ok;
        ans += (cnt >= m);
    }

    return ans;
}
#pragma GCC pop_options

Type p[N];

int main() {
    cin.tie(0)->sync_with_stdio(0);
    cin.exceptions(cin.failbit);

    Type n, m;
    cin >> n >> m;

#if 1 // real use
    for (int i = 0; i < n; i++)
        cin >> p[i];
#else // random test
    for (Type i = 0; i < n; i++)
        p[i] = i;
    mt19937 rng;
    shuffle(p, p + n, rng);
#endif

    ll ans = 0;
    for (Type d = 1; d + m <= n; d++)
        ans += solve(p, p + d, n - d, m);
    cout << ans;
}