Galois is one of the strongest chess players of Byteforces. He has even invented a new variant of chess, which he named «PawnChess».

This new game is played on a board consisting of 8 rows and 8 columns. At the beginning of every game some black and white pawns are placed on the board. The number of black pawns placed is not necessarily equal to the number of white pawns placed. 

<image>

Lets enumerate rows and columns with integers from 1 to 8. Rows are numbered from top to bottom, while columns are numbered from left to right. Now we denote as (r, c) the cell located at the row r and at the column c.

There are always two players A and B playing the game. Player A plays with white pawns, while player B plays with black ones. The goal of player A is to put any of his pawns to the row 1, while player B tries to put any of his pawns to the row 8. As soon as any of the players completes his goal the game finishes immediately and the succeeded player is declared a winner.

Player A moves first and then they alternate turns. On his move player A must choose exactly one white pawn and move it one step upward and player B (at his turn) must choose exactly one black pawn and move it one step down. Any move is possible only if the targeted cell is empty. It's guaranteed that for any scenario of the game there will always be at least one move available for any of the players.

Moving upward means that the pawn located in (r, c) will go to the cell (r - 1, c), while moving down means the pawn located in (r, c) will go to the cell (r + 1, c). Again, the corresponding cell must be empty, i.e. not occupied by any other pawn of any color.

Given the initial disposition of the board, determine who wins the game if both players play optimally. Note that there will always be a winner due to the restriction that for any game scenario both players will have some moves available.

Input

The input consists of the board description given in eight lines, each line contains eight characters. Character 'B' is used to denote a black pawn, and character 'W' represents a white pawn. Empty cell is marked with '.'. 

It's guaranteed that there will not be white pawns on the first row neither black pawns on the last row.

Output

Print 'A' if player A wins the game on the given board, and 'B' if player B will claim the victory. Again, it's guaranteed that there will always be a winner on the given board.

Examples

Input

........
........
.B....B.
....W...
........
..W.....
........
........


Output

A


Input

..B.....
..W.....
......B.
........
.....W..
......B.
........
........


Output

B

Note

In the first sample player A is able to complete his goal in 3 steps by always moving a pawn initially located at (4, 5). Player B needs at least 5 steps for any of his pawns to reach the row 8. Hence, player A will be the winner.




import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.InputMismatchException;
import java.util.Scanner;
import java.util.StringTokenizer;

public class q1 
{

    public static void main(String args[])
    {
        FasterScanner s=new FasterScanner();
        char[][] c=new char[8][8];
        for(int i=0;i<8;i++)
        {
            c[i]=s.nextLine().toCharArray();
        }
        int a=8;
        int b=8;
        for(int i=0;i<8;i++)
        {
            for(int j=0;j<8;j++)
            {
                if(c[i][j]=='.')
                    continue;
                else
                {
                    if(c[i][j]=='W')
                    {
                        int k=i;
                        for(k=i-1;k>=0;k--)
                            if(c[k][j]!='.')
                                break;
                        //System.out.println(k);
                        if(k==-1)
                            a=Math.min(a, i);
                    }
                    
                    if(c[i][j]=='B')
                    {
                        int k=i;
                        for(k=i+1;k<8;k++)
                            if(c[k][j]!='.')
                                break;
                        
                        if(k==8)
                            b=Math.min(b, 8-i-1);
                    }
                }
            }
        }
        
        //System.out.println(a+" "+b);
        if(a<b)
            System.out.println("A");
        else
            if(a>b)
                System.out.println("B");
            else
                System.out.println("A");
            
        
        
    }


    public static long gcd(long a, long b) 
    {

        if(a==b)
            return a;
        if(a==0)
            return b;
        if(b==0)
            return a;

        if(a>b)
            return gcd(b,a%b);
        else
            return gcd(a,b%a);
    }

    public static long modPow( long a, long b, long mod )
    {
        long res=1,pow=a;
        while( b>0 )
        {
            if( (b&1)==1 )
            {
                res = (pow*res)%mod;
            }
            pow = (pow*pow)%mod;
            b=b/2;
        }
        return res;
    }
    
    static class nck
    {
        public static long ncr[][];
        
        public nck(long z,long p)//z==maxvalue  p==mod
        {
            generateNCR(z, p);
        }
        
        private static void generateNCR( long z, long p )
        {
            ncr = new long[(int)z+1][(int)z+1];
            ncr[0][0] = 1;
            for(int i=1; i<=z; i++)
            {
                ncr[i][0] = 1;
                ncr[0][i] = 0;
            }
            for(int i=1; i<=z; i++)
            {
                for(int j=1; j<=z; j++)
                {
                    ncr[i][j] = (ncr[i-1][j] + ncr[i-1][j-1]) % p;
                }
            }
        }

        private static long lucas(long n, long k, long p) 
        {
        
            long ans = 1;
            
            while(n>0)
            {
                int N = (int)(n%p);
                int K = (int)(k%p);
                if(K>N)
                    return 0;
                ans *= (ncr[N][K] );
                n /= p;
                k /= p;
            }
            return ans % p;
        }
    }
    
    static class SegTree
    {
        static int seg[];
        static int dp[];
        int n;
        int d;
        public SegTree(int[] arr,int defaul)
        {
            this.dp=arr;
            n=dp.length;
            seg=new int[4*arr.length];
            build(1,0,n);
            this.d=defaul;
        }

        public void build(int id,int l,int r){
            if(r-l<2){
                seg[id]=dp[l];
                return;
            }
            int mid=(l+r)/2;
            build(2*id,l,mid);
            build(2*id+1,mid,r);
            seg[id]=merge(seg[2*id],seg[2*id+1]);
        }

        public int query(int l,int r)
        {
            return givemin(1,l,r,0,n);
        }

