#include <bits/stdc++.h>

using i64 = long long;
using u64 = unsigned long long;
using u32 = unsigned;

using i128 = __int128;

i128 gcd(i128 a, i128 b) {
    while (b) {
        a %= b;
        std::swap(a, b);
    }
    return a;
}

std::ostream &operator<<(std::ostream &os, i128 n) {
    constexpr i64 M = 1E18;
    if (n >= M) {
        return os << i64(n / M) << std::setw(18) << std::setfill('0') << i64(n % M);
    } else {
        return os << i64(n);
    }
}

constexpr i128 M = i128(47) * 43 * 41 * 37 * 32 * 31 * 29 * 27 * 25 * 23 * 19 * 17 * 13 * 11 * 7;

void solve() {
    int n, m;
    std::cin >> n >> m;
    
    std::vector<int> mc(1 + m);
    for (int i = 1; i <= m; i++) {
        std::cin >> mc[i];
    }
    
    std::vector<int> mp(n), gp(n), gc(n);
    std::vector<std::vector<int>> op(n);
    for (int r = 1; r <= m; r++) {
        std::vector<bool> vis(n);
        for (int i = 0; i < mc[r]; i++) {
            int a, b, w, l, d;
            std::cin >> a >> b >> w >> l >> d;
            a--;
            b--;
            vis[a] = true;
            vis[b] = true;
            op[a].push_back(b);
            op[b].push_back(a);
            gc[a] += w + l + d;
            gc[b] += w + l + d;
            gp[a] += w * 3 + d;
            gp[b] += l * 3 + d;
            if (w > l) {
                mp[a] += 3;
            } else if (w < l) {
                mp[b] += 3;
            } else {
                mp[a] += 1;
                mp[b] += 1;
            }
        }
        for (int x = 0; x < n; x++) {
            if (!vis[x]) {
                mp[x] += 3;
                gp[x] += 6;
                gc[x] += 2;
            }
        }
        std::cout << "Round " << r << "\n";
        for (int i = 0; i < n; i++) {
            std::cout << mp[i] << " ";
            
            int p, q;
            if (op[i].empty()) {
                p = 1;
                q = 3;
            } else {
                p = 0;
                q = 3 * r * op[i].size();
                for (auto x : op[i]) {
                    p += std::max(r, mp[x]);
                }
            }
            int g = std::gcd(p, q);
            p /= g;
            q /= g;
            std::cout << p << "/" << q << " ";
            
            p = std::max(gc[i], gp[i]);
            q = 3 * gc[i];
            g = std::gcd(p, q);
            p /= g;
            q /= g;
            std::cout << p << "/" << q << " ";
            
            {
                i128 p, q;
                if (op[i].empty()) {
                    p = 1;
                    q = 3;
                } else {
                    p = 0;
                    q = 3 * M * op[i].size();
                    for (auto x : op[i]) {
                        assert(M % gc[x] == 0);
                        p += std::max(gc[x], gp[x]) * (M / gc[x]);
                    }
                }
                i128 g = gcd(p, q);
                p /= g;
                q /= g;
                std::cout << p << "/" << q << "\n";
            }
        }
    }
}

int main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);
    
    int T;
    std::cin >> T;
    
    while (T--) {
        solve();
    }
    
    return 0;
}