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:
//package sept;

import java.io.*;
import java.util.*;



public class TimePass implements Runnable {
    InputStream is;
    PrintWriter out;
    String INPUT = "";
    //boolean debug=false;
    boolean debug=true;
    static long mod=998244353;
    static long mod2=1000000007;
    
    void solve() throws IOException
	{
    	int n=ni(),m=ni(),k=ni();
    	int[] a=na(n);
    	ArrayList<Pair> list=new ArrayList<>();
    	for(int i=0;i<n;i++)
    	{
    		list.add(new Pair(a[i],i));
    	}
    	Collections.sort(list,new Comparator<Pair>() {
    		public int compare(Pair p1,Pair p2)
    		{
    			return p2.a-p1.a;
    		}
    	});
    	
    	int[] b=new int[n];
    	long val=0;
    	for(int i=0;i<m*k;i++)
    	{
    		b[list.get(i).b]=1;
    		val+=list.get(i).a;
    	}
    	out.println(val);
    	int cnt=0;
    	int t=0;
    	for(int i=0;i<n;i++)
    	{
    		cnt+=b[i];
    		if(cnt==m)
    		{
    			t++;
    			out.print((i+1)+" ");
    			cnt=0;
    			if(t==k-1)break;
    		}
    	}
    	out.println();
	}
    
	static int[][] packD(int n,int[] from,int[] to)
	{
		int[][] g=new int[n][];
		int[] p=new int[n];
		for(int f:from)
		{
			p[f]++;
		}
		int m=from.length;
		for(int i=0;i<n;i++)
		{
			g[i]=new int[p[i]];
		}
		for(int i=0;i<m;i++)
		{
			g[from[i]][--p[from[i]]]=to[i];
		}
		return g;
	}
	    
    static class Pair
    {
        int a,b,c;
        public Pair(int a,int b)
        {
            this.a=a;
            this.b=b;
            //this.ind=ind;
        }
    }
    
    static long lcm(int a,int b)
    {
        long val=a;
        val*=b;
        return (val/gcd(a,b));
    }
    
    static long gcd(long a,long b)
    {
        if(a==0)return b;
        return gcd(b%a,a);
    }
    
    static int pow(int a, int b, int p)
    {
        long ans = 1, base = a;
        while (b!=0)
        {
            if ((b & 1)!=0)
            {
                ans *= base;
                ans%= p;
            }
            base *= base;
            base%= p;
            b >>= 1;
        }
        return (int)ans;
    }

    static int inv(int x, int p)
    {
        return pow(x, p - 2, p);
    }
    
    public void run()
    {
        if(debug)oj=true;
        is = oj ? System.in : new ByteArrayInputStream(INPUT.getBytes());
        out = new PrintWriter(System.out);
        
        long s = System.currentTimeMillis();
        try {
			solve();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
        out.flush();
        tr(System.currentTimeMillis()-s+"ms");
    }
    
    public static void main(String[] args) throws Exception {new Thread(null,new TimePass(),"Main",1<<26).start();}
    
    private byte[] inbuf = new byte[1024];
    public int lenbuf = 0, ptrbuf = 0;
    
    private int readByte()
    {
        if(lenbuf == -1)throw new InputMismatchException();
        if(ptrbuf >= lenbuf){
            ptrbuf = 0;
            try { lenbuf = is.read(inbuf); } catch (IOException e) { throw new InputMismatchException(); }
            if(lenbuf <= 0)return -1;
        }
        return inbuf[ptrbuf++];
    }
    
    private boolean isSpaceChar(int c) { return !(c >= 33 && c <= 126); }
    private int skip() { int b; while((b = readByte()) != -1 && isSpaceChar(b)); return b; }
    
    private double nd() { return Double.parseDouble(ns()); }
    private char nc() { return (char)skip(); }
    
    private String ns()
    {
        int b = skip();
        StringBuilder sb = new StringBuilder();
        while(!(isSpaceChar(b))){ // when nextLine, (isSpaceChar(b) && b != ' ')
            sb.appendCodePoint(b);
            b = readByte();
        }
        return sb.toString();
    }
    
    private char[] ns(int n)
    {
        char[] buf = new char[n];
        int b = skip(), p = 0;
        while(p < n && !(isSpaceChar(b))){
            buf[p++] = (char)b;
            b = readByte();
        }
        return n == p ? buf : Arrays.copyOf(buf, p);
    }
    
    private char[][] nm(int n, int m)
    {
        char[][] map = new char[n][];
        for(int i = 0;i < n;i++)map[i] = ns(m);
        return map;
    }
    
    private int[] na(int n)
    {
        int[] a = new int[n];
        for(int i = 0;i < n;i++)a[i] = ni();
        return a;
    }
    
    private int ni()
    {
        int num = 0, b;
        boolean minus = false;
        while((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-'));
        if(b == '-'){
            minus = true;
            b = readByte();
        }
        
        while(true){
            if(b >= '0' && b <= '9'){
                num = num * 10 + (b - '0');
            }else{
                return minus ? -num : num;
            }
            b = readByte();
        }
    }
    
    private long nl()
    {
        long num = 0;
        int b;
        boolean minus = false;
        while((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-'));
        if(b == '-'){
            minus = true;
            b = readByte();
        }
        
        while(true){
            if(b >= '0' && b <= '9'){
                num = num * 10 + (b - '0');
            }else{
                return minus ? -num : num;
            }
            b = readByte();
        }
    }
    
    private boolean oj = System.getProperty("ONLINE_JUDGE") != null;
    private void tr(Object... o) { if(!oj)System.out.println(Arrays.deepToString(o)); }
}