#include <bits/stdc++.h>
using namespace std;
template <class S, class T>
pair<S, T> operator+(const pair<S, T> &s, const pair<S, T> &t) {
  return pair<S, T>(s.first + t.first, s.second + t.second);
}
template <class S, class T>
pair<S, T> operator-(const pair<S, T> &s, const pair<S, T> &t) {
  return pair<S, T>(s.first - t.first, s.second - t.second);
}
template <class S, class T>
ostream &operator<<(ostream &os, pair<S, T> p) {
  os << "(" << p.first << ", " << p.second << ")";
  return os;
}
template <class T>
bool chmax(T &a, const T &b) {
  if (a < b) {
    a = b;
    return 1;
  }
  return 0;
}
template <class T>
bool chmin(T &a, const T &b) {
  if (a > b) {
    a = b;
    return 1;
  }
  return 0;
}
const long long inf = 1000000001;
const long long INF = (long long)1e18 + 1;
const long long MOD = 998244353;
const double pi = 3.14159265358979323846;
int dx[4] = {1, 0, -1, 0}, dy[4] = {0, 1, 0, -1};
int dx2[8] = {1, 1, 0, -1, -1, -1, 0, 1}, dy2[8] = {0, 1, 1, 1, 0, -1, -1, -1};
template <typename T1, typename T2>
class LazySegmentTree {
 public:
  using F = function<T1(T1 &, T1 &)>;
  using G = function<T2(T2 &, T2 &)>;
  using H = function<T1(T1 &, T2 &, int, int)>;
  int n;
  vector<T1> node;
  vector<T2> lazy;
  T1 e1;
  T2 e2;
  F query_func;
  G update_func;
  H eval_func;
  LazySegmentTree(vector<T1> a, F query_func, G update_func, H eval_func, T1 e1,
                  T2 e2)
      : query_func(query_func),
        update_func(update_func),
        eval_func(eval_func),
        e1(e1),
        e2(e2) {
    int _n = a.size();
    n = 1;
    while (n < _n) n *= 2;
    node.resize(2 * n - 1, e1);
    lazy.resize(2 * n - 1, e2);
    for (int i = 0; i < _n; i++) node[i + n - 1] = a[i];
    for (int i = n - 2; i >= 0; i--) {
      node[i] = query_func(node[i * 2 + 1], node[i * 2 + 2]);
    }
  }
  inline void eval(int k, int l, int r) {
    if (lazy[k] != e2) {
      node[k] = eval_func(node[k], lazy[k], l, r);
      if (r - l > 1) {
        lazy[2 * k + 1] = update_func(lazy[2 * k + 1], lazy[k]);
        lazy[2 * k + 2] = update_func(lazy[2 * k + 2], lazy[k]);
      }
      lazy[k] = e2;
    }
  }
  void update(int a, int b, T2 x, int k, int l, int r) {
    eval(k, l, r);
    if (b <= l || r <= a) return;
    if (a <= l && r <= b) {
      lazy[k] = update_func(lazy[k], x);
      eval(k, l, r);
    } else {
      update(a, b, x, 2 * k + 1, l, (l + r) / 2);
      update(a, b, x, 2 * k + 2, (l + r) / 2, r);
      node[k] = query_func(node[2 * k + 1], node[2 * k + 2]);
    }
  }
  T1 query(int a, int b, int k, int l, int r) {
    eval(k, l, r);
    if (b <= l || r <= a) return e1;
    if (a <= l && r <= b) return node[k];
    T1 resl = query(a, b, 2 * k + 1, l, (l + r) / 2);
    T1 resr = query(a, b, 2 * k + 2, (l + r) / 2, r);
    return query_func(resl, resr);
  }
};
vector<int> primes;
int m;
array<long long, 62> f1(array<long long, 62> a, array<long long, 62> b) {
  array<long long, 62> res;
  for (int i = 0; i < (m); i++) {
    res[i] = a[i] + b[i];
  }
  return res;
}
array<long long, 62> f3(array<long long, 62> a, array<long long, 62> b, int l,
                        int r) {
  array<long long, 62> res = a;
  for (int i = 0; i < (m); i++) {
    res[i] += b[i] * (r - l);
  }
  return res;
}
long long mod_pow(long long x, long long p, long long M = MOD) {
  long long a = 1;
  while (p) {
    if (p % 2) a = a * x % M;
    x = x * x % M;
    p /= 2;
  }
  return a;
}
long long mod_inverse(long long a, long long M = MOD) {
  return mod_pow(a, M - 2, M);
}
vector<int> eulers;
int eulerSingle(int n) {
  int res = n;
  for (int i = 2; i * i <= n; i++) {
    if (n % i == 0) {
      res = res / i * (i - 1);
      for (; n % i == 0; n /= i)
        ;
    }
  }
  if (n != 1) res = res / n * (n - 1);
  return res;
}
array<long long, 62> get_array(long long x) {
  array<long long, 62> res;
  for (int j = 0; j < primes.size(); j++) {
    int p = primes[j];
    res[j] = 0;
    while (x % p == 0) {
      res[j]++;
      x /= p;
    }
  }
  return res;
}
int main() {
  int n, m, k;
  cin >> n >> m >> k;
  vector<int> a(n);
  for (int i = 0; i < (n); i++) {
    cin >> a[i];
  }
  vector<int> b = a;
  sort(b.begin(), b.end());
  reverse(b.begin(), b.end());
  multiset<long long> st;
  long long ans = 0;
  for (int i = 0; i < (m * k); i++) {
    st.insert(b[i]);
    ans += b[i];
  }
  int cnt = 0;
  vector<int> p;
  for (int i = 0; i < (n); i++) {
    auto itr = st.lower_bound(a[i]);
    int temp = *itr;
    if (*itr == a[i]) {
      cnt++;
      st.erase(itr);
      if (cnt == m) {
        p.push_back(i + 1);
        cnt = 0;
      }
    }
  }
  cout << ans << endl;
  p.pop_back();
  for (int i = 0; i < (p.size()); i++) {
    cout << p[i] << " ";
  }
  cout << endl;
}

