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}$, $\ldots$, $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, \ldots, 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 \le n \le 2 \cdot 10^5$, $1 \le m$, $2 \le k$, $m \cdot k \le 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, \ldots, a_n$ ($-10^9 \le a_i \le 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, \ldots, p_{k-1}$ ($1 \le p_1 < p_2 < \ldots < 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.

 $\ldots$.

 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]$.

Difficulty: interview

Starter code:

Solutions:
#! usr/bin/env python
# -*- coding: utf-8 -*-

from collections import deque
import heapq
import math
import bisect


def main():
    N, M, K = list(map(int, input().split()))
    A = list(map(int, input().split()))

    B = [(A[i], i) for i in range(N)]
    B.sort(reverse=True)

    used = [0] * N
    ans = 0
    for i in range(M*K):
        idx = B[i][1]
        used[idx] = 1
        ans += B[i][0]

    lst = []
    cnt = le = 0
    for i in range(N):
        if used[i]:
            cnt += 1
        if cnt == M:
            lst.append(i+1)
            cnt = 0
            le += 1
            if le == K - 1:
                break

    print(ans)
    print(*lst)


def __starting_point():
    main()

__starting_point()

n,m,k=map(int,input().split())
A=list(map(int,input().split()))

B=list(enumerate(A))
B.sort(key=lambda x:x[1])
B.reverse()

LIST=[0]*n
ANS=0

for i in range(m*k):
    LIST[B[i][0]]=1
    ANS+=B[i][1]

ANSLIST=[]
count=0
for i in range(n):
    if LIST[i]==1:
        count+=1

    if count==m:
        ANSLIST.append(i+1)
        count=0

print(ANS)
for a in ANSLIST[:-1]:
    print(a,end=" ")


n, m, k = map(int, input().split())
a = list(map(int, input().split()))
b = []
for i in range(n):
    b.append((a[i], i + 1))
b.sort(reverse=True)
c = b[: m * k]
c.sort(key=lambda x: x[1])

ans = 0
for i in c:
    ans += i[0]

print(ans)
for i in range(len(c) - 1):
    if (i + 1) % m == 0:
        print(c[i][1], end=' ')

def func(n):
    return n[1]


n, m, k = map(int, input().split())
a = list(map(int, input().split()))
b = [[a[i], i] for i in range(len(a))]
b.sort(reverse=True)
b = b[:m * k]
b.sort(key=func)
ans = []
ans2 = 0
for i in range(0, len(b), 1):
    if (i + 1) % m == 0:
        ans.append(b[i][1] + 1)
    ans2 += b[i][0]
print(ans2)
print(' '.join(map(str, ans[:-1])))

n, m, k = list(map(int, input().split()))
a = list(map(int, input().split()))

indexed_a = list(zip(a, list(range(n))))

sorted_indexed_a = list(reversed(sorted(indexed_a)))

sorted_a = list(reversed(sorted(a)))

partition = list(sorted([y for x,y in sorted_indexed_a[:(m*k)]]))
print(sum(sorted_a[:(m*k)]))
result = [x + 1 for x in partition[(m-1)::m]]
print(' '.join([ str(x) for x in result[:-1]]))


# -*- coding: utf-8 -*-
# @Time    : 2019/2/10 22:11
# @Author  : LunaFire
# @Email   : gilgemesh2012@gmail.com
# @File    : B. Yet Another Array Partitioning Task.py


def main():
    n, m, k = list(map(int, input().split()))
    a = list(map(int, input().split()))
    ret = sum(a)

    index = list(range(n))
    index.sort(key=lambda i: a[i])
    rm_flag = [False] * n
    for i in range(n - m * k):
        rm_flag[index[i]] = True
        ret -= a[index[i]]

    pos, cnt = [], 0
    for i in range(n):
        if not rm_flag[i]:
            cnt += 1
            if cnt == m:
                pos.append(i + 1)
                cnt = 0
                if len(pos) == k - 1:
                    break

    print(ret)
    print(*pos)


def __starting_point():
    main()


__starting_point()

'''input
2 1 2
-1000000000 1000000000

9 2 3
5 2 5 2 4 1 1 3 2
6 1 4
4 1 3 2 2 3
'''
n, m, k = list(map(int, input().split()))
a = list(map(int, input().split()))
b = sorted([(a[i], i) for i in range(n)])
ok = [0] * n
ans = 0
for x, i in b[-k * m:]:
	ok[i] = 1
	ans += x
# print(ok)
t = 0
li = []
for i in range(n):
	t += ok[i]
	if ok[i] and t % m == 0:
		li += [i + 1]
print(ans)
print(*li[:-1])


import bisect

n, m, k = list(map(int, input().strip().split()))
array = list(map(int, input().strip().split()))

new_array = [(v, idx) for idx, v in enumerate(array)]
new_array.sort()

to_select = new_array[-m*k:]

to_select = [(b, a) for a, b in to_select]
to_select.sort()

res = 0
curr_m = 0
partitions = []
for pos, val in to_select:
	res += val
	curr_m += 1
	if curr_m == m:
		partitions.append(str(pos+1))
		curr_m = 0


print(res)
print(" ".join(partitions[:-1]))