There are n blocks arranged in a row and numbered from left to right, starting from one. Each block is either black or white. 

You may perform the following operation zero or more times: choose two adjacent blocks and invert their colors (white block becomes black, and vice versa). 

You want to find a sequence of operations, such that they make all the blocks having the same color. You don't have to minimize the number of operations, but it should not exceed 3 ⋅ n. If it is impossible to find such a sequence of operations, you need to report it.

Input

The first line contains one integer n (2 ≤ n ≤ 200) — the number of blocks.

The second line contains one string s consisting of n characters, each character is either "W" or "B". If the i-th character is "W", then the i-th block is white. If the i-th character is "B", then the i-th block is black. 

Output

If it is impossible to make all the blocks having the same color, print -1.

Otherwise, print an integer k (0 ≤ k ≤ 3 ⋅ n) — the number of operations. Then print k integers p_1, p_2, ..., p_k (1 ≤ p_j ≤ n - 1), where p_j is the position of the left block in the pair of blocks that should be affected by the j-th operation.

If there are multiple answers, print any of them.

Examples

Input


8
BWWWWWWB


Output


3
6 2 4


Input


4
BWBB


Output


-1


Input


5
WWWWW


Output


0


Input


3
BWB


Output


2
2 1 

Note

In the first example, it is possible to make all blocks black in 3 operations. Start with changing blocks 6 and 7, so the sequence is "BWWWWBBB". Then change blocks 2 and 3, so the sequence is "BBBWWBB". And finally, change blocks 4 and 5, so all blocks are black.

It is impossible to make all colors equal in the second example.

All blocks are already white in the third example.

In the fourth example it is possible to make all blocks white in two operations: first operation is to change blocks 2 and 3 (so the sequence is "BBW"), and then change blocks 1 and 2 (so all blocks are white).
import javafx.beans.NamedArg;
import java.io.*;
import java.util.Comparator;
import java.util.*;
/**
 * @author Yuxuan Wu
 */
public class Main {
    public static final int RANGE = 1000000;
    static int MAX = Integer.MAX_VALUE;
    static int MIN = Integer.MIN_VALUE;
    static int MODULO = 1000000007;
    static Scanner sc = new Scanner(System.in);

    public static void main(String[] args) {

        B1217();
/*
        int T = sc.nextInt();
        for(int t = 1; t <= T; ++t){
            solve();
        }
*/
    }

    private static void solve() {
        int n = sc.nextInt();
        String s = sc.next();
        int[] str = new int[n];
        int black = 0;
        int white = 0;
        for (int i = 0; i < n; i++) {
            if(s.charAt(i) == 'B'){
                str[i] = 1;
                black++;
            }
            else{
                str[i] = 0;
                white++;
            }
        }
        if(black % 2 == 1 && white % 2 == 1){
            System.out.println(-1);
            return;
        }
        else{
            Queue<Integer> ans = new LinkedList<>();
            int cnt = 0;
            int toClear = 0;
            if(white % 2 == 1){
                toClear = 1;
            }
            if(n == 1){
                System.out.println(-1);
                return;
            }
            for (int i = 1; i < n; ) {
                if(str[i] == str[i-1] && str[i] == toClear){
                    str[i] = 1;
                    str[i-1] = 1;
                    ans.add(i);
                    cnt++;
                    i += 2;
                }else {
                    ++i;
                }
            }

            int p = 0;
            while(p <= n-1){
                while (p <= n-1 && str[p] != toClear){
                    ++p;
                }
                if(p >= n-1){
                    break;
                }
                while(p <= n-1 && str[p+1] != toClear){
                    ans.add(p+1);
                    cnt++;
                    ++p;
                }
                ans.add(p+1);
                cnt++;
                if(p + 1 >= n-1){
                    break;
                }
                else {
                    p += 2;
                }
            }
            System.out.println(cnt);
            for (int i = 0; i < cnt; i++) {
                System.out.print(ans.poll() + " ");
            }
        }
    }

    private static void B1217() {
        int n = sc.nextInt();
        String s = sc.next();
        int[] str = new int[n];
        int black = 0;
        int white = 0;
        for (int i = 0; i < n; i++) {
            if(s.charAt(i) == 'B'){
                str[i] = 1;
                black++;
            }
            else{
                str[i] = 0;
                white++;
            }
        }
        if(black % 2 == 1 && white % 2 == 1){
            System.out.println(-1);
            return;
        }
        else{
            Queue<Integer> ans = new LinkedList<>();
            int cnt = 0;
            int toClear = 0;
            if(white % 2 == 1){
                toClear = 1;
            }
            if(n == 1){
                System.out.println(-1);
                return;
            }

            for (int i = 0; i < n-1; i++) {
                if(str[i] == toClear){
                    ans.add(i+1);
                    cnt++;
                    str[i+1] = 1 - str[i+1];
                }
            }
            if(str[n-1] == toClear){
                System.out.println(-1);
                return;
            }
            System.out.println(cnt);
            for (int i = 0; i < cnt; i++) {
                System.out.print(ans.poll() + " ");
            }
        }
    }

    /**
     * 返回最大公约数
     * 时间复杂度 O(Log min(n1, n2))
     */
    public static long gcd(long n1, long n2) {
        if (n2 == 0) {
            return n1;
        }
        return gcd(n2, n1 % n2);
    }

