Problem: Everybody loves magic, especially magicians who compete for glory on the Byteland Magic Tournament. Magician Cyael is one such magician.
Cyael has been having some issues with her last performances and today she’ll have to perform for an audience of some judges, who will change her tournament ranking, possibly increasing it. As she is a great magician she managed to gather a description of the fixed judges’ disposition on the room (which is represented as an N × N square matrix), such that she knows in advance the fixed points each judge will provide. She also knows that the room is divided into several parallel corridors, such that we will denote the j-th cell on corridor i, as [i][j]. Note that some judges can award Cyael, zero points or negative points, as they are never pleased with her performance.
There is just one judge at each cell of the matrix, except the cells [1][1] and [N][N].
To complete her evaluation, she must start on the top leftmost corner of the room (cell [1][1]), and finish on the bottom right corner (cell [N][N]), moving either to the cell directly in front of her on the same corridor (that is, moving from cell [r][c] to cell [r][c+1], where c+1 ≤ N) or to the cell in the next corridor directly in front of where she is (that is, moving from cell [r][c] to cell [r+1][c], where r+1 ≤ N). She will keep doing this until she reaches the end point of the room, i.e. last cell [N][N] on the last corridor. Cyael will be judged at all visited cells with a judge.

Cyael wants to maximize her average score at end of her performance. More specifically, if she passes K judges, each being on cell [i1][j1], cell [i2][j2], ..., cell [iK][jK] respectively, then she wants to maximize (S[i1][j1] + S[i2][j2] + ... + S[iK][jK]) / K, where S[i][j] denotes the points that the judge will give her on the cell [i][j].
Help her determine the best path she has to follow in order to maximize her average points.

Input
The first line contains a single integer T denoting the number of test cases. The description for T test cases follows. For each test case, the first line contains a single integer N. Each of the next N lines contains N space-separated integers.
The j-th integer S[i][j] in i-th line denotes the points awarded by the judge at cell [i][j].
Note that the cells [1][1] and [N][N] have no judges, so S[1][1] and S[N][N] will be 0.

Output
For each test case, if the maximum possible average points Cyael can obtain is negative, output a single line containing "Bad Judges" (quotes for clarity). Otherwise, output the maximum possible average points. The answer will be considered correct if it has an absolute error no more than  10^-6.

Constraints
1 ≤ T ≤ 202 ≤ N ≤ 100-2500 ≤ S[i][j] ≤ 2500S[1][1] = S[N][N] = 0
Your code will be judged against several input files. 

Example

Input:
2
2
0 -4
8 0
2
0 -45
-3  0


Output:
8.000000
Bad Judges

Solution (in PYTHON):

Solution:
def count(i,j,c):
    global room
    global dp
    global n
    if dp[i][j] != -1 :
        return dp[i][j]
    
    if i == n-1 and j == n-1 :
        if dp[i][j] == -1 :
            dp[i][j] = c
        elif dp[i][j] > c :
            dp[i][j] = c
        return c
            

    if i == n-1 :
        dp[i][j] = room[i][j] + count(i,j+1,0)
        return dp[i][j]
    elif j == n-1 :
        dp[i][j] = room[i][j] + count(i+1,j,0)
        return dp[i][j]
    else :
        x = count(i,j+1,0)
        y = count(i+1,j,0)

        dp[i][j] = room[i][j] + max(x,y)
        return dp[i][j]


t = int(raw_input())

for ab in xrange(t):
    n = int(raw_input())
    room = []
    dp = []
    for i in xrange(n):
        a = []
        a = map(int,raw_input().split())
        b = []
        for j in xrange(n):
            b.append(-1)
        dp.append(b)
        room.append(a)

    count(0,0,0)
    c = (n-1)+(n-2)
    if dp[0][0] < 0 :
        print "Bad Judges"
    else :
        print float(dp[0][0])/c