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.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.lang.reflect.Array;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Map.Entry;
import java.util.PriorityQueue;
import java.util.StringTokenizer;
import java.util.TreeMap;
import java.util.TreeSet;

import javafx.scene.layout.Priority;


public class Main {
	static Scanner sc = new Scanner(System.in);

	/*public static void main(String[] args) throws IOException {
		int n=sc.nextInt();
		int beg=0;
		boolean on=false;
		int[] a= new int[n];
		for (int i = 0; i < n; i++) {
			a[i]=sc.nextInt();
		}
		int max=-1;
		int curr=0;
		//System.out.println(Arrays.toString(a));
		for (int i = 0; i < a.length; i++) {
			if(i ==0 && a[0]==1)
			{
				beg++;
				on=true;
			}
			else if(a[i]==1)
			{
				curr++;
				if(on)
				{
					beg++;
				}
			}
			else
			{
				if(on)
				{
					on=false;
				}
				if(max==-1 || max<curr)
				{
					max=curr;
				}
				curr=0;
			}
			//System.out.println(beg + " " + on + " " + curr + " " + max);
		}
		if(!on)
		{
			
			curr=curr+ beg;
			if(max==-1 || max<curr)
			{
				max=curr;
				curr=0;
			}
		}
		else if(on)
		{
			max=a.length;
		}
		System.out.println(max);
	}*/
	
	/*public static void main(String[] args) throws IOException {
		long n=sc.nextLong();
		long wx=1;
		long wy=1;
		long bx=n;
		long by=n;
		long x=sc.nextLong();
		long y=sc.nextLong();
		if(wx==x && wy==y)
		{
			System.out.println("White");
		}
		else if(bx==x && by==y)
		{
			System.out.println("Black");
		}
		else
		{
			Long movesB=(long) 0;
			Long movesW=(long) 0;
			
			if(Math.abs(x-wx)<=Math.abs(y-wy))
			{
				movesW=Math.abs(x-wx) + Math.abs(y-x);
			}
			else if(Math.abs(x-wx)>Math.abs(y-wy))
			{
				//System.out.println(2);
				movesW=Math.abs(y-wy) + Math.abs(y-x);
			}
			//System.out.println(movesW);
			if(Math.abs(x-bx)<=Math.abs(y-by))
			{
				//System.out.println(1);
				movesB=Math.abs(x-bx) + Math.abs(y-x);
			}
			else if(Math.abs(x-bx)>Math.abs(y-by))
			{
				//System.out.println(2);
				movesB=Math.abs(y-by) + Math.abs(y-x);
			}
			//System.out.println(movesB);
			if(movesW<= movesB)
			{
				System.out.println("White");
			}
			else
			{
				System.out.println("Black");
			}
			
		}
		
	}*/
	
	/*public static void main(String[] args) throws IOException {
		int n=sc.nextInt();
		int[] a= new int[n];
		
		for (int i = 0; i < a.length; i++) {
			a[i]=sc.nextInt();
		}
		
		int max=-1;
		int curr=1;
		
		for (int i = 1; i < a.length; i++) {
			if(a[i]-a[i-1]==1)
			{
				curr++;
			}
			else
			{
				if(i==curr && a[0]==1 && a[i-1]==i)
				{
					if(max==-1 || max<curr-1)
					max=curr-1;
				}
				else
				{
					if(max==-1 || max<curr-2)
						max=curr-2;
				}
				
				curr=1;
			}
		}
		if(a[a.length-1]==1000)
		{
			if(max==-1 || max<curr-1)
			max=curr-1;
		}
			
		else if(a[0]==1 && a[a.length-1]==a.length)
		{
			if(max==-1 || max<curr-1)
			max=curr-1;
		}
		else
		{
			if(max==-1 || max<curr-2)
			max=curr-2;
		}
		
		if(max==-1)
		{
			System.out.println(0);
		}
		else
		System.out.println(max);
	}*/
	static int n;
	static boolean exists=false;
	static int[] finalArray;
	public static void solve(int[] a, int index, int sum)
	{
		if(index==a.length)
		{
			int temp=0;
			for (int i = 0; i < a.length; i++) {
				temp+=a[i];
			}
			if(temp==n)
			{
				finalArray= new int[a.length];
				for (int i = 0; i < a.length; i++) {
					finalArray[i]=a[i];
				}
				exists=true;
			}
			
			return;
		}
		for(int i=0; i<30; i++)
		{
			if(sum+Math.pow(2, i)>n || exists)
			{
				return;
			}
			a[index]=(int) Math.pow(2, i);
			solve(a, index+1, sum +(int) Math.pow(2, i));
		}
	}
	/*public static void main(String[] args) throws IOException {
		n=sc.nextInt();
		int k=sc.nextInt();
		
		int[]a= new int[k];
		solve(a, 0,0);
		if(!exists)
		{
			System.out.println("NO");
		}
		else
		{
			System.out.println("YES");
			for (int i = 0; i < a.length; i++) {
				if(i==0)
				{
					System.out.print(finalArray[i]);
				}
				else
				{
					System.out.print(" " + finalArray[i]);
				}
			}
		}
	}*/
	
