Problem: Following FIFA World Cup, a larger competition called ``GIGA Universe Cup'' is taking place somewhere in our universe. Both FIFA World Cup and GIGA Universe Cup are two rounds competitions that consist of the first round, also known as ``group league,'' and the second called ``final tournament.'' In the first round, participating teams are divided into groups of four teams each. Each team in a group plays a match against each of the other teams in the same group. For example, let's say we have a group of the following four teams, ``Engband, Swedon, Argontina, and Nigerua.'' They play the following six matches: Engband - Swedon, Engband - Argontina, Engband - Nigerua, Swedon - Argontina, Swedon - Nigerua, and Argontina - Nigerua.

The result of a single match is shown by the number of goals scored by each team, like ``Engband 1 - 0 Argontina,'' which says Engband scored one goal whereas Argontina zero. Based on the result of a match, points are given to the two teams as follows and used to rank teams. If a team wins a match (i.e., scores more goals than the other), three points are given to it and zero to the other. If a match draws (i.e., the two teams score the same number of goals), one point is given to each.

The goal difference of a team in given matches is the total number of goals it scored minus the total number of goals its opponents scored in these matches. For example, if we have three matches ``Swedon 1 - 2 Engband,'' ``Swedon 3 - 4 Nigerua,'' and ``Swedon 5 - 6 Argontina,'' then the goal difference of Swedon in these three matches is (1 + 3 + 5) - (2 + 4+ 6) = -3.

Given the results of all the six matches in a group, teams are ranked by the following criteria, listed in the order of priority (that is, we first apply (a) to determine the ranking, with ties broken by (b), with ties broken by (c), and so on).

(a) greater number of points in all the group matches;

(b) greater goal difference in all the group matches;

(c) greater number of goals scored in all the group matches.

If two or more teams are equal on the basis of the above three criteria, their place shall be determined by the following criteria, applied in this order:

(d) greater number of points obtained in the group matches between the teams concerned;

(e) greater goal difference resulting from the group matches between the teams concerned;

(f) greater number of goals scored in the group matches between the teams concerned;

If two or more teams are stiIl equal, apply (d), (e), and (f) as necessary to each such group. Repeat this until those three rules to equal teams do not make any further resolution. Finally, teams that still remain equal are ordered by:

(g) drawing lots by the Organizing Committee for the GIGA Universe Cup.

The two teams coming first and second in each group qualify for the second round.

Your job is to write a program which, given the results of matches played so far in a group and one team specified in the group, calculates the probability that the specified team will qualify for the second round. You may assume each team has played exactly two matches and has one match to play. In total, four matches have been played and two matches are to be played.

Assume the probability that any team scores (exactly) p goals in any match is:

<image>

for p ≤ 8, and zero for p > 8 . Assume the lot in the step (g) is fair.



Input

The first line of the input is an integer, less than 1000, that indicates the number of subsequent records.

The rest of the input is the indicated number of records. A single record has the following format:

<image>

In the above, <_> is a single underscore (_) and <empty> a sequence of exactly four underscores (____). Each of <team>1, ... , <team>4 is either an asterisk character (*) followed by exactly three uppercase letters (e.g., *ENG), or an underscore followed by exactly three uppercase letters (e.g., _SWE). The former indicates that it is the team you are asked to calculate the probability of the second round qualification for. You may assume exactly one of <team>1, ... , <team>4 is marked with an asterisk. Each <m>ij(1 ≤ i < j ≤ 4) is a match result between the <team>i and <team>j. Each match result is either __-_ (i.e., two underscores, hyphen, and another underscore) or of the form _x-y where each of x and y is a single digit (≤ 8) . The former indicates that the corresponding match has not been played, whereas the latter that the result of the match was x goals by <team>i and y goals by <team>j. Since each team has played exactly two matches, exactly two match results are in the former format.

Output

The output should consist of n lines where n is the number of records in the input. The ith line should show the probability that the designated team (marked with an asterisk) will qualify for the second round in the ith record.

Numbers should be printed with exactly seven digits after the decimal point. Each number should not contain an error greater than 10-7.

Example

Input

5
_____*AAA__BBB__CCC__DDD
*AAA_______0-0__0-0___-_
_BBB_____________-___0-0
_CCC_________________0-0
_DDD____________________
______CHN__CRC__TUR_*BRA
_CHN_______0-2___-___0-4
_CRC____________1-1___-_
_TUR_________________1-2
*BRA____________________
______CMR_*KSA__GER__IRL
_CMR_______1-0___-___1-1
*KSA____________0-8___-_
_GER_________________1-1
_IRL____________________
______TUN__JPN_*BEL__RUS
_TUN________-___1-1__0-2
_JPN____________2-2__1-0
*BEL__________________-_
_RUS____________________
______MEX__CRO_*ECU__ITA
_MEX_______1-0__2-1___-_
_CRO_____________-___2-1
*ECU_________________0-2
_ITA____________________


Output

0.5000000
1.0000000
0.0000000
0.3852746
0.0353304

Solution (in CPP):

Solution:
#include <bits/stdc++.h>

using namespace std;

struct Data {
    int p, gd, gs, id;
    
    Data() { p = gd = gs = id = -1; }
    
