Problem: There are n children, who study at the school №41. It is well-known that they are good mathematicians. Once at a break, they arranged a challenge for themselves. All children arranged in a row and turned heads either to the left or to the right.

Children can do the following: in one second several pairs of neighboring children who are looking at each other can simultaneously turn the head in the opposite direction. For instance, the one who was looking at the right neighbor turns left and vice versa for the second child. Moreover, every second at least one pair of neighboring children performs such action. They are going to finish when there is no pair of neighboring children who are looking at each other. 

You are given the number n, the initial arrangement of children and the number k. You have to find a way for the children to act if they want to finish the process in exactly k seconds. More formally, for each of the k moves, you need to output the numbers of the children who turn left during this move.

For instance, for the configuration shown below and k = 2 children can do the following steps: 

<image> At the beginning, two pairs make move: (1, 2) and (3, 4). After that, we receive the following configuration:  <image> At the second move pair (2, 3) makes the move. The final configuration is reached. Good job.  <image>

It is guaranteed that if the solution exists, it takes not more than n^2 "headturns".

Input

The first line of input contains two integers n and k (2 ≤ n ≤ 3000, 1 ≤ k ≤ 3000000) — the number of children and required number of moves.

The next line contains a string of length n and consists only of characters L and R, where L means that the child looks to the left and R means that the child looks to the right. 

Output

If there is no solution, print a single line with number -1.

Otherwise, output k lines. Each line has to start with a number n_i (1≤ n_i ≤ n/2) — the number of pairs of children, who turn at this move. After that print n_i distinct integers — the numbers of the children who will turn left during this move. 

After performing all "headturns", there can't be a pair of two neighboring children looking at each other.

If there are many solutions, print any of them.

Examples

Input


2 1
RL


Output


1 1 


Input


2 1
LR


Output


-1

Input


4 2
RLRL


Output


2 1 3 
1 2

Note

The first sample contains a pair of children who look at each other. After one move, they can finish the process.

In the second sample, children can't make any move. As a result, they can't end in k>0 moves.

The third configuration is described in the statement.

Solution (in JAVA):

Solution:
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStreamWriter;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.PriorityQueue;
import java.util.Map.Entry;


import java.util.Random;
import java.util.TreeSet;

public final class CF_632_D2_D
{


	static boolean verb=true;
	static void log(Object X){if (verb) System.err.println(X);}
	static void log(Object[] X){if (verb) {for (Object U:X) System.err.print(U+" ");System.err.println("");}}
	static void log(int[] X){if (verb) {for (int U:X) System.err.print(U+" ");System.err.println("");}}
	static void logWln(int[] X){if (verb) {for (int U:X) System.err.print(U+" ");}}
	static void log(int[] X,int L){if (verb) {for (int i=0;i<L;i++) System.err.print(X[i]+" ");System.err.println("");}}
	static void log(long[] X){if (verb) {for (long U:X) System.err.print(U+" ");System.err.println("");}}

	static void logWln(Object X){if (verb) System.err.print(X);}
	static void info(Object o){	System.out.println(o);}
	static void output(Object o){outputWln(""+o+"\n");	}
	static void outputFlush(Object o){try {out.write(""+ o+"\n");out.flush();} catch (Exception e) {}}
	static void outputWln(Object o){try {out.write(""+ o);} catch (Exception e) {}}


	static void logBin(int[] tm) {for (int x:tm) logWln(bin(8,x)+" ");log("");}

	static String bin(int L,int x) {
		String s=Integer.toBinaryString(x);
		while (s.length()<L) s="0"+s;
		return s;
	}

	// Global vars
	static BufferedWriter out;
	static InputReader reader;


	static void test() {
		log("testing");

		Random r=new Random();
		int NTESTS=100000;
		int NMAX=10;
		int VMAX=10;
		for (int t=0;t<NTESTS;t++) {

		}

	}

	static int st;







	static class Composite implements Comparable<Composite>{

		long v;
		int idx;
		long x;
		long d;

		public int compareTo(Composite X) {
			if (v<X.v)
				return -1;
			if (v>X.v)
				return 1;
			return idx-X.idx;
		}

		public Composite(long v, int idx, long x, long d) {
			this.v = v;
			this.idx = idx;
			this.x = x;
			this.d = d;
		}




	}


	static void test(long u) {
		long v=0;
		while ((v^u)<=Math.max(u, v))
			v++;
		log(u+" "+v+" "+(u^v));
	}

	static int[] tmp;

	static int best(int[] a) {
		int n=a.length;

		System.arraycopy(a,0,tmp,0,n);
		boolean goon=true;
		int iter=0;
		while (goon) {
			goon=false;
			int i=n-1;
			while (i>0) {
				if (tmp[i]==1 && tmp[i-1]==0) {
					tmp[i]=0;
					tmp[i-1]=1;
					i=i-2;
					goon=true;
				} else
					i--;
			}
			if (goon)
				iter++;
		}
		return iter;
	}

