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.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.io.Reader;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.StringTokenizer;

public class D {
    public static void main(String[] args) {
        var scanner = new BufferedScanner();
        var writer = new PrintWriter(new BufferedOutputStream(System.out, 32768));

        // 10 10 LLRRLRLRLL
        var n = scanner.nextInt();
        var k = scanner.nextInt();
        var s = scanner.next().toCharArray();
//        var n = 3000;
//        var k = 1000000;
//        var s = new char[n];
//        for (int i = 0; i < n; i++) {
//            if (Math.random() > 0.5) {
//                s[i] = 'L';
//            } else {
//                s[i] = 'R';
//            }
//        }
//        for (int i = 0; i < n / 2; i++) {
//            s[i] = 'R';
//        }
//        for (int i = n / 2; i < n; i++) {
//            s[i] = 'L';
//        }
        assert debug(new String(s));

        var t = System.nanoTime();
        var tt = System.nanoTime();
        // 最终，LL...LL,RR...RR,LL...LLRR...RR
        // 转头不改变L和R的数量，相当于L和R互换位置
        // RLRL->LRLR->LLRR
        // 左边的L往左边走了，右边的才能继续往左边走
        // 求最大步数，如果大于等于k就有戏
        var moves = new ArrayList<Integer>();
        var ls = new ArrayList<L>();
        {
            var r = 0;
            for (int i = 0; i < s.length; i++) {
                if (s[i] == 'R') {
                    r++;
                } else {
                    ls.add(new L(i, r));
                    r = 0;
                }
            }
        }
        var ls2 = ls.toArray(new L[0]);
        assert debug("ls time:%.2f", (System.nanoTime() - t) / 1e9);
        t = System.nanoTime();
        var range = new int[]{0, ls.size() - 1};
        while (true) {
            var all = allLAfterR2(ls, ls2, range);
//            var all = allLAfterR(s);
//            assert all.equals(allLAfterR(s));
//            assert debug("all size:%d", all.size());
            if (all.size() == 0) {
                break;
            }
            moves.addAll(all);
//            for (Integer i : all) {
//                moves.add((i - 1) + 1);
//                if (s[i - 1] != 'R') {
//                    throw new RuntimeException("wtf");
//                }
//                if (s[i] != 'L') {
//                    throw new RuntimeException("wtf");
//                }
//                assert s[i - 1] == 'R' && s[i] == 'L';
//                swap(s, i - 1, i);
//            }
        }
        assert debug("moves.size:%d", moves.size());
        assert debug("moves loop:%d", totalAllAfterR2);
        assert debug("moves inner loop:%d", totalAllAfterR2Loop);
        assert debug("moves time:%.2f", (System.nanoTime() - t) / 1e9);
        t = System.nanoTime();
//        assert firstLAfterR(s) < 0;
        if (moves.size() < k) {
            writer.println(-1);
        } else {
//            var groups = group(moves, k);
//            assert groups.size() == k;
            var groups2 = group2(moves, k);
            assert groups2 == null || groups2.length == k;
            assert debug("group time:%.2f", (System.nanoTime() - t) / 1e9);
            t = System.nanoTime();
//            assert false;
//            for (List<Integer> group : groups) {
//                writer.print(group.size());
//                writer.print(" ");
//                for (Integer each : group) {
//                    writer.print(each);
//                    writer.print(" ");
//                }
//                writer.println();
//            }
            if (groups2 == null) {
                writer.println(-1);
            } else {
                for (int[] group : groups2) {
                    writer.print(group.length);
                    writer.print(' ');
                    for (int x : group) {
                        writer.print(x);
                        writer.print(' ');
                    }
                    writer.println();
                }
            }
            assert debug("output time:%.2f", (System.nanoTime() - t) / 1e9);
        }
        assert debug("total time:%.2f", (System.nanoTime() - t) / 1e9);
//        assert false;

        scanner.close();
        writer.flush();
        writer.close();
    }

    static boolean debug(String fmt, Object... args) {
        System.out.println(String.format(fmt, args));
        return true;
    }

    static int totalAllAfterR2 = 0;
    static int totalAllAfterR2Loop = 0;
    static int totalTime1, totalTime2;

    private static List<Integer> allLAfterR2(List<L> ls, L[] ls2, int[] range) {
//        assert debug("range(%d,%d)", range[0], range[1]);
        totalAllAfterR2++;
        var ans = new ArrayList<Integer>();
//        while (ls.peek() != null && ls.peek().preR == 0) {
//            ls.poll();
//        }
//        var it = ls.iterator();
//        while (it.hasNext() && it.next().preR == 0) {
//            it.remove();
//        }
//        var first = IntStream.range(0, ls.size())
//                .filter(i -> ls.get(i).preR > 0)
//                .findFirst()
//                .orElse(-1);
//        if (first < 0) {
//            return List.of();
//        }
//        var newLs = new ArrayList<L>();
//        while (range[0] < ls.size() && ls.get(range[0]).preR == 0) {
        while (range[0] < ls2.length && ls2[range[0]].preR == 0) {
            range[0]++;
        }
        var prevI = -999;
//        var i = -1;
//        for (var x : ls) {
        var newEnd = range[0];
        for (var i = range[0]; i <= range[1]; i++) {
            totalAllAfterR2Loop++;
//            L x = ls.get(i);
            L x = ls2[i];
//            newLs.add(x);
//            i++;
            var plusR = prevI + 1 == i;
            if (x.preR > 0) {
                ans.add(x.pos);
                x.preR--;
                x.pos--;
                prevI = i;
            }
            if (plusR) {
                x.preR++;
            }
            if (x.preR > 0) {
                newEnd = i;
            }
        }
        range[1] = Math.min(newEnd + 1, ls2.length - 1);
//        ls.clear();
//        ls.addAll(newLs);
        return ans;
    }