	/*public static void main(String[] args) throws IOException {
		TreeSet<Integer> set= new TreeSet<Integer>();
		int n=sc.nextInt();
		int k=sc.nextInt();
		if(n<k)
		{
			System.out.println("NO");
		}
		else
		{
			for(int i=0; i<=30; i++)
			{
				set.add((int) Math.pow(2, i));
			}
			
			PriorityQueue<Integer> pq= new PriorityQueue<Integer>(Collections.reverseOrder());
			while(!set.contains(n))
			{
				int temp=1;
				while(Math.pow(2, temp)<=n)
				{
					temp++;
				}
				temp--;
				int temp2=(int)Math.pow(2, temp);
				pq.add(temp2);
				n=n%temp2;
			}
			pq.add(n);
			
			if(pq.size()>k)
			{
				System.out.println("NO");
			}
			else
			{
				System.out.println("YES");
				while(pq.size()!=k)
				{
					int temp= pq.remove();
					pq.add(temp/2);
					pq.add(temp/2);
				}
				boolean first=true;
				for(int x: pq)
				{
					if(first)
					{
						System.out.print(x);
						first=false;
					}
					else
					{
						System.out.print(" " + x);
					}
				}	
			}
		}
	}*/
	
	/*public static void main(String[] args) throws IOException {
		int n=sc.nextInt();
		int k=sc.nextInt();
		
		int[] p=new int[n];
		TreeMap<Integer, Integer> map= new TreeMap<Integer, Integer>();
		for (int i = 0; i < p.length; i++) {
			p[i]=sc.nextInt();
			map.put(p[i], i);
		}
		int[] c=new int[n];
		for (int i = 0; i < c.length; i++) {
			c[i]=sc.nextInt();
		}
		Knight[] arr= new Knight[n];
		for (int i = 0; i < arr.length; i++) {
			arr[i]=new Knight(p[i], c[i]);
		}
		Arrays.sort(arr);
		
		
		PriorityQueue<Integer> tree=new PriorityQueue<Integer>();
		long[] result=new long[n];
		for (int i = 0; i < arr.length; i++) {
			long sum=arr[i].c;
			for(int x: tree)
			{
				sum+=x;
			}
			result[map.get(arr[i].p)]=sum;
			if(tree.size()==k && k!=0)
			{
				if(tree.peek()<arr[i].c)
				{
					tree.poll();
					tree.add(arr[i].c);
				}
			}
			else if(tree.size()<k && k!=0)
			{
				tree.add(arr[i].c);
			}
			
		}
		for (int i = 0; i < result.length; i++) {
			if(i==0)
			{
				System.out.print(result[i]);
			}
			else
			{
				System.out.print(" " + result[i]);
			}
		}
	}*/
	
	public static void main(String[] args) throws IOException {
		int n=sc.nextInt();
		int m=sc.nextInt();
		int k=sc.nextInt();
				
		int[] a =new int[n];
		for (int i = 0; i < a.length; i++) {
			a[i]=sc.nextInt();
		}
		//System.out.println(Arrays.toString(a));
		PriorityQueue<ArrayCells> pq= new PriorityQueue<Main.ArrayCells>();
		
		for (int i = 0; i < a.length; i++) {
			if(pq.size()<m*k)
			{
				pq.add(new ArrayCells(i, a[i]));
			}
			else if(pq.peek().value<=a[i])
			{
				pq.poll();
				pq.add(new ArrayCells(i, a[i]));
			}
		}
		//System.out.println(pq.toString());
		long value=0;
		int[] indexes= new int[m*k];
		int i=0;
		for (ArrayCells ac: pq) {
			value+=ac.value;
			indexes[i++]=++ac.index;
		}
		Arrays.sort(indexes);
		System.out.println(value);
		//System.out.println(Arrays.toString(indexes));
		boolean first=true;
		for (int j = 0; j < indexes.length; j++) {
			if((j+1)%m==0 && j!=indexes.length-1)
			{
				if(first)
				{
					System.out.print(indexes[j]);
					first=false;
				}
				else
				System.out.print(" "+ indexes[j]);
			}
		}
	}
	
	static class ArrayCells implements Comparable<ArrayCells>
	{
		int index;
		int value;
		public ArrayCells(int i, int v) {
			// TODO Auto-generated constructor stub
			index=i;
			value=v;
		}
		@Override
		public int compareTo(ArrayCells a) {
			// TODO Auto-generated method stub
			if(this.value==a.value)
			{
				return this.index-a.index;
			}
			return this.value-a.value;
		}
		
		public String toString()
		{
			return "(" + index + "," + value + ")";
		}
		
	}
	static class Knight implements Comparable<Knight>
	{
		int p;
		int c;
		 public Knight(int p, int c) {
			// TODO Auto-generated constructor stub
			this.p=p;
			this.c=c;
		}
		@Override
		public int compareTo(Knight k) {
			// TODO Auto-generated method stub
			return this.p-k.p;
		}
		
	}
	static class Scanner {
		StringTokenizer st;
		BufferedReader br;
 
		public Scanner(InputStream s) {
			br = new BufferedReader(new InputStreamReader(s));
		}
 
		public String next() throws IOException {
			while (st == null || !st.hasMoreTokens())
				st = new StringTokenizer(br.readLine());
			return st.nextToken();
		}
 
		public int nextInt() throws IOException {
			return Integer.parseInt(next());
		}
 
		public long nextLong() throws IOException {
			return Long.parseLong(next());
		}
 
		public String nextLine() throws IOException {
			return br.readLine();
		}
 
		public double nextDouble() throws IOException {
			String x = next();
			StringBuilder sb = new StringBuilder("0");
			double res = 0, f = 1;
			int start = 0;
			boolean dec = false, neg = false;
			if (x.charAt(0) == '-') {
				neg = true;
				start++;
			}
			for (int i = start; i < x.length(); i++)
				if (x.charAt(i) == '.') {
					res = Long.parseLong(sb.toString());
					sb = new StringBuilder("0");
					dec = true;
				} else {
					sb.append(x.charAt(i));
					if (dec)
						f *= 10;
				}
			res += Long.parseLong(sb.toString()) / f;
			return res * (neg ? -1 : 1);
		}
 
		public boolean ready() throws IOException {
			return br.ready();
		}
 
	}
}