        public  int givemin(int id,int x,int y,int l,int r){
            if(x<=l && y>=r){
                return seg[id];
            }
            if(y<=l || r<=x){
                return d;
            }
            int mid=(l+r)/2;
            return merge(givemin(2*id, x, y, l, mid),givemin(2*id+1, x, y, mid, r));
        }

        public int upd(int id,int value)
        {
            return update(1,id,value,0,n);
        }
        public  int update(int id,int p,int value,int l,int r){
            if(r-l<2){
                dp[p]=value;
                seg[id]=value;
                return value;
            }
            int mid=(l+r)/2;
            if(p<mid){
                update(2*id, p, value, l, mid);
                seg[id]=merge(seg[2*id], seg[2*id+1]);
                return seg[id];
            }
            else{
                update(2*id+1, p, value, mid,r);
                seg[id]=merge(seg[2*id+1], seg[2*id]);
                return seg[id];

            }
        }

        public int merge(int l,int r)
        {

            //set initial value
            return l+r;
        }
    }


    static class UF {

        private int[] parent;  // parent[i] = parent of i
        private byte[] rank;   // rank[i] = rank of subtree rooted at i (never more than 31)
        private int count;   
        int[] seg;
        int max;
        // number of components
        public UF(int N) {
            if (N < 0) throw new IllegalArgumentException();
            count = N;
            parent = new int[N];
            rank = new byte[N];
            seg=new int[N];
            for (int i = 0; i < N; i++) {
                parent[i] = i;
                rank[i] = 0;
                seg[i]=1;
            }
            max=1;
        }

        public int find(int p) {
            if (p < 0 || p >= parent.length) throw new IndexOutOfBoundsException();
            while (p != parent[p]) {
                parent[p] = parent[parent[p]];    // path compression by halving
                p = parent[p];
            }
            return p;
        }
        public int count() {
            return count;
        }

        public boolean connected(int p, int q) {
            return find(p) == find(q);
        }

        public boolean union(int p, int q) {
            //    System.out.println("uf "+p+" "+q);
            int rootP = find(p);
            int rootQ = find(q);
            if (rootP == rootQ) return false;

            // make root of smaller rank point to root of larger rank
            if      (rank[rootP] < rank[rootQ])
            {
                parent[rootP] = rootQ;
                seg[rootQ]+=seg[rootP];
                max=Math.max(seg[rootQ],max);
            }
            else if (rank[rootP] > rank[rootQ])
            {
                parent[rootQ] = rootP;
                seg[rootP]+=seg[rootQ];
                max=Math.max(seg[rootP],max);
            }
            else {
                parent[rootQ] = rootP;
                rank[rootP]++;
                seg[rootP]+=seg[rootQ];
                max=Math.max(seg[rootP],max);
            }
            count--;
            return true;
        }

    }



    static class SparseTable
    {
        int[][] st;
        public SparseTable(int[] h){
            int n=h.length;
            int MAX_LOG=(int)Math.ceil(Math.log(n)/Math.log(2))+1;
            st=new int[n][MAX_LOG];
            for (int i = 0; i < n; i++)
                st[i][0] = h[i];
            for (int j = 1; (1 << j) <= n; j++)
            {
                for (int i = 0;( i + (1 << j) - 1 )< n; i++)
                {
                    st[i][j]=Math.max(st[i][j-1],st[i+(1<<(j-1))][j-1]);
                }
            }
        }
        public int query(int l,int r)
        {
            int x=(int )Math.floor((Math.log(r-l+1)/Math.log(2)));
            int ans=Math.max(st[l][x],st[r-(1<<x)+1][x]);
            return ans;
        }

    }

    public static class FasterScanner {
        private byte[] buf = new byte[1024];
        private int curChar;
        private int numChars;

        public int read() {
            if (numChars == -1)
                throw new InputMismatchException();
            if (curChar >= numChars) {
                curChar = 0;
                try {
                    numChars = System.in.read(buf);
                } catch (IOException e) {
                    throw new InputMismatchException();
                }
                if (numChars <= 0)
                    return -1;
            }
            return buf[curChar++];
        }

        public String nextLine() {
            int c = read();
            while (isSpaceChar(c))
                c = read();
            StringBuilder res = new StringBuilder();
            do {
                res.appendCodePoint(c);
                c = read();
            } while (!isEndOfLine(c));
            return res.toString();
        }

        public String nextString() {
            int c = read();
            while (isSpaceChar(c))
                c = read();
            StringBuilder res = new StringBuilder();
            do {
                res.appendCodePoint(c);
                c = read();
            } while (!isSpaceChar(c));
            return res.toString();
        }

        public long nextLong() {
            int c = read();
            while (isSpaceChar(c))
                c = read();
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = read();
            }
            long res = 0;
            do {
                if (c < '0' || c > '9')
                    throw new InputMismatchException();
                res *= 10;
                res += c - '0';
                c = read();
            } while (!isSpaceChar(c));
            return res * sgn;
        }

        public int nextInt() {
            int c = read();
            while (isSpaceChar(c))
                c = read();
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = read();
            }
            int res = 0;
            do {
                if (c < '0' || c > '9')
                    throw new InputMismatchException();
                res *= 10;
                res += c - '0';
                c = read();
            } while (!isSpaceChar(c));
            return res * sgn;
        }

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

        public long[] nextLongArray(int n) {
            long[] arr = new long[n];
            for (int i = 0; i < n; i++) {
                arr[i] = nextLong();
            }
            return arr;
        }

        private boolean isSpaceChar(int c) {
            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
        }

        private boolean isEndOfLine(int c) {
            return c == '\n' || c == '\r' || c == -1;
        }
    }

}
