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

Solution (in JAVA):

Solution:
import java.util.*;
import java.io.*;  

public class Solution{
    // int t=Integer.parseInt(br.readLine());
        // while(t-->0){
        //     int n=Integer.parseInt(strs[0]);
        //     String line=br.readLine();
        //     String[] strs=line.trim().split(" ");
        //     int[] arr=new int[n];
        //     for(int i=0;i<v;i++){
        //         arr[i]=Integer.parseInt(strs[i]);
        //     }
        // }
    public static class pair{
        int x;
        int y;
    }
    public static void main(String[] args) throws IOException{
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        // int t=Integer.parseInt(br.readLine());
        // while(t-->0){
            String line=br.readLine();
            String[] strs=line.trim().split(" ");
            int n=Integer.parseInt(strs[0]);
            int m=Integer.parseInt(strs[1]);
            int k=Integer.parseInt(strs[2]);
            line=br.readLine();
            strs=line.trim().split(" ");
            int[] arr=new int[n];
            Integer[] v=new Integer[n];
            for(int i=0;i<arr.length;i++){
                arr[i]=Integer.parseInt(strs[i]);
                v[i]=arr[i];
            }
            Arrays.sort(v,Collections.reverseOrder());
            ArrayList<Integer> list=new ArrayList<>();
            HashMap<Integer,Integer> map=new HashMap<>();
            long sum=0;
            for(int i=0;i<m*k;i++){
                sum+=v[i];
                if(map.containsKey(v[i])){
                    int val=map.get(v[i]);
                    map.put(v[i],val+1);
                }else{
                    map.put(v[i],1);
                }
            }
            int i=0;
            int made=0;
            int l=0;
            int ese=0;
            while(i<n){
                if(made==k-1){
                    break;
                }
                if(l<m){
                    l++;
                    if(map.containsKey(arr[i])){
                        int val=map.get(arr[i]);
                        if(val==1){
                            map.remove(arr[i]);
                        }else{
                            map.put(arr[i],val-1);
                        }
                        ese++;
                    }
                    if(ese==m){
                        l=0;
                        ese=0;
                        list.add(i+1);
                        // System.out.println(i);
                        made++;
                    }
                    i++;
                }else{
                    l++;
                    if(map.containsKey(arr[i])){
                        int val=map.get(arr[i]);
                        if(val==1){
                            map.remove(arr[i]);
                        }else{
                            map.put(arr[i],val-1);
                        }
                        ese++;
                    }
                    if(ese==m){
                        l=0;
                        ese=0;
                        list.add(i+1);
                        made++;
                    }
                    i++;
                }
            }
            System.out.println(sum);
            for(int j=0;j<list.size();j++){
                System.out.print(list.get(j)+" ");
            }
    } 
    
    public static long quala(long b){
        long val=(long)Math.ceil(Math.pow(1+(8*b),0.5));
        if(val%2==0){
            long va=(long)(2+val)/(long)2;
            return va;
        }else{
            long va=(long)(1+val)/(long)2;
            return va;
        }
    }
    public static String find(int a,int b){
        if(a==3){
            if(b==1){
                return "abb";
            }else if(b==2){
                return "bab";
            }else{
                return "bba";
            }
        }
        int v=((a-1)*(a-2))/2;
        if(b<=v){
            String s=find(a-1,b);
            StringBuffer sb=new StringBuffer(s);
            int diff=a-s.length();
            while(diff-->0){
                sb.insert(0,"a");
            }
            return sb.toString();
        }else{
            int diff=b-v;
            StringBuffer sb=new StringBuffer();
            sb.append("b");
            for(int i=0;i<a-diff-1;i++){
                sb.append("a");
            }
            sb.append("b");
            for(int i=0;i<diff-1;i++){
                sb.append("a");
            }
            return sb.toString();
        }
        // return new String("a"+s);
    }
    public static long z(long val){
        long p=1;
        while(val!=0){
            long rem=val%10;
            p*=rem;
            val=val/10;
        }
        return p;
    }
    public static int[] soe(int n){
        int[] arr=new int[n];
        arr[0]=0;
        for(int i=1;i<n;i++){
            if(arr[i]==0){
                for(int j=(2*(i+1))-1;j<n;j=j+i+1){
                    arr[j]=1;
                }
            }
        }
        return arr;
    }
    public static int[][] floydWarshall(int graph[][],int V){ 
        int dist[][] = new int[V][V]; 
        int i, j, k; 
        for (i = 0; i < V; i++){ 
            for (j = 0; j < V; j++){
                dist[i][j] = graph[i][j]; 
            }
        }
        for (k = 0; k < V; k++) { 
            for (i = 0; i < V; i++){ 
                for (j = 0; j < V; j++){ 
                    if (dist[i][k] + dist[k][j] < dist[i][j]){ 
                        dist[i][j] = dist[i][k] + dist[k][j]; 
                    }
                } 
            } 
        }
        return dist;
    } 
    public static class Comp implements Comparator<pair>{
        public int compare(pair a,pair b){
            if(a.x!=b.x){
                return a.x-b.x;
            }else{
                return a.y-b.y;
            }
        }
    }
    public static int gcd(int a,int b){
        if (b == 0) 
        return a; 
        return gcd(b, a % b);
    }
    public static int lcm(int a,int b){
        int x=Math.max(a,b);
        int y=Math.min(a,b);
        long ans=x;
        while(ans%y!=0){
            ans+=x;
        }
        if(ans>Integer.MAX_VALUE){
            return -1;
        }
        return (int)ans;
    }
    public static long fact(int n){
        long ans=1;
        for(int i=1;i<=n;i++){
            ans*=i;
        }
        return ans;
    }
}