Problem: Description

KULASIS is the name of a system developed and operated by the Higher Education Research and Development Promotion Organization for the purpose of providing information on common subjects throughout the university on the Web, supporting students and faculty members, and improving services. KULASIS started with the development of the online syllabus in 2003, and has gradually expanded the system to include Web bulletin boards, course registration, grades (scoring registration, scoring confirmation from students).
Students can use functions such as confirmation of academic affairs information (class cancellations, class changes, reports), course registration, and scoring confirmation from both inside and outside the university from a personal computer or mobile phone. The number of logins exceeds 10,000 on many days, and it has become widespread as an academic affairs information system at Kyoto University, and is indispensable for taking common courses throughout the university. We are developing this KULASIS so that it can be applied not only to common subjects throughout the university, but also to undergraduate specialized courses and graduate schools.
http://www.z.k.kyoto-u.ac.jp/introduction_kulasis.html

Q, a student at Kyoto University, was logged in to KULASIS to form a late syllabus. When I was wondering which subject I was going to enter, KULASIS suddenly gave off a dazzling light and moved to another page.
The page to which the transition was made was as shown in the figure below. The subject name and evaluation (impossible, acceptable, good, excellent) are written in the 5x5 square, and 16 ● buttons are arranged on the grid.
It was Q that I did not know what happened, but apparently when I press the ● button on the grid, the evaluation of the subjects in the upper right, lower right, upper left, and lower left is not possible → Yes, Yes → Good, Good → Excellent, Excellent → Impossible.


<image>


You can press the ● button as many times as you like.
I'm not sure if KULASIS has been rewritten by someone or if I'm dreaming, but if I can confirm my grades with this, Q wanted to get as good a grade as possible.
Confident that he was collecting a lot of credits, Q decided to maximize his fighting power in preparation for his assignment to the laboratory six months later than the number of credits itself.
Combat power is the total value of the evaluation of each subject converted into impossible → 0 points, acceptable → 60 points, good → 70 points, excellent → 80 points. It is thought (in the Q department) to show how superior it is.

Now that the subjects displayed on the KULASIS screen and their evaluations are given, please describe the program that outputs the maximum value of the combat power that can be obtained.



Input

The number of test cases is given on the first line of input. The number of test cases is guaranteed to be 100 or less.
From the second line onward, 5x5 numbers are lined up, and the evaluation of the subject displayed on the KULASIS screen is given, and 1,2,3,4 correspond to impossible, acceptable, good, and excellent, respectively.
If it is 0, no subject is registered in that frame.
The test cases are separated by a blank line.

Output

Output the maximum value of combat power that can be obtained for each test case.

Example

Input

5

1 1 0 3 3
1 1 0 3 3
0 0 0 0 0
2 2 0 4 4
2 2 0 4 4

1 1 1 0 0
1 1 1 1 0
1 0 1 1 0
0 0 1 1 1
1 1 1 1 1

0 0 0 0 0
0 0 0 0 0
0 0 0 0 0
0 0 0 0 0
0 0 0 0 0

4 3 4 3 4
3 4 3 4 3
4 3 4 3 4
3 4 3 4 3
4 3 4 3 4

2 2 2 2 2
0 0 0 2 0
2 2 0 2 0
2 2 0 2 0
0 0 0 2 0


Output

1280
1420
0
1920
1020

Solution (in CPP):

Solution:
#include <iostream>
#include <sstream>
#include <iomanip>
#include <algorithm>
#include <cmath>
#include <string>
#include <vector>
#include <list>
#include <queue>
#include <stack>
#include <set>
#include <map>
#include <bitset>
#include <numeric>
#include <climits>
#include <cfloat>
using namespace std;

int toInt(const vector<int>& a){
    int ret = 0;
    for(int i=0; i<6; ++i)
        ret |= max(a[i], 0) << (i*2);
    return ret;
}

vector<int> toVector(int a){
    vector<int> ret(6);
    for(int i=0; i<6; ++i){
        ret[i] = a & 3;
        a >>= 2;
    }
    return ret;
}

int getScore(vector<int>& a, int b){
    int ret = 0;
    for(int i=0; i<5; ++i){
        if(a[i] != -1 && (b & 3))
            ret += 50 + 10 * (b & 3);
        b >>= 2;
    }
    return ret;
}

int main()
{
    int n;
    cin >> n;

    while(--n >= 0){
        vector<int> grade(25);
        for(int i=0; i<25; ++i){
            cin >> grade[i];
            -- grade[i];
        }

        vector<int> dp(1<<12, -1);
        dp[toInt(grade)] = 0;
        for(int i=6; i<25; ++i){
            vector<int> nextDp(1<<12, -1);
            for(int j=0; j<(1<<12); ++j){
                if(dp[j] == -1)
                    continue;
                for(int k=0; k<4; ++k){
                    if(i % 5 == 0 && k > 0)
                        break;
                    vector<int> a = toVector(j);
                    (a[0] += k) %= 4;
                    (a[1] += k) %= 4;
                    (a[5] += k) %= 4;
                    int score = dp[j];
                    if(grade[i-6] != -1 && a[0] != 0)
                        score += 50 + 10 * a[0];
                    a[0] = 0;
                    int b = (toInt(a) >> 2) | (((max(grade[i], 0) + k) % 4) << 10);
                    nextDp[b] = max(nextDp[b], score);
                }
            }
            dp.swap(nextDp);
        }

        int ret = 0;
        for(int i=0; i<(1<<12); ++i){
            vector<int> a = toVector(i);
            int score = dp[i];
            for(int j=0; j<6; ++j){
                if(grade[19+j] != -1 && a[j] != 0){
                    score += 50 + 10 * a[j];
                }
            }
            ret = max(ret, score);
        }
        cout << ret << endl;
    }

    return 0;

    while(--n >= 0){
        vector<vector<int> > grade(5, vector<int>(5));
        for(int i=0; i<5; ++i){
            for(int j=0; j<5; ++j){
                cin >> grade[i][j];
                -- grade[i][j];
            }
        }

        vector<int> dp(1<<10, -1);
        dp[toInt(grade[0])] = 0;
        for(int i=0; i<4; ++i){
            vector<int> nextDp(1<<10, -1);
            for(int j=0; j<(1<<10); ++j){
                if(dp[j] == -1)
                    continue;
                for(int k=0; k<(1<<8); ++k){
                    vector<int> a = toVector(j);
                    vector<int> b = grade[i+1];
                    for(int l=0; l<4; ++l){
                        (a[l]   += (k>>(l*2)) & 3) %= 4;
                        (a[l+1] += (k>>(l*2)) & 3) %= 4;
                        (b[l]   += (k>>(l*2)) & 3) %= 4;
                        (b[l+1] += (k>>(l*2)) & 3) %= 4;
                    }
                    int a1 = toInt(a);
                    int b1 = toInt(b);
                    nextDp[b1] = max(nextDp[b1], dp[j] + getScore(grade[i], a1)); 
                }
            }
            dp.swap(nextDp);
        }

        int ret = 0;
        for(int i=0; i<(1<<10); ++i){
            ret = max(ret, dp[i] + getScore(grade[4], i));
        }
        cout << ret << endl;
    }

    return 0;
}