#include <bits/stdc++.h>
using namespace std;
int inf;
const double eps = 1e-8;
const double pi = acos(-1.0);
template <class T, class T2>
int chkmin(T &a, T2 b) {
  return a > b ? a = b, 1 : 0;
}
template <class T, class T2>
int chkmax(T &a, T2 b) {
  return a < b ? a = b, 1 : 0;
}
template <class T>
T sqr(T a) {
  return a * a;
}
template <class T, class T2>
T mmin(T a, T2 b) {
  return a < b ? a : b;
}
template <class T, class T2>
T mmax(T a, T2 b) {
  return a > b ? a : b;
}
template <class T>
T aabs(T a) {
  return a < 0 ? -a : a;
}
template <class T>
int dcmp(T a, T b) {
  return a > b;
}
template <int *a>
int cmp_a(int first, int second) {
  return a[first] < a[second];
}
struct __INIT__ {
  __INIT__() { memset(&inf, 0x3f, sizeof(inf)); }
} __INIT___;
namespace io {
const int SIZE = (1 << 21) + 1;
char ibuf[SIZE], *iS, *iT, obuf[SIZE], *oS = obuf, *oT = oS + SIZE - 1, c,
                                       qu[55];
int f, qr;
inline void flush() {
  fwrite(obuf, 1, oS - obuf, stdout);
  oS = obuf;
}
inline void putc(char first) {
  *oS++ = first;
  if (oS == oT) flush();
}
template <typename A>
inline bool read(A &first) {
  for (f = 1, c = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, SIZE, stdin),
                              (iS == iT ? EOF : *iS++))
                            : *iS++);
       c < '0' || c > '9';
       c = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, SIZE, stdin),
                       (iS == iT ? EOF : *iS++))
                     : *iS++))
    if (c == '-')
      f = -1;
    else if (c == EOF)
      return 0;
  for (first = 0; c <= '9' && c >= '0';
       c = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, SIZE, stdin),
                       (iS == iT ? EOF : *iS++))
                     : *iS++))
    first = first * 10 + (c & 15);
  first *= f;
  return 1;
}
inline bool read(char &first) {
  while ((first = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, SIZE, stdin),
                               (iS == iT ? EOF : *iS++))
                            : *iS++)) == ' ' ||
         first == '\n' || first == '\r')
    ;
  return first != EOF;
}
inline bool read(char *first) {
  while ((*first = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, SIZE, stdin),
                                (iS == iT ? EOF : *iS++))
                             : *iS++)) == '\n' ||
         *first == ' ' || *first == '\r')
    ;
  if (*first == EOF) return 0;
  while (!(*first == '\n' || *first == ' ' || *first == '\r' || *first == EOF))
    *(++first) = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, SIZE, stdin),
                              (iS == iT ? EOF : *iS++))
                           : *iS++);
  *first = 0;
  return 1;
}
template <typename A, typename... B>
inline bool read(A &first, B &...second) {
  return read(first) && read(second...);
}
template <typename A>
inline bool write(A first) {
  if (!first) putc('0');
  if (first < 0) putc('-'), first = -first;
  while (first) qu[++qr] = first % 10 + '0', first /= 10;
  while (qr) putc(qu[qr--]);
  return 0;
}
inline bool write(char first) {
  putc(first);
  return 0;
}
inline bool write(const char *first) {
  while (*first) {
    putc(*first);
    ++first;
  }
  return 0;
}
inline bool write(char *first) {
  while (*first) {
    putc(*first);
    ++first;
  }
  return 0;
}
template <typename A, typename... B>
inline bool write(A first, B... second) {
  return write(first) || write(second...);
}
struct Flusher_ {
  ~Flusher_() { flush(); }
} io_flusher_;
}  // namespace io
using io ::putc;
using io ::read;
using io ::write;
int a[200005], cur, is[200005], pw[200005], fa[200005];
int *pre[200005], *suf[200005], cnt[200005], nwa[200005];
long long ans;
int dp[400005], *f = dp + 400000;
int w[25000005], *at = w;
pair<int, int> b[200005];
int *newI(int n) {
  at += n;
  return at - n;
}
int find(int first) {
  return first == fa[first] ? first : fa[first] = find(fa[first]);
}
int nex[200005], stk[400005], tp, ist[200005];
void add(int first, int second) {
  ist[second] = -1;
  if (!ist[first]) ist[first] = 1;
  stk[++tp] = first;
  stk[++tp] = second;
  nex[first] = second;
}
void put(int first) {
  is[first] = 1;
  nwa[first] = a[first];
  cnt[first] = 1;
  pre[first] = newI(1);
  pre[first][0] = 1;
  suf[first] = newI(1);
  suf[first][0] = 1;
  fa[first] = first;
  if (is[first - 1]) {
    add(find(first - 1), first);
  }
  if (is[first + 1]) {
    add(first, find(first + 1));
  }
}
int id[200005], m, n, l;
void solve() {
  int cc = 0;
  for (int i = 1; i <= m; ++i) {
    if (nwa[id[i]] != cur) {
      int S = pw[mmin(cur - nwa[id[i]], n)];
      int *p = pre[id[i]], *s = suf[id[i]];
      for (int j = 1; j <= cnt[id[i]]; ++j) {
        int w = p[j - 1];
        p[j - 1] = 0;
        if (j >= S) p[j / S - 1] += w;
        w = s[j - 1];
        s[j - 1] = 0;
        if (j >= S) s[j / S - 1] += w;
      }
      cnt[id[i]] /= S;
      nwa[id[i]] = cur;
    }
    cc += cnt[id[i]];
  }
  int *np = newI(cc), *ns = newI(cc);
  int t = 0;
  for (int i = 1; i <= m; ++i) {
    for (int j = 0; j < cnt[id[i]]; ++j) {
      np[t] = pre[id[i]][j];
      ++t;
    }
  }
  t = 0;
  for (int i = m; i; --i) {
    for (int j = 0; j < cnt[id[i]]; ++j) {
      ns[t] = suf[id[i]][j];
      ++t;
    }
  }
  for (int i = m; i; --i) {
    for (int j = 1; j <= cnt[id[i]]; ++j)
      ans += (long long)suf[id[i]][j - 1] * f[mmax(1, l - j)];
    for (int j = cnt[id[i]]; j; --j) {
      f[0] = f[1] + pre[id[i]][j - 1];
      --f;
    }
  }
  for (int i = 1; i <= cc; ++i) *(++f) = 0;
  cnt[id[1]] = cc;
  pre[id[1]] = np;
  suf[id[1]] = ns;
}
void work() {
  for (; tp; --tp) {
    if (ist[stk[tp]] <= 0) {
      ist[stk[tp]] = 0;
      continue;
    }
    ist[stk[tp]] = 0;
    int at = stk[tp];
    m = 0;
    while (at) {
      id[++m] = at;
      fa[at] = stk[tp];
      int nx = nex[at];
      nex[at] = 0;
      at = nx;
    }
    solve();
  }
}
signed main() {
  read(n, l);
  pw[0] = 1;
  int iee = n / l + 1;
  for (int i = 1; i <= n; ++i) pw[i] = mmin(pw[i - 1], iee) * l;
  for (int i = 1; i <= n; ++i) {
    read(a[i]);
    b[i] = make_pair(a[i], i);
  }
  sort(b + 1, b + n + 1);
  for (int i = 1, j = 1; i <= n; i = j) {
    cur = b[i].first;
    while (b[i].first == b[j].first) {
      put(b[j].second);
      ++j;
    }
    work();
  }
  write(ans + n, '\n');
  return 0;
}