### Prompt

In CPP, your task is to solve the following problem:

An array b is called to be a subarray of a if it forms a continuous subsequence of a, that is, if it is equal to a_l, a_{l + 1}, …, a_r for some l, r.

Suppose m is some known constant. For any array, having m or more elements, let's define it's beauty as the sum of m largest elements of that array. For example: 

  * For array x = [4, 3, 1, 5, 2] and m = 3, the 3 largest elements of x are 5, 4 and 3, so the beauty of x is 5 + 4 + 3 = 12.
  * For array x = [10, 10, 10] and m = 2, the beauty of x is 10 + 10 = 20.



You are given an array a_1, a_2, …, a_n, the value of the said constant m and an integer k. Your need to split the array a into exactly k subarrays such that:

  * Each element from a belongs to exactly one subarray.
  * Each subarray has at least m elements.
  * The sum of all beauties of k subarrays is maximum possible.

Input

The first line contains three integers n, m and k (2 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ m, 2 ≤ k, m ⋅ k ≤ n) — the number of elements in a, the constant m in the definition of beauty and the number of subarrays to split to.

The second line contains n integers a_1, a_2, …, a_n (-10^9 ≤ a_i ≤ 10^9).

Output

In the first line, print the maximum possible sum of the beauties of the subarrays in the optimal partition.

In the second line, print k-1 integers p_1, p_2, …, p_{k-1} (1 ≤ p_1 < p_2 < … < p_{k-1} < n) representing the partition of the array, in which:

  * All elements with indices from 1 to p_1 belong to the first subarray.
  * All elements with indices from p_1 + 1 to p_2 belong to the second subarray.
  * ….
  * All elements with indices from p_{k-1} + 1 to n belong to the last, k-th subarray.



If there are several optimal partitions, print any of them.

Examples

Input


9 2 3
5 2 5 2 4 1 1 3 2


Output


21
3 5 

Input


6 1 4
4 1 3 2 2 3


Output


12
1 3 5 

Input


2 1 2
-1000000000 1000000000


Output


0
1 

Note

In the first example, one of the optimal partitions is [5, 2, 5], [2, 4], [1, 1, 3, 2].

  * The beauty of the subarray [5, 2, 5] is 5 + 5 = 10. 
  * The beauty of the subarray [2, 4] is 2 + 4 = 6. 
  * The beauty of the subarray [1, 1, 3, 2] is 3 + 2 = 5. 



The sum of their beauties is 10 + 6 + 5 = 21.

In the second example, one optimal partition is [4], [1, 3], [2, 2], [3].

### Response

