#include <bits/stdc++.h>

using namespace std;

#define int long long
#define all(v) (v).begin(), (v).end()
#define resz(v, ...) (v).clear(), (v).resize(__VA_ARGS__)
#define reps(i, m, n) for(int i = (int)(m); i < (int)(n); i++)
#define rep(i, n) reps(i, 0, n)

template<class T1, class T2> void chmin(T1 &a, T2 b){if(a>b)a=b;}
template<class T1, class T2> void chmax(T1 &a, T2 b){if(a<b)a=b;}

typedef pair<int, int> Pi;
typedef tuple<int, int, int> Ti;
typedef vector<int> vint;

const int inf = 1LL << 55;
const int mod = 1e9 + 7;

#define EPS (1e-10)
#define eq(a, b) (fabs((a)-(b)) < EPS)
#define lt(a, b) ((a)-(b) < -EPS)
#define le(a, b) (eq(a, b) || lt(a, b))

struct Plate {
  double x, h;
  Plate(){}
  Plate(double x, double h):x(x), h(h){}
};

struct Tank {
  Plate l, r;
  double w;
  Tank(){}
  Tank(Plate l, Plate r, double w = 0.0):l(l), r(r), w(w){}
  void pour(double water) {
    w += water;
  }
  void reset() {
    w = 0.0;
  }
  double capacity() {
    return min(l.h, r.h)*fabs(l.x-r.x)*30;
  }
  double contain() {
    return w;
  }
  double overflow(double water = 0.0) {
    return max(0.0, water+contain() - capacity());
  }
  double waterlevel() {
    return min(50.0, contain()/(fabs(l.x-r.x)*30));
  }
};

struct Tap {
  double x, w;
  Tap(){}
  Tap(double x, double w):x(x), w(w){}
};

int N, M, L;
vector<Tank> tank;
vector<Tap> tap;
vector< tuple<double, double, int> > query;
vector<double> ans;

bool in(Tank ta, double x) {
  return ta.l.x <= x && x <= ta.r.x;
}

void unite(int idx) {
  tank[idx+1].l = tank[idx].l;
  tank[idx+1].pour(tank[idx].contain());
  tank.erase(begin(tank)+idx);
}

void simulate(int idx) {
  double flow = tank[idx].overflow();
  if(flow <= 0) return;
  tank[idx].pour(-flow);
  if(tank[idx].l.h < tank[idx].r.h) {
    if(0 < idx) {
      tank[idx-1].pour(flow);
      if(tank[idx-1].overflow() > 0) {
	if(tank[idx].l.h <= tank[idx-1].l.h) {
	  unite(idx-1);
	  simulate(idx-1);
	} else simulate(idx-1);
      }
    } else assert(false);
  } else if(tank[idx].l.h > tank[idx].r.h) {
    if(idx < (int)tank.size()-1) {
      tank[idx+1].pour(flow);
      if(tank[idx+1].overflow() > 0) {
	if(tank[idx].r.h <= tank[idx+1].r.h) {
	  unite(idx);
	  simulate(idx);
	}
	else simulate(idx+1);
      }
    } else assert(false);
  }
}

double solve(double p, double t) {
  rep(i, tank.size()) tank[i].reset();

  rep(i, tap.size()) {
    rep(j, tank.size()) {
      if(in(tank[j], tap[i].x)) {
	tank[j].pour(tap[i].w*t);
	break;
      }
    }
  }
  for(int i = tank.size()-1; i >= 0; i--) {
    if(i >= (int)tank.size()) continue;
    simulate(i);
  }

  rep(i, tank.size()) {
    if(in(tank[i], p)) return tank[i].waterlevel();
  }

  assert(false);
  return -1;
}

signed main()
{
  cin.tie(0);
  ios_base::sync_with_stdio(0);
  cout << fixed << setprecision(12);

  int D;
  cin >> D;
  while(D--) {
    cin >> N;
    resz(tank, N+1);
    Plate p, q;
    p = Plate(0, 50);
    rep(i, N) {
      cin >> q.x >> q.h;
      tank[i] = Tank(p, q);
      p = q;
    }
    q = Plate(100, 50);
    tank[N] = Tank(p, q);

    cin >> M;
    resz(tap, M);
    rep(i, M) {
      cin >> tap[i].x >> tap[i].w;
    }

    cin >> L;
    resz(ans, L);
    query.clear();
    rep(i, L) {
      double p, t;
      cin >> p >> t;
      query.emplace_back(t, p, i);
    }
    sort(all(query));

    rep(i, L) {
      double p, t; int idx;
      tie(t, p, idx) = query[i];
      ans[idx] = solve(p, t);
    }

    rep(i, L) cout << ans[i] << endl;
  }

  return 0;
}

Measured memory_bytes: 3300