    /**
     * 返回该数的位数
     */
    public static int getDigit(long num){
        int ans = 0;
        while(num > 0){
            num /= 10;
            ans++;
        }
        return ans;
    }

    /**
     * 判断是否为回文串
     */
    public static boolean palindrome(String s) {
        int n = s.length();
        for(int i = 0; i < n; i++) {
            if(s.charAt(i) != s.charAt(n - i - 1)) {
                return false;
            }
        }
        return true;
    }

    /**
     * 判断是否为完全平方数
     */
    public static boolean isSquare(int num) {
        double a = 0;
        try {
            a = Math.sqrt(num);
        } catch (Exception e) {
            return false;
        }
        int b = (int) a;
        return a - b == 0;
    }

    public static class Pairs<K, V> implements Comparable<Pairs> {
        private K key;
        private V value;

        public K getKey() { return key; }
        public V getValue() { return value; }
        public void setKey(K key) {
            this.key = key;
        }
        public void setValue(V value) {
            this.value = value;
        }
        public Pairs(@NamedArg("key") K key, @NamedArg("value") V value) {
            this.key = key;
            this.value = value;
        }

        @Override
        public String toString() {
            return key + " = " + value;
        }

        @Override
        public boolean equals(Object o) {
            if (this == o) {
                return true;
            }
            if (o == null || getClass() != o.getClass()) {
                return false;
            }
            Pairs<?, ?> pairs = (Pairs<?, ?>) o;
            return Objects.equals(key, pairs.key) &&
                    Objects.equals(value, pairs.value);
        }

        @Override
        public int hashCode() {
            return Objects.hash(key, value);
        }

        @Override
        public int compareTo(Pairs o) {
            return 0;
        }
    }

    static class CompInt implements Comparator<Pairs>{
        @Override
        public int compare(Pairs o1, Pairs o2) {
            if(o1.key instanceof  Integer&&o2.key instanceof  Integer){
                if((int)o1.key>(int)o2.key){
                    return 1;
                }else{
                    return -1;
                }
            }
            return 0;
        }
    }

    static class CompLong implements Comparator<Pairs>{
        @Override
        public int compare(Pairs o1, Pairs o2) {
            return Long.compare((long)o1.key, (long)o2.key);
        }
    }

    static class CompDouble implements Comparator<Pairs>{
        @Override
        public int compare(Pairs o1, Pairs o2) {
            if(o1.key instanceof  Double && o2.key instanceof Double){
                return Double.compare((double) o1.key, (double) o2.key);
            }
            return 0;
        }
    }

    static class Reader {
        final private int BUFFER_SIZE = 1 << 16;
        private DataInputStream din;
        private byte[] buffer;
        private int bufferPointer, bytesRead;

        public Reader()
        {
            din = new DataInputStream(System.in);
            buffer = new byte[BUFFER_SIZE];
            bufferPointer = bytesRead = 0;
        }

        public Reader(String file_name) throws IOException
        {
            din = new DataInputStream(
                    new FileInputStream(file_name));
            buffer = new byte[BUFFER_SIZE];
            bufferPointer = bytesRead = 0;
        }

        public String readLine() throws IOException
        {
            byte[] buf = new byte[64]; // line length
            int cnt = 0, c;
            while ((c = read()) != -1) {
                if (c == '\n') {
                    if (cnt != 0) {
                        break;
                    }
                    else {
                        continue;
                    }
                }
                buf[cnt++] = (byte)c;
            }
            return new String(buf, 0, cnt);
        }

        public int nextInt() throws IOException
        {
            int ret = 0;
            byte c = read();
            while (c <= ' ') {
                c = read();
            }
            boolean neg = (c == '-');
            if (neg) {
                c = read();
            }
            do {
                ret = ret * 10 + c - '0';
            } while ((c = read()) >= '0' && c <= '9');

            if (neg) {
                return -ret;
            }
            return ret;
        }

        public long nextLong() throws IOException
        {
            long ret = 0;
            byte c = read();
            while (c <= ' ') {
                c = read();
            }
            boolean neg = (c == '-');
            if (neg) {
                c = read();
            }
            do {
                ret = ret * 10 + c - '0';
            } while ((c = read()) >= '0' && c <= '9');
            if (neg) {
                return -ret;
            }
            return ret;
        }

        public double nextDouble() throws IOException
        {
            double ret = 0, div = 1;
            byte c = read();
            while (c <= ' ') {
                c = read();
            }
            boolean neg = (c == '-');
            if (neg) {
                c = read();
            }

            do {
                ret = ret * 10 + c - '0';
            } while ((c = read()) >= '0' && c <= '9');

            if (c == '.') {
                while ((c = read()) >= '0' && c <= '9') {
                    ret += (c - '0') / (div *= 10);
                }
            }

            if (neg) {
                return -ret;
            }
            return ret;
        }

        private void fillBuffer() throws IOException
        {
            bytesRead = din.read(buffer, bufferPointer = 0,
                    BUFFER_SIZE);
            if (bytesRead == -1) {
                buffer[0] = -1;
            }
        }

        private byte read() throws IOException
        {
            if (bufferPointer == bytesRead) {
                fillBuffer();
            }
            return buffer[bufferPointer++];
        }

        public void close() throws IOException
        {
            if (din == null) {
                return;
            }
            din.close();
        }
    }
}