```cpp
#include <bits/stdc++.h>
using namespace std;
template <class S, class T>
pair<S, T> operator+(const pair<S, T> &s, const pair<S, T> &t) {
  return pair<S, T>(s.first + t.first, s.second + t.second);
}
template <class S, class T>
pair<S, T> operator-(const pair<S, T> &s, const pair<S, T> &t) {
  return pair<S, T>(s.first - t.first, s.second - t.second);
}
template <class S, class T>
ostream &operator<<(ostream &os, pair<S, T> p) {
  os << "(" << p.first << ", " << p.second << ")";
  return os;
}
template <class T>
bool chmax(T &a, const T &b) {
  if (a < b) {
    a = b;
    return 1;
  }
  return 0;
}
template <class T>
bool chmin(T &a, const T &b) {
  if (a > b) {
    a = b;
    return 1;
  }
  return 0;
}
const long long inf = 1000000001;
const long long INF = (long long)1e18 + 1;
const long long MOD = 998244353;
const double pi = 3.14159265358979323846;
int dx[4] = {1, 0, -1, 0}, dy[4] = {0, 1, 0, -1};
int dx2[8] = {1, 1, 0, -1, -1, -1, 0, 1}, dy2[8] = {0, 1, 1, 1, 0, -1, -1, -1};
template <typename T1, typename T2>
class LazySegmentTree {
 public:
  using F = function<T1(T1 &, T1 &)>;
  using G = function<T2(T2 &, T2 &)>;
  using H = function<T1(T1 &, T2 &, int, int)>;
  int n;
  vector<T1> node;
  vector<T2> lazy;
  T1 e1;
  T2 e2;
  F query_func;
  G update_func;
  H eval_func;
  LazySegmentTree(vector<T1> a, F query_func, G update_func, H eval_func, T1 e1,
                  T2 e2)
      : query_func(query_func),
        update_func(update_func),
        eval_func(eval_func),
        e1(e1),
        e2(e2) {
    int _n = a.size();
    n = 1;
    while (n < _n) n *= 2;
    node.resize(2 * n - 1, e1);
    lazy.resize(2 * n - 1, e2);
    for (int i = 0; i < _n; i++) node[i + n - 1] = a[i];
    for (int i = n - 2; i >= 0; i--) {
      node[i] = query_func(node[i * 2 + 1], node[i * 2 + 2]);
    }
  }
  inline void eval(int k, int l, int r) {
    if (lazy[k] != e2) {
      node[k] = eval_func(node[k], lazy[k], l, r);
      if (r - l > 1) {
        lazy[2 * k + 1] = update_func(lazy[2 * k + 1], lazy[k]);
        lazy[2 * k + 2] = update_func(lazy[2 * k + 2], lazy[k]);
      }
      lazy[k] = e2;
    }
  }
  void update(int a, int b, T2 x, int k, int l, int r) {
    eval(k, l, r);
    if (b <= l || r <= a) return;
    if (a <= l && r <= b) {
      lazy[k] = update_func(lazy[k], x);
      eval(k, l, r);
    } else {
      update(a, b, x, 2 * k + 1, l, (l + r) / 2);
      update(a, b, x, 2 * k + 2, (l + r) / 2, r);
      node[k] = query_func(node[2 * k + 1], node[2 * k + 2]);
    }
  }
  T1 query(int a, int b, int k, int l, int r) {
    eval(k, l, r);
    if (b <= l || r <= a) return e1;
    if (a <= l && r <= b) return node[k];
    T1 resl = query(a, b, 2 * k + 1, l, (l + r) / 2);
    T1 resr = query(a, b, 2 * k + 2, (l + r) / 2, r);
    return query_func(resl, resr);
  }
};
vector<int> primes;
int m;
array<long long, 62> f1(array<long long, 62> a, array<long long, 62> b) {
  array<long long, 62> res;
  for (int i = 0; i < (m); i++) {
    res[i] = a[i] + b[i];
  }
  return res;
}
array<long long, 62> f3(array<long long, 62> a, array<long long, 62> b, int l,
                        int r) {
  array<long long, 62> res = a;
  for (int i = 0; i < (m); i++) {
    res[i] += b[i] * (r - l);
  }
  return res;
}
long long mod_pow(long long x, long long p, long long M = MOD) {
  long long a = 1;
  while (p) {
    if (p % 2) a = a * x % M;
    x = x * x % M;
    p /= 2;
  }
  return a;
}
long long mod_inverse(long long a, long long M = MOD) {
  return mod_pow(a, M - 2, M);
}
vector<int> eulers;
int eulerSingle(int n) {
  int res = n;
  for (int i = 2; i * i <= n; i++) {
    if (n % i == 0) {
      res = res / i * (i - 1);
      for (; n % i == 0; n /= i)
        ;
    }
  }
  if (n != 1) res = res / n * (n - 1);
  return res;
}
array<long long, 62> get_array(long long x) {
  array<long long, 62> res;
  for (int j = 0; j < primes.size(); j++) {
    int p = primes[j];
    res[j] = 0;
    while (x % p == 0) {
      res[j]++;
      x /= p;
    }
  }
  return res;
}
int main() {
  int n, m, k;
  cin >> n >> m >> k;
  vector<int> a(n);
  for (int i = 0; i < (n); i++) {
    cin >> a[i];
  }
  vector<int> b = a;
  sort(b.begin(), b.end());
  reverse(b.begin(), b.end());
  multiset<long long> st;
  long long ans = 0;
  for (int i = 0; i < (m * k); i++) {
    st.insert(b[i]);
    ans += b[i];
  }
  int cnt = 0;
  vector<int> p;
  for (int i = 0; i < (n); i++) {
    auto itr = st.lower_bound(a[i]);
    int temp = *itr;
    if (*itr == a[i]) {
      cnt++;
      st.erase(itr);
      if (cnt == m) {
        p.push_back(i + 1);
        cnt = 0;
      }
    }
  }
  cout << ans << endl;
  p.pop_back();
  for (int i = 0; i < (p.size()); i++) {
    cout << p[i] << " ";
  }
  cout << endl;
}

```