// Polyomino Packing (Reflections Allowed) — Checker (updated to new statement)
// Uses testlib: https://codeforces.com/blog/entry/18431
//
// Validates a participant's output for a single test case.
//
// Problem statement deltas reflected here:
//   - n ∈ [100, 10000]
//   - k_i ∈ [1, 10]
//   - Σk_i ≤ 2000  (enforced)
//   - Scoring per test: score = 1e5 * (Σk_i) / (W*H)   (higher is better)
//
// Input (from problem):
//   Line 1: n
//   For each i=1..n:
//     Line: k_i
//     Next k_i lines: x y   (integers; define a polyomino in local coords)
//
// Output (participant):
//   Line 1: W H
//   Then n lines (one per polyomino i):
//     X_i Y_i R_i F_i
//       R_i ∈ {0,1,2,3} = # of 90° clockwise rotations
//       F_i ∈ {0,1}     = reflection flag (1 = reflect across y-axis)
// Transform order (must): reflect → rotate → translate.
//
// Checks performed:
//   - Token counts and ranges (R_i, F_i in valid sets)
//   - After transform, every cell in [0, W) × [0, H)
//   - No overlapping occupied grid cells between pieces
// Scoring message: Score = Σk_i / (W*H)

#include "testlib.h"
#include <bits/stdc++.h>
using namespace std;

struct CellHash {
    size_t operator()(const pair<long long,long long>& p) const noexcept {
        uint64_t x = static_cast<uint64_t>(p.first);
        uint64_t y = static_cast<uint64_t>(p.second);
        // splitmix-style mixing
        x ^= y + 0x9e3779b97f4a7c15ULL + (x<<6) + (x>>2);
        x ^= x >> 30; x *= 0xbf58476d1ce4e5b9ULL;
        x ^= x >> 27; x *= 0x94d049bb133111ebULL;
        x ^= x >> 31;
        return static_cast<size_t>(x);
    }
};

static inline pair<long long,long long> rot90cw(long long x, long long y, int r) {
    switch (r & 3) {
        case 0:  return { x,  y};
        case 1:  return { y, -x};
        case 2:  return {-x, -y};
        default: return {-y,  x};
    }
}

int main(int argc, char* argv[]) {
    registerTestlibCmd(argc, argv);

    // ===== Read input =====
    const int n = inf.readInt(100, 10000, "n");

    vector<vector<pair<long long,long long>>> shapes(n);
    long long totalCells = 0;

    for (int i = 0; i < n; ++i) {
        int k = inf.readInt(1, 10, "k_i");
        shapes[i].reserve(k);
        for (int j = 0; j < k; ++j) {
            long long x = inf.readLong(numeric_limits<long long>::min()/4,
                                       numeric_limits<long long>::max()/4, "x_ij");
            long long y = inf.readLong(numeric_limits<long long>::min()/4,
                                       numeric_limits<long long>::max()/4, "y_ij");
            shapes[i].push_back({x, y});
        }
        totalCells += k;
    }

    // ===== Read participant output =====
    // Allow large W/H to avoid artificial limits; still within signed 64-bit
    long long W = ouf.readLong(1, (long long)4e12, "W");
    long long H = ouf.readLong(1, (long long)4e12, "H");

    struct Place { long long X, Y; int R; int F; };
    vector<Place> place(n);
    for (int i = 0; i < n; ++i) {
        long long X = ouf.readLong(-(long long)4e12, (long long)4e12, "X_i");
        long long Y = ouf.readLong(-(long long)4e12, (long long)4e12, "Y_i");
        int R = ouf.readInt(0, 3, "R_i");
        int F = ouf.readInt(0, 1, "F_i");
        place[i] = {X, Y, R, F};
    }

    if (!ouf.seekEof()) {
        quitf(_pe, "Extra data after expected %d placement lines", n);
    }

    // ===== Validate placement =====
    unordered_set<pair<long long,long long>, CellHash> occ;
    occ.reserve(static_cast<size_t>(max<long long>(16, totalCells * 2)));

    auto inBounds = [&](long long x, long long y) -> bool {
        return x >= 0 && y >= 0 && x < W && y < H;
    };

    for (int i = 0; i < n; ++i) {
        const auto [X, Y, R, F] = place[i];
        for (const auto& c : shapes[i]) {
            long long sx = c.first, sy = c.second;

            // reflect across y-axis if F=1: (x, y) -> (-x, y)
            long long rx = (F == 1 ? -sx : sx);
            long long ry = sy;

            // rotate r times 90° CW about origin
            auto [qx, qy] = rot90cw(rx, ry, R);

            // translate by (X, Y) with overflow checks
            long long gx, gy;
            if (__builtin_add_overflow(qx, X, &gx) ||
                __builtin_add_overflow(qy, Y, &gy)) {
                quitf(_wa, "Overflow after transforming piece %d", i+1);
            }

            if (!inBounds(gx, gy)) {
                quitf(_wa,
                      "Out of bounds: piece %d cell -> (%lld,%lld) not in [0,%lld)×[0,%lld)",
                      i+1, gx, gy, W, H);
            }

            auto ins = occ.insert({gx, gy});
            if (!ins.second) {
                quitf(_wa, "Overlap at cell (%lld,%lld)", gx, gy);
            }
        }
    }

    // ===== Scoring message =====
    // Use 128-bit to avoid overflow in W*H
    __int128 area128 = (__int128)W * (__int128)H;
    if (area128 <= 0) quitf(_wa, "Non-positive area (W*H)");
    long long area;
    if (area128 > numeric_limits<long long>::max())
        quitf(_wa, "Area overflow: W*H exceeds 64-bit");
    area = (long long)area128;

    double score = (double) totalCells / (double) area;
    // Include "Ratio:" in message so judge system can parse the partial score
    quitp(score, "Ratio: %.9f (cells=%lld, W=%lld, H=%lld, area=%lld)",
          score, totalCells, W, H, area);
}