Consider a table of size n × m, initially fully white. Rows are numbered 1 through n from top to bottom, columns 1 through m from left to right. Some square inside the table with odd side length was painted black. Find the center of this square.

Input

The first line contains two integers n and m (1 ≤ n, m ≤ 115) — the number of rows and the number of columns in the table.

The i-th of the next n lines contains a string of m characters s_{i1} s_{i2} … s_{im} (s_{ij} is 'W' for white cells and 'B' for black cells), describing the i-th row of the table.

Output

Output two integers r and c (1 ≤ r ≤ n, 1 ≤ c ≤ m) separated by a space — the row and column numbers of the center of the black square.

Examples

Input

5 6
WWBBBW
WWBBBW
WWBBBW
WWWWWW
WWWWWW


Output

2 4


Input

3 3
WWW
BWW
WWW


Output

2 1
import java.io.*;
import java.util.*;




public class Main {
    private final static long mod = 1000000007;

    private static void printArr(char arr[][]) {
        int i, j, n = arr.length, m = arr[0].length;
        for (i = 0; i < n; i++) {
            for (j = 0; j < m; j++) {
                System.out.print(arr[i][j]);
            }
            System.out.println();
        }
    }


    private static long power(long x, long y, long m) {
        long temp;
        if (y == 0)
            return 1;
        temp = power(x, y / 2,m);
        temp = (temp * temp) % m;
        if (y % 2 == 0)
            return temp;
        else
            return ((x % m) * temp) % m;
    }

    private static  long power(long x, long y){
        return power(x,y,mod);
    }

    private static int gcd(int a, int b) {
        if (b == 0) return a;
        return gcd(b, a % b);
    }

    private static int cmp(Pair p, Pair q) {
        return (int)(p.a == q.a ? p.b - q.b : q.a - p.a);
    }

    static int nextPowerOf2(int n) {
        int count = 0;
        if (n > 0 && (n & (n - 1)) == 0)
            return n * 2;

        while (n != 0) {
            n >>= 1;
            count += 1;
        }

        return 1 << count;
    }
    static String isPrime(int n){
        int i;
        for(i=2;i*i<n;i++){
            if(n%i==0)return "Not prime";
        }
        return "Prime";
    }

    private static long[] computeTotient(int n) {
        long phi[] = new long[n + 1];
        for (int i = 1; i <= n; i++)
            phi[i] = i;
        for (int p = 2; p <= n; p++) {
            if (phi[p] == p) {
                phi[p] = p - 1;
                for (int i = 2 * p; i <= n; i += p) {
                    phi[i] = (phi[i] / p) * (p - 1);
                }
            }
        }
        return phi;
    }

    private static long modInverse(long a, long m) {
        long m0 = m;
        long y = 0, x = 1;
        if (m == 1)
            return 0;
        while (a > 1) {
            long q = a / m;
            long t = m;
            m = a % m;
            a = t;
            t = y;
            y = x - q * y;
            x = t;
        }
        if (x < 0)
            x += m0;
        return x;
    }

    private static boolean nextPermutation(int[] a) {
        int i = a.length - 1;
        while (i > 0 && a[i - 1] >= a[i])
            i--;
        if (i <= 0)
            return false;
        int j = a.length - 1;
        while (a[j] <= a[i - 1])
            j--;
        int temp = a[i - 1];
        a[i - 1] = a[j];
        a[j] = temp;
        j = a.length - 1;
        while (i < j) {
            temp = a[i];
            a[i] = a[j];
            a[j] = temp;
            i++;
            j--;
        }
        return true;
    }

    private static int isWon(int a[],int b[]){
        int n=a.length;
        int sa,sb,w=0,i;
        sa=0;
        sb=0;
        for(i=0;i<n/3;i++){
            sa+=a[i];
            sb+=b[i];
        }
        if(sa>sb)w++;

        sa=0;
        sb=0;
        for(;i<2*n/3;i++){
            sa+=a[i];
            sb+=b[i];
        }
        if(sa>sb)w++;

        sa=0;
        sb=0;
        for(;i<n;i++){
            sa+=a[i];
            sb+=b[i];
        }
        if(sa>sb)w++;
        return (w>1)?1:0;
    }