    static class L {
        int pos;
        int preR;

        public L(int i, int r) {
            pos = i;
            preR = r;
        }
    }

    private static List<Integer> allLAfterR(char[] s) {
//        System.out.println("woohoo");
        var ans = new ArrayList<Integer>();
        var foundR = false;
        var prev = -1;
        for (int i = 0; i < s.length; i++) {
            if (s[i] == 'R') {
                foundR = true;
            } else {
                if (foundR) {
                    if (i > prev + 1) {
                        ans.add(i);
                        prev = i;
                    }
                    foundR = false;
                }
            }
        }
        return ans;
    }

    private static List<List<Integer>> group(List<Integer> moves, int k) {
        var work = new LinkedList<>(moves);
        var ans = new ArrayList<List<Integer>>();
        while (ans.size() < k) {
            var batch = new ArrayList<Integer>();
            ans.add(batch);
            var prev = -1;
            var it = work.iterator();
            var atMost = work.size() - (k - ans.size());
            while (it.hasNext() && batch.size() < atMost) {
                var next = it.next();
                if (next > prev + 1) {
                    batch.add(next);
                    it.remove();
                    prev = next;
                } else if (next <= prev) {
                    break;
                }
            }
        }
//        if (moves.size() > 0) {
//            throw new RuntimeException("wtf");
//        }
        assert work.size() == 0;
        return ans;
    }

    private static int[][] group2(List<Integer> moves, int k) {
        var work = new LinkedList<>(moves);
        var ans = new int[k][];
        var batch = new ArrayList<Integer>();
        for (var i = 0; i < k; i++) {
            batch.clear();
            var prev = -1;
            var it = work.iterator();
            var atMost = work.size() - (k - i - 1);
            while (it.hasNext() && batch.size() < atMost) {
                var next = it.next();
                if (next > prev + 1) {
                    batch.add(next);
                    it.remove();
                    prev = next;
                } else if (next <= prev) {
                    break;
                }
            }
            ans[i] = batch.stream().mapToInt(x -> x).toArray();
        }
//        if (moves.size() > 0) {
//            throw new RuntimeException("wtf");
//        }
//        assert work.size() == 0;
//        return ans;
        return work.size() == 0 ? ans : null;
    }

    private static int firstLAfterR(char[] s) {
        var foundR = false;
        for (int i = 0; i < s.length; i++) {
            if (s[i] == 'R') {
                foundR = true;
            } else {
                if (foundR) {
                    return i;
                }
            }
        }
        return -1;
    }

    static void swap(char[] s, int i, int j) {
        char tmp = s[i];
        s[i] = s[j];
        s[j] = tmp;
    }

    public static class BufferedScanner {
        BufferedReader br;
        StringTokenizer st;

        public BufferedScanner(Reader reader) {
            br = new BufferedReader(reader);
        }

        public BufferedScanner() {
            this(new InputStreamReader(System.in));
        }

        String next() {
            while (st == null || !st.hasMoreElements()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }

        int nextInt() {
            return Integer.parseInt(next());
        }

        long nextLong() {
            return Long.parseLong(next());
        }

        double nextDouble() {
            return Double.parseDouble(next());
        }

        String nextLine() {
            String str = "";
            try {
                str = br.readLine();
            } catch (IOException e) {
                e.printStackTrace();
            }
            return str;
        }

        void close() {
            try {
                br.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

    }

    static long gcd(long a, long b) {
        if (a < b) {
            return gcd(b, a);
        }
        while (b > 0) {
            long tmp = b;
            b = a % b;
            a = tmp;
        }
        return a;
    }

    static long inverse(long a, long m) {
        long[] ans = extgcd(a, m);
        return ans[0] == 1 ? (ans[1] + m) % m : -1;
    }

    private static long[] extgcd(long a, long m) {
        if (m == 0) {
            return new long[]{a, 1, 0};
        } else {
            long[] ans = extgcd(m, a % m);
            long tmp = ans[1];
            ans[1] = ans[2];
            ans[2] = tmp;
            ans[2] -= ans[1] * (a / m);
            return ans;
        }
    }

    private static List<Integer> primes(double upperBound) {
        var limit = (int) Math.sqrt(upperBound);
        var isComposite = new boolean[limit + 1];
        var primes = new ArrayList<Integer>();
        for (int i = 2; i <= limit; i++) {
            if (isComposite[i]) {
                continue;
            }
            primes.add(i);
            int j = i + i;
            while (j <= limit) {
                isComposite[j] = true;
                j += i;
            }
        }
        return primes;
    }


}