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.
import java.io.*;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.util.*;

public class D {
	static String[] dictionary;
	static char[] encryptToClear;
	static String[] sentence;

	static ArrayList<String> allPossible(String s) {
		ArrayList<String> res = new ArrayList<>();
		for (int i = 0; i < dictionary.length; i++) {
			if (dictionary[i].length() != s.length())
				continue;
			String s2 = dictionary[i];
			boolean correct = true;
			for (int j = 0; j < s2.length(); j++) {
				if (s.charAt(j) == '?')
					continue;
				if (s.charAt(j) != s2.charAt(j)) {
					correct = false;
					break;
				}

			}
			if (correct)
				res.add(s2);
		}
		return res;
	}

	static boolean Decrypted(int i) {
		if (i >= sentence.length)
			return true;
		String s = "";
		String s2 = sentence[i];
		for (int j = 0; j < s2.length(); j++) {
			if (encryptToClear[s2.charAt(j) - 'a'] == '0')
				s += "?";
			else
				s += encryptToClear[s2.charAt(j) - 'a'];
		}
		ArrayList<String> res = allPossible(s);
		for (int j = 0; j < res.size(); j++) {
			for (int k = 0; k < s2.length(); k++) {
				if (s.charAt(k) == '?')
					encryptToClear[s2.charAt(k) - 'a'] = res.get(j).charAt(k);
			}
			if (Decrypted(i + 1))
				return true;
			for (int k = 0; k < s.length(); k++) {
				if (s.charAt(k) == '?')
					encryptToClear[s2.charAt(k) - 'a'] = '0';
			}

		}
		return false;
	}

	static class pair implements Comparable<pair> {
		int u;
		int cost;

		public pair(int uu, int c) {
			u = uu;
			cost = c;
		}

		@Override
		public int compareTo(pair o) {
			// TODO Auto-generated method stub
			return cost - o.cost;
		}
	}

	static ArrayList<Integer>[] tree;
	static int n;

	static int[] mark;

	static double dist(Point a, Point b) {
		return Math.sqrt((a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y));
	}

	static int m, p, q;
	static int sa, sb, sc;

	static int asd() {
		sa ^= sa << 16;
		sa ^= sa >> 5;
		sa ^= sa << 1;
		int t = sa;
		sa = sb;
		sb = sc;
		sc ^= t ^ sa;
		return sc;
	}

	public static void main(String[] args) throws IOException {
		// BufferedReader br = new BufferedReader(new FileReader("name.in"));
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		StringTokenizer st;
		PrintWriter out = new PrintWriter(System.out);

		st = new StringTokenizer(br.readLine());

		int n = Integer.parseInt(st.nextToken());
		int k = Integer.parseInt(st.nextToken());

		char[] a = br.readLine().toCharArray();
		boolean f = true;
		ArrayList<ArrayList<Integer>> arr = new ArrayList<>();
		int sum = 0;
		while (f) {
			f = false;
			ArrayList<Integer> temp = new ArrayList<>();
			for (int i = 0; i < a.length - 1; i++) {
				if (a[i] == 'R' && a[i + 1] == 'L') {
					temp.add(i + 1);
					sum++;
					a[i] = 'L';
					a[i + 1] = 'R';
					i++;
					f = true;
				}
			}
			if (!temp.isEmpty())
				arr.add(temp);
		}
//		System.out.println(arr.size());
		if (k < arr.size() || k > sum)
			out.println(-1);
		else {

			for (int i = 0; i < arr.size(); i++) {
				int t = k - (arr.size() - i - 1);
				int id = 0;
				int x=0;
				ArrayList<Integer> dd = arr.get(i);
				while (t-- != 1 && id < dd.size()) {
					out.println(1 + " " + dd.get(id));
					id++;
					x++;
				}
				if (id != dd.size()) {
					x++;
					out.print(dd.size() - id + " ");
					while (id != dd.size()) {
						out.print(dd.get(id++) + " ");
					}
					out.println();
					t--;
				}
//				System.out.println(x+" "+(k - (arr.size() - i ) - t));
				k -= k - (arr.size() - i ) - t;
			}
		}

		out.flush();
		out.close();

	}

	static class Point implements Comparable<Point> {

		static final double EPS = 1e-9;

		double x, y;

		Point(double a, double b) {
			x = a;
			y = b;
		}

		public int compareTo(Point p) {
			if (Math.abs(x - p.x) > EPS)
				return x > p.x ? 1 : -1;
			if (Math.abs(y - p.y) > EPS)
				return y > p.y ? 1 : -1;
			return 0;
		}

		public double dist(Point p) {
			return Math.sqrt(sq(x - p.x) + sq(y - p.y));
		}

		static double sq(double x) {
			return x * x;
		}

		Point rotate(double angle) {
			double c = Math.cos(angle), s = Math.sin(angle);
			return new Point(x * c - y * s, x * s + y * c);
		}
		// for integer points and rotation by 90 (counterclockwise) : swap x and y,
		// negate x

		Point rotate(double theta, Point p) // rotate around p
		{
			Vector v = new Vector(p, new Point(0, 0));
			return translate(v).rotate(theta).translate(v.reverse());
		}

		Point translate(Vector v) {
			return new Point(x + v.x, y + v.y);
		}

		Point reflectionPoint(Line l) // reflection point of p on line l
		{
			Point p = l.closestPoint(this);
			Vector v = new Vector(this, p);
			return this.translate(v).translate(v);
		}