	static int getTot(int[] a) {
		int tot=0;
		int cnt=0;
		for (int x:a) {
			if (x==0)
				cnt++;
			else
				tot+=cnt;
		}
		return tot;
	}

	static void solve(int[] a,int k) {
		int n=a.length;
		int tot=getTot(a);
		tmp=new int[n];
		int b=best(a);
		//log(a);
		//log("b:"+b+" tot:"+tot);

		// not enough moves
		if (tot<k) {
			output("-1");
			//log("no enough action");
			return ;
		}
		if (b>k) {
			//log("too many action");
			output("-1");
			return;
		}
		// tot>=k && b<=k

		TreeSet<Integer> fre=new TreeSet<Integer>();
		int time=1;
		int[] visited=new int[n];
		for (int i=1;i<n;i++)
			if (a[i]==1 && a[i-1]==0)
				fre.add(-i);
		//log(fre);
		for (int st=0;st<k;st++) {
			ArrayList<Integer> ans=new ArrayList<Integer>();
			//log("iteration for st:"+st);

			time++;
			ArrayList<Integer> toadd=new ArrayList<Integer>();
			ArrayList<Integer> toremove=new ArrayList<Integer>();

			for (int ni:fre) {
			
				if (tot>k-1-st) {
					int i=-ni;
					ans.add(i);
					a[i-1]=1;
					a[i]=0;
					toremove.add(i);
					tot--;
					if (i-1>0 && a[i-2]==0) {
						toadd.add(i-1);
					}
					if (i+1<n && a[i+1]==1) {
						toadd.add(i+1);
					}
				} else
					break;

			}
			for (int i:toremove) {
				fre.remove(-i);
			}
			for (int i:toadd) {
				fre.add(-i);
			}

		
				
			
			outputWln(ans.size()+" ");
			for (int x:ans)
				outputWln(x+" ");
			output("");
			//logWln("finish iteration with a:");
			//log(a);

		}


	}

	static void process() throws Exception {


		out = new BufferedWriter(new OutputStreamWriter(System.out));
		reader = new InputReader(System.in);

		//test();

		int n=reader.readInt();
		int k=reader.readInt();
		int[] a=new int[n];
		String s=reader.readString();
		for (int i=0;i<n;i++) {
			if (s.charAt(i)=='L')
				a[i]=1;
		}
		solve(a,k);


		try {
			out.close();
		} catch (Exception Ex) {
		}

	}





	public static void main(String[] args) throws Exception {
		process();

	}

	static final class InputReader {
		private final InputStream stream;
		private final byte[] buf = new byte[1024];
		private int curChar;
		private int numChars;

		public InputReader(InputStream stream) {
			this.stream = stream;
		}

		private int read() throws IOException {
			if (curChar >= numChars) {
				curChar = 0;
				numChars = stream.read(buf);
				if (numChars <= 0) {
					return -1;
				}
			}
			return buf[curChar++];
		}

		public final String readString() throws IOException {
			int c = read();
			while (isSpaceChar(c)) {
				c = read();
			}
			StringBuilder res = new StringBuilder();
			do {
				res.append((char) c);
				c = read();
			} while (!isSpaceChar(c));
			return res.toString();
		}

		public final String readString(int L) throws IOException {
			int c = read();
			while (isSpaceChar(c)) {
				c = read();
			}
			StringBuilder res = new StringBuilder(L);
			do {
				res.append((char) c);
				c = read();
			} while (!isSpaceChar(c));
			return res.toString();
		}

		public final int readInt() throws IOException {
			int c = read();
			boolean neg = false;
			while (isSpaceChar(c)) {
				c = read();
			}
			char d = (char) c;
			// log("d:"+d);
			if (d == '-') {
				neg = true;
				c = read();
			}
			int res = 0;
			do {
				res *= 10;
				res += c - '0';
				c = read();
			} while (!isSpaceChar(c));
			// log("res:"+res);
			if (neg)
				return -res;
			return res;

		}

		public final long readLong() throws IOException {
			int c = read();
			boolean neg = false;
			while (isSpaceChar(c)) {
				c = read();
			}
			char d = (char) c;
			// log("d:"+d);
			if (d == '-') {
				neg = true;
				c = read();
			}
			long res = 0;
			do {
				res *= 10;
				res += c - '0';
				c = read();
			} while (!isSpaceChar(c));
			// log("res:"+res);
			if (neg)
				return -res;
			return res;

		}

		private boolean isSpaceChar(int c) {
			return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
		}
	}

}
/*

5
1 4 5 2 3

 */