#include <bits/stdc++.h>

using namespace std;

#define REP(i, n) for (int i=0; i<(n); ++i)
#define RREP(i, n) for (int i=(int)(n)-1; i>=0; --i)
#define FOR(i, a, n) for (int i=(a); i<(n); ++i)
#define RFOR(i, a, n) for (int i=(int)(n)-1; i>=(a); --i)

#define SZ(x) ((int)(x).size())
#define all(x) begin(x),end(x)

#define dump(x) cerr<<#x<<" = "<<(x)<<endl
#define debug(x) cerr<<#x<<" = "<<(x)<<" (L"<<__LINE__<<")"<<endl;

template<class T>
ostream &operator<<(ostream &os, const vector <T> &v) {
    os << "[";
    REP(i, SZ(v)) {
        if (i) os << ", ";
        os << v[i];
    }
    return os << "]";
}

template<class T, class U>
ostream &operator<<(ostream &os, const pair <T, U> &p) {
    return os << "(" << p.first << " " << p.second << ")";
}

template<class T>
bool chmax(T &a, const T &b) {
    if (a < b) {
        a = b;
        return true;
    }
    return false;
}

template<class T>
bool chmin(T &a, const T &b) {
    if (b < a) {
        a = b;
        return true;
    }
    return false;
}

using ll = long long;
using ull = unsigned long long;
using ld = long double;
using P = pair<int, int>;
using vi = vector<int>;
using vll = vector<ll>;
using vvi = vector<vi>;
using vvll = vector<vll>;

const ll MOD = 1e9 + 7;
const int INF = INT_MAX / 2;
const ll LINF = LLONG_MAX / 2;
const ld eps = 1e-9;


int main() {
    cin.tie(0);
    ios::sync_with_stdio(false);
    cout << fixed << setprecision(10);

    using vd = vector<double>;

    int D; cin >> D;
    while (D--) {
        int N; cin >> N;
        vd B(N+2), H(N+2);
        B[0] = 0, B[N+1] = 100;
        H[0] = H[N+1] = 50;
        REP(i, N) cin >> B[i+1] >> H[i+1];

        vd F(N+1);
        int M; cin >> M;
        REP(i, M) {
            double f, a; cin >> f >> a;
            int u = upper_bound(all(B), f) - begin(B);
            F[u-1] += a;
        }


        function<double(int,int,vd&,vd&)> dfs = [&](int l, int r, vd& flow, vd& height) {
            // [l, r) にflow を流す
            if (l+1 == r) {
                double h = min(H[l], H[r]);
                double cap = (B[r] - B[l]) * h;
                height[l] = min(h, flow[l] / (B[r] - B[l]));
                return max(flow[l] - cap, 0.0);
            }

            int m = max_element(begin(H)+l+1, begin(H)+r) - begin(H);
            double h = min(H[l], H[r]);

            double cap = (B[r] - B[l]) * (h - H[m]);

            double leftover = dfs(l, m, flow, height),
                   rightover = dfs(m, r, flow, height);

            if (leftover > 0) {
                FOR(i, l, m) height[i] = H[m];
                flow[m] += leftover;
                rightover = dfs(m, r, flow, height);
                flow[m] -= leftover;
                if (rightover > cap) {
                    FOR(i, l, r) height[i] = h;
                    return rightover - cap;
                } else if (rightover > 0) {
                    FOR(i, l, r) height[i] = H[m] + rightover / (B[r] - B[l]);
                    return 0.0;
                } else {
                    return 0.0;
                }
            }
            else if (rightover > 0) {
                FOR(i, m, r) height[i] = H[m];
                flow[m-1] += rightover;
                leftover = dfs(l, m, flow, height);
                flow[m-1] -= rightover;
                if (leftover > cap) {
                    FOR(i, l, r) height[i] = h;
                    return leftover - cap;
                } else if (leftover > 0) {
                    FOR(i, l, r) height[i] = H[m] + leftover / (B[r] - B[l]);
                    return 0.0;
                } else {
                    return 0.0;
                }
            }
            else {
                return 0.0;
            }
        };

        int L; cin >> L;
        while (L--) {
            int p, t; cin >> p >> t;
            vd flow(N+1);
            REP(i, N+1) flow[i] = F[i] * t / 30.0;
            vd height(N+1);

            double over = dfs(0, N+1, flow, height);
            if (over) {
                cout << 50.0 << endl;
                continue;
            }

            int i = upper_bound(all(B), p) - begin(B);
            cout << height[i-1] << endl;
        }
    }

    return 0;
}

