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.lang.reflect.Array;
import java.math.BigInteger;
import java.util.*;
import java.util.Stack;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.Map.Entry;

import static java.lang.Character.isSpaceChar;

public class GFG
{
    static int mod1 = (int) (1e9 + 7);

    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')
                    break;
                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();
        }

        public int[] nextArray(int n) throws IOException
        {
            int[] a = new int[n];
            for (int i = 0; i < n; i++)
            {
                a[i] = nextInt();
            }
            return a;
        }
    }

    static Set<Long> divisor(Set<Long> set0, long num0)
    {
        if (num0 != 1)
        {
            set0.add(num0);
        }
        for (long i = 2; i * i <= num0; i++)
        {
            while (num0 % i == 0)
            {
                set0.add(i);
                num0 /= i;
            }
        }
        return set0;
    }
    static long primeDivisor(long num0)
    {
        long maxPrime1=1;
        for (long i = 2; i * i <= num0; i++)
        {
            while (num0 % i == 0)
            {
                boolean b1=primeCheck(i);
                if(b1)
                {
                    if(maxPrime1<i)
                    {
                        maxPrime1=i;
                    }
                }
                boolean b2=primeCheck(num0/i);
                if(b2)
                {
                    if(maxPrime1<num0/i)
                    {
                        maxPrime1=num0/i;
                    }
                }
                num0/=i;
            }
        }
        if(maxPrime1==1)
        {
            maxPrime1=num0;
        }
        return maxPrime1;
    }

    static long power2(long x, long y, long p)
    {
        long res = 1;
        x = x % p;
        while (y > 0)
        {
            if ((y & 1) == 1)
            {
                BigInteger res0 = BigInteger.valueOf(res);
                res0 = res0.multiply(BigInteger.valueOf(x));
                res0 = res0.mod(BigInteger.valueOf(p));
                String str0 = res0.toString();
                res = Long.parseLong(str0);
            }
            y = y >> 1;
            BigInteger res00 = BigInteger.valueOf(x);
            res00 = res00.multiply(BigInteger.valueOf(x));
            res00 = res00.mod(BigInteger.valueOf(p));
            String ans00 = res00.toString();
            x = Long.parseLong(ans00);

        }
        return res;
    }

    static long GCD(long num0, long num00)
    {
        BigInteger big1 = BigInteger.valueOf(num0);
        BigInteger big2 = BigInteger.valueOf(num00);
        big1 = big1.gcd(big2);
        long num000 = Long.parseLong(big1.toString());
        return num000;
    }

    static boolean primeCheck(long num0)
    {
        int num01 = (int) (Math.sqrt(num0)) + 1;
        boolean b1 = true;
        me1:
        for (int i = 2; i < num01; i++)
        {
            if (num0 % i == 0)
            {
                b1 = false;
                break me1;
            }
        }
        return b1;
    }

    static double getTime()
    {
        return System.nanoTime();
    }

    static int countSum1(int len0, int[] arr0, int sum0)
    {
        HashMap<Integer, Integer> map1 = new HashMap<>();

        for (int i = 0; i < len0; i++)
        {
            if (!map1.containsKey(arr0[i]))
            {
                map1.put(arr0[i], 0);
            }
            map1.put(arr0[i], map1.get(arr0[i]) + 1);
        }
        int count0 = 0;
        for (int i = 0; i < len0; i++)
        {
            if (map1.get(sum0 - arr0[i]) != null)
                count0 += map1.get(sum0 - arr0[i]);
            if (sum0 - arr0[i] == arr0[i])
                count0--;
        }
        int num7 = count0 / 2;
        return num7;
    }

    static int lastNum1(int num0)
    {
        String str1 = String.valueOf(num0);
        int num00 = num0;
        while (str1.length() > 1)
        {
            num00 = 0;
            for (int i = 0; i < str1.length(); i++)
            {
                num00 = num00 + Character.getNumericValue(str1.charAt(i));
            }
            str1 = String.valueOf(num00);
        }
        return num00;
    }

    static String sortedString(String str01)
    {
        char[] chrArr1=str01.toCharArray();
        Arrays.sort(chrArr1);
        str01="";
        for(int i=0;i<chrArr1.length;i++)
        {
            str01=str01+chrArr1[i];
        }
        return str01;
    }

    public static void main(String[] args) throws IOException
    {
        //double tTime   = getTime()-(startTime);
        //out1.print(tTime/(1e9)+" ");
        //Reader r = new Reader();
        Scanner r = new Scanner(new BufferedReader(new InputStreamReader(System.in)));
        //Scanner r=new Scanner(System.in);
        OutputWriter3 out1 = new OutputWriter3(System.out);
        int num1=r.nextInt();
        int num2=r.nextInt();
        char[][] chrArr1=new char[num1][num2];
        for(int i=0;i<num1;i++)
        {
            chrArr1[i]=r.next().toCharArray();
        }
        me1: for(int i=0;i<num1;i++)
        {
            for(int j=0;j<num2;j++)
            {
                if(chrArr1[i][j]=='B')
                {
                    int num3=j;
                    int count1=0;
                    while(j<num2-1 && chrArr1[i][j+1]=='B')
                    {
                        count1++;
                        j++;
                    }
                    count1=count1/2;
                    int res1=i+1+count1;
                    int res2=num3+1+count1;
                    out1.print(res1+" "+res2+"\n");
                    break me1;
                }
            }
        }
        r.close();
        out1.close();
    }
}
/*class linkedList
{
    Node head;

    static class Node
    {
        int data;
        Node next;

        Node(int d)
        {
            data = d;
            next = null;
        }
    }

    public void print()
    {
        Node ptr1 = head;
        while (ptr1 != null)
        {
            System.out.print(ptr1.data + " ");
            ptr1 = ptr1.next;
        }
    }
}
*/
class OutputWriter3
{
    BufferedWriter writer;

    public OutputWriter3(OutputStream stream)
    {
        writer = new BufferedWriter(new OutputStreamWriter(stream));
    }

    public void print(int i) throws IOException
    {
        writer.write(i + "");
    }

    public void println(int i) throws IOException
    {
        writer.write(i + "\n");
    }

    public void print(String s) throws IOException
    {
        writer.write(s + "");
    }

    public void println(String s) throws IOException
    {
        writer.write(s + "\n");
    }

    public void print(char[] c) throws IOException
    {
        writer.write(c);
    }

    public void close() throws IOException
    {
        writer.close();
    }
}
