Problem: The story was not finished as PMP thought. God offered him one more chance to reincarnate and come back to life. But before he can come back, God told him that PMP should ask n great men including prominent programmers about their life experiences.

The men are standing on a straight line. They are numbered 1 through n from left to right. The coordinate of the i-th man is xi (xi < xi + 1, i < n). PMP should visit all these people one by one in arbitrary order. Each men should be visited exactly once. At the beginning of his tour, he starts at location of s-th man and asks him about his experiences.

Each time PMP wants to change his location, he should give a ticket to an angel and the angel carries him to his destination. Angels take PMP from one location, fly to his destination and put him down there. Nobody else is visited in this movement. Moving from i-th man to j-th man, takes |xi - xj| time. PMP can get back to life as soon as he visits all men.

There are two types of angels: Some angels are going to the right and they only accept right tickets. Others are going the left and they only accept left tickets. There are an unlimited number of angels of each type. PMP has l left tickets and n - 1 - l right tickets.

PMP wants to get back to life as soon as possible to be able to compete in this year's final instead of the final he missed last year. He wants to know the quickest way to visit all the men exactly once. He also needs to know the exact sequence moves he should make.

Input

The first line of input contains three space-separated integers n, l, s (2 ≤ n ≤ 105, 0 ≤ l < n, 1 ≤ s ≤ n) — the number of people to visit, the number left tickets PMP got, and initial location of PMP. Next line contains n space-separated integers. The i-th integer in this line is xi (0 = x1 < x2 < ... < xn ≤ 109) — the location of i-th man.

Output

If PMP cannot visit all men with the tickets he got print -1 in the only line of output. Otherwise, in the first line you should print the minimum time PMP can visit all men. In the second line you should print n - 1 integers that are the numbers of the men that PMP should visit in order in one optimal solution. If there are multiple answers, output any of them.

Please do not use the %lld specifier to read or write 64-bit integers in С++. It is preferred to use cin, cout streams or the %I64d specifier.

Examples

Input

5 2 2
0 10 11 21 22


Output

33
1 3 5 4


Input

4 3 1
0 1 2 3


Output

-1


Input

7 3 2
0 100 200 201 301 303 305


Output

409
1 3 4 7 6 5

Note

Let us remind here, a great contestant of all times, who left us about a year ago. May Renat Mullakhanov rest in peace.

Solution (in CPP):

Solution:
#include <bits/stdc++.h>
using namespace std;
const long long inf = 0x3f3f3f3f3f3f3f3fLL;
const int N = 100000 + 5;
int n, l, s;
long long xn[N], dtxn[N];
struct ll_i {
  long long v;
  int from;
  inline ll_i(long long _v, int _from) : v(_v), from(_from) {}
};
inline bool operator<(ll_i a, ll_i b) { return a.v < b.v; }
inline bool operator>(ll_i a, ll_i b) { return a.v > b.v; }
long long ans = inf;
int seq[N], szseq;
bool vis[N];
bool tag[N];
inline bool solve(long long expans) {
  long long sum_using = 0;
  priority_queue<ll_i> pq_using;
  priority_queue<ll_i, vector<ll_i>, greater<ll_i> > pq_prepare;
  for (int i = s + 1; i <= n; ++i) {
    int need_l = max(0, l - (s - 1 + n - i));
    if (i >= s + 3) pq_prepare.push(ll_i(xn[i - 1] - xn[i - 2], i - 1));
    while ((int)pq_using.size() > need_l) {
      pq_prepare.push(pq_using.top());
      sum_using -= pq_using.top().v;
      pq_using.pop();
    }
    while ((int)pq_using.size() < need_l && !pq_prepare.empty()) {
      if (pq_prepare.empty()) return inf;
      pq_using.push(pq_prepare.top());
      sum_using += pq_prepare.top().v;
      pq_prepare.pop();
    }
    while (!pq_using.empty() && !pq_prepare.empty() &&
           pq_using.top() > pq_prepare.top()) {
      ll_i a = pq_using.top(), b = pq_prepare.top();
      pq_using.pop();
      pq_prepare.pop();
      pq_using.push(b);
      pq_prepare.push(a);
      sum_using = sum_using - a.v + b.v;
    }
    if (((s > 1) + (i < n)) <= l && (int)pq_using.size() == need_l) {
      long long tans =
          xn[s] * 2 + (xn[n] - xn[i]) * 2 + (xn[i] - xn[s]) + sum_using * 2;
      ans = min(ans, tans);
      if (tans == expans) {
        vis[s] = true;
        for (int j = s - 1; j >= 2; --j)
          if (l - (s > 1) - (i < n)) {
            --l;
            vis[j] = true;
            seq[++szseq] = j;
          }
        if (s > 1) {
          --l;
          vis[1] = true;
          seq[++szseq] = 1;
        }
        for (int j = 1; j < s; ++j)
          if (!vis[j]) {
            vis[j] = true;
            seq[++szseq] = j;
          }
        while (!pq_using.empty()) {
          tag[pq_using.top().from] = true;
          pq_using.pop();
        }
        for (int j = s + 1; j < i;) {
          if (!tag[j + 1]) {
            seq[++szseq] = j;
            ++j;
          } else {
            int k = j + 1;
            while (tag[k + 1]) ++k;
            for (int m = k; m >= j; --m) seq[++szseq] = m;
            l -= k - j;
            j = k + 1;
          }
        }
        for (int j = n; j >= i + l; --j) seq[++szseq] = j;
        for (int j = i + l - 1; j >= i; --j) seq[++szseq] = j;
        return true;
      }
    }
  }
  return false;
}
inline void reverse_problem() {
  s = n - s + 1;
  l = n - 1 - l;
  for (int i = 2; i <= n; ++i) dtxn[i] = xn[i] - xn[i - 1];
  for (int i = 2, j = n; i < j; ++i, --j) swap(dtxn[i], dtxn[j]);
  for (int i = 2; i <= n; ++i) xn[i] = xn[i - 1] + dtxn[i];
}
int main() {
  scanf("%d%d%d", &n, &l, &s);
  for (int i = 1; i <= n; ++i) scanf("%I64d", &xn[i]);
  if (n == 2) {
    if ((s == 1 && l == 1) || (s == 2 && l == 0))
      puts("-1");
    else {
      printf("%I64d\n", xn[2]);
      if (s == 1)
        puts("2");
      else
        puts("1");
    }
    return 0;
  }
  if (s != n) solve(-1);
  if (s != 1) {
    reverse_problem();
    solve(-1);
    reverse_problem();
  }
  if (ans == inf)
    puts("-1");
  else {
    printf("%I64d\n", ans);
    if (!solve(ans)) {
      reverse_problem();
      solve(ans);
      for (int i = 1; i <= szseq; ++i) seq[i] = n - seq[i] + 1;
    }
    for (int i = 1; i <= szseq; ++i) printf("%d%c", seq[i], " \n"[i == szseq]);
  }
  return 0;
}