    public static void main(String[] args) throws IOException {
        FastReader in = new FastReader();
        FastWriter out = new FastWriter();
        int t, i, j, k, r=1, l = 0,g, n,ti,m,x,y,p,c=1;
        long ans = 0, cur=0, w, mx = -mod, mn = mod,md;
        //tc:for (t = in.nextInt(),ti=1; ti <= t; ti++)
        {
            ans=0;
            //out.print(String.format("Case #%d: ",ti));
            n=in.nextInt();
            m=in.nextInt();
            for(i=0;i<n;i++){
                String s=in.next();
                for(j=0;j<m;j++){
                    if(s.charAt(j)=='B')
                    {
                        r=i+1;
                        c=j+1;
                        l++;
                    }
                }
            }
            j=(int)(Math.sqrt(l)+0.5);
            j=(j-1)/2;
            r-=j;
            c-=j;
            out.println(r+" "+c);
        }

        in.close();
        out.close();
    }

    private static class Pair {
        long a;
        long b;

        public Pair(long a, long b) {
            this.a = a;
            this.b = b;
        }

        @Override
        public boolean equals(Object o) {
            if (this == o) return true;
            if (o == null || getClass() != o.getClass()) return false;
            Pair pair = (Pair) o;
            return a == pair.a &&
                    b == pair.b;
        }

        @Override
        public int hashCode() {

            return Objects.hash(a, b);
        }

        @Override
        public String toString() {
            return "Pair{" +
                    "a=" + a +
                    ", b=" + b +
                    '}';
        }
    }

    static class FastReader implements Closeable{
        private BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        private StringTokenizer st;

        String next() {
            while (st == null || !st.hasMoreElements()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (Exception 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;
        }

        int[] nextIntArr(int n) {
            int[] arr = new int[n];
            for (int i = 0; i < n; i++) {
                arr[i] = nextInt();
            }
            return arr;
        }

        long[] nextLongArr(int n) {
            long[] arr = new long[n];
            for (int i = 0; i < n; i++) {
                arr[i] = nextLong();
            }
            return arr;
        }
        int[][] nextIntArr2(int n, int m) {
            int[][] arr = new int[n][m];
            for (int i = 0; i < n; i++) {
                arr[i] = nextIntArr(m);
            }
            return arr;
        }

        long[][] nextLongArr2(int n, int m) {
            long[][] arr = new long[n][m];
            for (int i = 0; i < n; i++) {
                arr[i] = nextLongArr(m);
            }
            return arr;
        }

        @Override
        public void close() throws IOException {
            br.close();
        }
    }

    static class FastWriter implements Closeable{
        BufferedWriter bw;
        List<String> list = new ArrayList<>();
        Set<String> set = new HashSet<>();

        FastWriter() {
            bw = new BufferedWriter(new OutputStreamWriter(System.out));
        }

        <T> void print(T obj) throws IOException {
            bw.write(obj.toString());
            bw.flush();
        }

        void println() throws IOException {
            print("\n");
        }

        <T> void println(T obj) throws IOException {
            print(obj.toString() + "\n");
        }

        <T> void printArrLn(T[] arr) throws IOException {
            for (int i = 0; i < arr.length-1; i++) {
                print(arr[i] + " ");
            }
            println(arr[arr.length-1]);
        }

        <T> void printArr2(T[][] arr) throws IOException {
            for(int j=0;j<arr.length;j++) {
                for (int i = 0; i < arr[j].length - 1; i++) {
                    print(arr[j][i] + " ");
                }
                println(arr[j][arr.length - 1]);
            }
        }

        <T> void printColl(Collection<T> coll) throws IOException {
            for (T e:coll) {
                print(e + " ");
            }
            println();
        }

        void printCharN(char c, int n) throws IOException {
            for (int i = 0; i < n; i++) {
                print(c);
            }
        }

        @Override
        public void close() throws IOException {
            bw.close();
        }
    }


}