    Data(int p, int gd, int gs, int id) :
        p{p}, gd{gd}, gs{gs}, id{id} {}

    bool operator == (const Data& d) const {
        return (p == d.p && gd == d.gd && gs == d.gs);
    }
    
    bool operator != (const Data& d) const {
        return !(*this == d);
    }
        
    bool operator < (const Data& d) const {
        if (p != d.p) {
            return p < d.p;            
        } else if (gd != d.gd) {
            return gd < d.gd;
        } 
        return gs < d.gs;
    }
};

auto f(int x) -> double
{
    return (x <= 1 ? 1 : f(x - 1) * x);
}

auto get_result(int S, const vector<vector<int>>& results) -> vector<Data>
{
    vector<int> point(4), goal_diff(4), goal(4);
    for (int i = 0; i < 4; i++) {
        for (int j = 0; j < 4; j++) {
            if ((S >> i & 1) || (S >> j & 1) || i == j) continue;
            
            int p1 = results[i][j], p2 = results[j][i];
            point[i] += (p1 > p2 ? 3 : p1 < p2 ? 0 : 1);
            goal[i] += p1;
            goal_diff[i] += p1 - p2;
        }
    }
    
    vector<Data> d(4);
    for (int i = 0; i < 4; i++) {
        if (S >> i & 1) continue;
        d[i] = {point[i], goal_diff[i], goal[i], i};
    }
    sort(d.rbegin(), d.rend());
    return d;
}

auto win_p(int mt, const vector<vector<int>>& results) -> double
{        
    auto r = get_result(0, results);
    if ((r[0].id == mt && r[0] != r[2]) ||
        (r[1].id == mt && r[1] != r[2])) {
        return 1;
    }

    if ((r[2].id == mt && r[2] != r[1]) ||
        (r[3].id == mt && r[3] != r[1])) {
        return 0;                
    }
    
    if (r[0] == r[3]) return 2.0 / 4;

    int S = (1 << 4) - 1, size = -1;
    if (r[0] != r[1]) {
        for (int i = 3; i >= 1; i--) {
            if (r[i] == r[1]) {
                for (int j = 1; j <= i; j++) {
                    S &= ~(1 << r[j].id);
                }
                size = i;
                break;
            }
        }

        r = get_result(S, results);
        if (r[0] == r[size - 1]) return 1.0 / size;
        
        if (r[0].id == mt && r[0] != r[1]) return 1;
        if (r[0] != r[1]) return 0;

        S = (1 << 4) - 1;
        S &= ~(1 << r[0].id);
        S &= ~(1 << r[1].id);
        r = get_result(S, results);        
        
        if (r[0].id == mt && r[0] != r[1]) {
            return 1;
        }

        return (r[0] == r[1] ? 1.0 / 2 : 0);
    } else {
        for (int i = 0; i <= 2; i++) {
            S &= ~(1 << r[i].id);
        }       
        
        r = get_result(S, results);
        if ((r[0].id == mt && r[0] != r[2]) ||
            (r[1].id == mt && r[1] != r[2])) {
            return 1;
        }
        
        if (r[0] == r[2]) return 2.0 / 3;
        if (r[2].id == mt) return 0;

        S = (1 << 4) - 1;
        S &= ~(1 << r[0].id);
        S &= ~(1 << r[1].id);
        r = get_result(S, results);
                
        return (r[0] == r[1] ? 1.0 / 2 : 1);        
    }
}

int main()
{
    int Tc;
    cin >> Tc;
    while (Tc--) {
        int mt = -1;
        vector<string> v(5);
        
        for (int i = 0; i < 5; i++) {
            cin >> v[i];            
        }
        for (int i = 0, j = 6; i < 4; i++, j += 5) {
            if (v[0][j - 1] == '*') mt = i;
        }

        vector<vector<int>> results(4, vector<int>(4));
        vector<pair<int, int>> np;
        int s[] = {11, 16, 21};
        for (int i = 0; i < 3; i++) {
            for (int j = i + 1, k = s[i]; j < 4; j++, k += 5) {
                if (isdigit(v[i + 1][k])) {
                    results[i][j] = v[i + 1][k] - '0';
                    results[j][i] = v[i + 1][k + 2] - '0';
                } else {
                    np.emplace_back(i, j);
                }
            }
        }
        
        auto poss = [](int p) -> double {        
            return f(8) / f(p) / f(8 - p) * pow(0.25, p) * pow(0.75, 8 - p);
        };
        
        vector<double> p(9);
        for (int i = 0; i <= 8; i++) {
            p[i] = poss(i);
        }

        double res = 0;
        for (int i = 0; i <= 8; i++) {
            for (int j = 0; j <= 8; j++) {
                for (int k = 0; k <= 8; k++) {
                    for (int l = 0; l <= 8; l++) {
                        int tp[] = {i, j, k, l};
                        for (int m = 0; m < 2; m++) {
                            int a, b;
                            tie(a, b) = np[m];
                            results[a][b] = tp[a];
                            results[b][a] = tp[b];
                        }
                        
                        double mp = p[i] * p[j] * p[k] * p[l];
                        res += mp * win_p(mt, results);
                    }
                }
            }
        }
        printf("%.10f\n", res);
    }        
    return 0;
}