#include <bits/stdc++.h>

#define int int64_t

using pii = std::pair<int, int>;

const int kMaxN = 2e5 + 5, kMaxT = kMaxN * 40;

int n, k, line_tot;
int a[kMaxN], sum[kMaxN], f[kMaxN];
pii line[kMaxT];

int addl(int k, int b) {
  line[++line_tot] = {k, b};
  return line_tot;
}

pii sub(pii a, pii b) { return {a.first - b.first, a.second - b.second}; }
int mul(pii a, pii b) { return a.first * b.second - a.second * b.first; }
int func(pii p, int x) { return x * p.first + p.second;}

int func(int k, int x) {
  if (!k) return -1e18;
  else return func(line[k], x);
}

struct SGT_MEX {
  int mi[kMaxN * 4];
  
  void pushup(int x) {
    mi[x] = std::min(mi[x << 1], mi[x << 1 | 1]);
  }
  
  void build(int x, int l, int r) {
    if (l == r) return;
    int mid = (l + r) >> 1;
    build(x << 1, l, mid), build(x << 1 | 1, mid + 1, r);
  }
  
  void update(int x, int l, int r, int ql, int v) {
    if (l == r) return void(mi[x] = v);
    int mid = (l + r) >> 1;
    if (ql <= mid) update(x << 1, l, mid, ql, v);
    else update(x << 1 | 1, mid + 1, r, ql, v);
    pushup(x);
  }
  
  int getmex(int x, int l, int r, int p) {
    if (l == r) return l;
    int mid = (l + r) >> 1;
    if (mi[x << 1] < p) return getmex(x << 1, l, mid, p);
    else return getmex(x << 1 | 1, mid + 1, r, p);
  }
  
  int getmin(int x, int l, int r, int ql, int qr) {
    if (l > qr || r < ql) return 1e9;
    else if (l >= ql && r <= qr) return mi[x];
    int mid = (l + r) >> 1;
    return std::min(getmin(x << 1, l, mid, ql, qr), getmin(x << 1 | 1, mid + 1, r, ql, qr));
  }
} sgt_mex;

struct SGT_VEC {
  std::vector<pii> v[kMaxN * 4];

  void ins(int x, pii p) {
    for (; (int)v[x].size() >= 2 && mul(sub(p, v[x].back()), sub(v[x].back(), v[x][(int)v[x].size() - 2])) <= 0; v[x].pop_back()) {}
    v[x].emplace_back(p);
  }
  
  int getval(int x, int y) {
    if (!v[x].size()) return -1e18;
    int L = 0, R = (int)v[x].size(), res = 0;
    while (L + 1 < R) {
      int mid = (L + R) >> 1;
      if (func(v[x][mid], y) >= func(v[x][mid - 1], y)) L = res = mid;
      else R = mid;
    }
    return func(v[x][res], y);
  }
  
  void update(int x, int l, int r, int ql, pii p) {
    ins(x, p);
    if (l == r) return;
    int mid = (l + r) >> 1;
    if (ql <= mid) update(x << 1, l, mid, ql, p);
    else update(x << 1 | 1, mid + 1, r, ql, p);
  }
  
  int query(int x, int l, int r, int ql, int qr, int v) {
    if (l > qr || r < ql) return -1e18;
    else if (l >= ql && r <= qr) return getval(x, v);
    int mid = (l + r) >> 1;
    return std::max(query(x << 1, l, mid, ql, qr, v), query(x << 1 | 1, mid + 1, r, ql, qr, v));
  }
} sgt_vec;

struct SGT_LCT {
  int tot, ls[kMaxT], rs[kMaxT], tag[kMaxT];
  
  void update(int &x, int l, int r, int k) {
    if (!x) return void(tag[x = ++tot] = k);
    int mid = (l + r) >> 1;
    if (func(tag[x], mid) < func(k, mid)) std::swap(tag[x], k);
    if (l == r) return;
    if (func(tag[x], l) < func(k, l)) update(ls[x], l, mid, k);
    if (func(tag[x], r) < func(k, r)) update(rs[x], mid + 1, r, k);
  }
  
  int query(int x, int l, int r, int k) {
    if (!x || l > k || r < k) return -1e18;
    else if (l == r) return func(tag[x], k);
    int mid = (l + r) >> 1;
    return std::max({query(ls[x], l, mid, k), query(rs[x], mid + 1, r, k), func(tag[x], k)});
  }
} sgt_lct;

struct SGT {
  int rt[kMaxN * 4];
  
  void update(int x, int l, int r, int ql, int k) {
    sgt_lct.update(rt[x], 0, 1e18, k);
    if (l == r) return;
    int mid = (l + r) >> 1;
    if (ql <= mid) update(x << 1, l, mid, ql, k);
    else update(x << 1 | 1, mid + 1, r, ql, k);
  }
  
  int query(int x, int l, int r, int ql, int qr, int k) {
    if (l > qr || r < ql) return -1e18;
    else if (l >= ql && r <= qr) return sgt_lct.query(rt[x], 0, 1e18, k);
    int mid = (l + r) >> 1;
    return std::max(query(x << 1, l, mid, ql, qr, k), query(x << 1 | 1, mid + 1, r, ql, qr, k));
  }
} sgt;

void dickdreamer() {
  std::cin >> n >> k;
  for (int i = 1; i <= n; ++i) {
    std::cin >> a[i];
    sum[i] = sum[i - 1] + a[i];
  }
  sgt_vec.update(1, 0, n, 0, {0, 0});
  for (int i = 1; i <= n; ++i) {
//    std::cerr << "!!!\n";
    int r = (!a[i] ? i : sgt_mex.getmin(1, 0, n, 0, a[i] - 1)), l = sgt_mex.getmin(1, 0, n, 0, a[i]);
    sgt_mex.update(1, 0, n, a[i], i);
//    std::cerr << i << ' ' << l << ' ' << r << '\n';
    for (; r > l;) {
      int mex = sgt_mex.getmex(1, 0, n, r), p = sgt_mex.getmin(1, 0, n, 0, mex);
      int val = sgt_vec.query(1, 0, n, p, r - 1, -mex);
      sgt.update(1, 1, n, p + 1, addl(mex, val));
      r = p;
    }
    int p = std::max<int>(i - k + 1, 1), mex = sgt_mex.getmex(1, 0, n, p);
    f[i] = sgt.query(1, 1, n, p, i, sum[i]);
    r = (!mex ? i : sgt_mex.getmin(1, 0, n, 0, mex - 1));
    f[i] = std::max(f[i], mex * sum[i] + sgt_vec.query(1, 0, n, p - 1, r - 1, -mex));
    assert(p <= r && sgt_mex.getmex(1, 0, n, r) == mex);
    sgt_vec.update(1, 0, n, i, {sum[i], f[i]});
    sgt.update(1, 1, n, i, addl(0, 0));
  }
  std::cout << f[n] << '\n';
}

int32_t main() {
#ifdef ORZXKR
  freopen("in.txt", "r", stdin);
  freopen("out.txt", "w", stdout);
#endif
  std::ios::sync_with_stdio(0), std::cin.tie(0), std::cout.tie(0);
  int T = 1;
  // std::cin >> T;
  while (T--) dickdreamer();
  // std::cerr << 1.0 * clock() / CLOCKS_PER_SEC << "s\n";
  return 0;
}