		boolean between(Point p, Point q) {
			return x < Math.max(p.x, q.x) + EPS && x + EPS > Math.min(p.x, q.x) && y < Math.max(p.y, q.y) + EPS
					&& y + EPS > Math.min(p.y, q.y);
		}

		// returns true if it is on the line defined by a and b
		boolean onLine(Point a, Point b) {
			if (a.compareTo(b) == 0)
				return compareTo(a) == 0;
			return Math.abs(new Vector(a, b).cross(new Vector(a, this))) < EPS;
		}

		boolean onSegment(Point a, Point b) {
			if (a.compareTo(b) == 0)
				return compareTo(a) == 0;
			return onRay(a, b) && onRay(b, a);
		}

		// returns true if it is on the ray whose start point is a and passes through b
		boolean onRay(Point a, Point b) {
			if (a.compareTo(b) == 0)
				return compareTo(a) == 0;
			return new Vector(a, b).normalize().equals(new Vector(a, this).normalize()); // implement equals()
		}

		// returns true if it is on the left side of Line pq
		// add EPS to LHS if on-line points are accepted
		static boolean ccw(Point p, Point q, Point r) {
			return new Vector(p, q).cross(new Vector(p, r)) > 0;
		}

		static boolean collinear(Point p, Point q, Point r) {
			return Math.abs(new Vector(p, q).cross(new Vector(p, r))) < EPS;
		}

		static double angle(Point a, Point o, Point b) // angle AOB
		{
			Vector oa = new Vector(o, a), ob = new Vector(o, b);
			return Math.acos(oa.dot(ob) / Math.sqrt(oa.norm2() * ob.norm2()));
		}

		static double distToLine(Point p, Point a, Point b) // distance between point p and a line defined by points a,
															// b (a != b)
		{
			if (a.compareTo(b) == 0)
				return p.dist(a);
			// formula: c = a + u * ab
			Vector ap = new Vector(a, p), ab = new Vector(a, b);
			double u = ap.dot(ab) / ab.norm2();
			Point c = a.translate(ab.scale(u));
			return p.dist(c);
		}
		// Another way: find closest point and calculate the distance between it and p

		static double distToLineSegment(Point p, Point a, Point b) {
			Vector ap = new Vector(a, p), ab = new Vector(a, b);
			double u = ap.dot(ab) / ab.norm2();
			if (u < 0.0)
				return p.dist(a);
			if (u > 1.0)
				return p.dist(b);
			return distToLine(p, a, b);
		}
		// Another way: find closest point and calculate the distance between it and p
	}

	static class Line {

		static final double INF = 1e9, EPS = 1e-9;

		double a, b, c;

		Line(Point p, Point q) {
			if (Math.abs(p.x - q.x) < EPS) {
				a = 1;
				b = 0;
				c = -p.x;
			} else {
				a = (p.y - q.y) / (q.x - p.x);
				b = 1.0;
				c = -(a * p.x + p.y);
			}

		}

		Line(Point p, double m) {
			a = -m;
			b = 1;
			c = -(a * p.x + p.y);
		}

		boolean parallel(Line l) {
			return Math.abs(a - l.a) < EPS && Math.abs(b - l.b) < EPS;
		}

		boolean same(Line l) {
			return parallel(l) && Math.abs(c - l.c) < EPS;
		}

		Point intersect(Line l) {
			if (parallel(l))
				return null;
			double x = (b * l.c - c * l.b) / (a * l.b - b * l.a);
			double y;
			if (Math.abs(b) < EPS)
				y = -l.a * x - l.c;
			else
				y = -a * x - c;

			return new Point(x, y);
		}

		Point closestPoint(Point p) {
			if (Math.abs(b) < EPS)
				return new Point(-c, p.y);
			if (Math.abs(a) < EPS)
				return new Point(p.x, -c);
			return intersect(new Line(p, 1 / a));
		}

	}

	static class Vector {

		double x, y;

		Vector(double a, double b) {
			x = a;
			y = b;
		}

		Vector(Point a, Point b) {
			this(b.x - a.x, b.y - a.y);
		}

		Vector scale(double s) {
			return new Vector(x * s, y * s);
		} // s is a non-negative value

		double dot(Vector v) {
			return (x * v.x + y * v.y);
		}

		double cross(Vector v) {
			return x * v.y - y * v.x;
		}

		double norm2() {
			return x * x + y * y;
		}

		Vector reverse() {
			return new Vector(-x, -y);
		}

		Vector normalize() {
			double d = Math.sqrt(norm2());
			return scale(1 / d);
		}
	}

	static boolean vis[];

	static void dfs(int u) {
		vis[u] = true;
		for (int v : tree[u]) {
			if (!vis[v]) {
				dfs(v);
			}
		}
	}

	static int diamiter(int u) {
		int f = far(u);
		int f2 = far(f);
		return dist(f, -1, f2);
	}

	static int far(int u) {
		vis = new boolean[n];
		Queue<Integer> q = new LinkedList<Integer>();
		q.add(u);
		vis[u] = true;
		int ans = -1;
		while (!q.isEmpty()) {
			int cur = q.poll();
			ans = cur;
			for (int v : tree[cur]) {
				if (!vis[v]) {
					vis[v] = true;
					q.add(v);
				}
			}
		}
		return ans;
	}

	static int dist(int u, int pa, int e) {
		if (u == e)
			return 0;
		int min = 1000000000;
		for (int v : tree[u]) {
			if (v != pa) {
				min = Math.min(min, 1 + dist(v, u, e));
			}
		}
		return min;
	}

}