#include <iostream>
#include <algorithm>
#include <numeric>
#include <vector>
#include <string>
#include <memory.h>
#include <queue>
#include <cstdio>
#include <cstdlib>
#include <set>
#include <map>
#include <cctype>
#include <iomanip>
#include <sstream>
#include <cctype>
#include <fstream>
#include <cmath>
using namespace std;

#define REP2(i, m, n) for(int i = (int)(m); i < (int)(n); i++)
#define REP(i, n) REP2(i, 0, n)
#define ALL(c) (c).begin(), (c).end()
#define ITER(c) __typeof((c).begin())
#define PB(e) push_back(e)
#define FOREACH(i, c) for(ITER(c) i = (c).begin(); i != (c).end(); ++i)
#define MP(a, b) make_pair(a, b)
#define PARITY(n) ((n) & 1)

struct query{ int id, time, pos; };
bool operator<(const query &q1, const query &q2) { return q1.time < q2.time; }

struct rect{
  int L, R;
  int bottomH, topH;
  int water, supply;
  int chl, chr;
  rect() {
    bottomH = water = supply = 0;
    chl = chr = -1;
  }
};

const int MAXN = 10;
const int MAXM = 10;
const int MAXL = 10;
const int MAXVALUE = 30 * 50 * 100;

rect R[MAXN * MAXN * 2];
int B[MAXN+2];
int H[MAXN+2];
query Q[MAXL];
int _N;

int push(int v, int over, bool fromleft){
  if(v == -1) return over;
  
  if(fromleft){
    over = push(R[v].chl, over, true);
    over = push(R[v].chr ,over, true);
  }else{
    over = push(R[v].chr, over, false);
    over = push(R[v].chl, over, false);
  }

  int p = min(over, (R[v].R-R[v].L) * 30 * (R[v].topH-R[v].bottomH) - R[v].water);
  R[v].water += p;
  return over - p;
}

int step(int v, int t){
  if(v == -1) return 0;
  if(R[v].supply > 0){
    return push(v, R[v].supply * t, true);
  }
  
  int water = step(R[v].chl, t);
  if(water > 0) water = push(R[v].chr, water, true);
  water += step(R[v].chr, t);
  if(water > 0) water = push(R[v].chl, water, false);
  return push(v, water, true);
}

int makeID(int l, int r, int N) { return l + r * N;}

double calc_height(int v, int pos){
  double res = 0;
  int l = R[v].chl, r = R[v].chr;
  if(l != -1 && R[l].L < pos && pos < R[l].R) res += calc_height(l, pos);
  if(r != -1 && R[r].L < pos && pos < R[r].R) res += calc_height(r, pos);
  if(R[v].L < pos && pos < R[v].R)  res += R[v].water/30.0/(R[v].R-R[v].L);
  return res;
}

void ans_query(int N){
  int L;
  int root = makeID(0, N - 1, N);
  cin >> L;
  REP(i, L) Q[i].id = i, cin >> Q[i].pos >> Q[i].time;
  sort(Q, Q + L);
  vector<double> res(L);
  REP(i, L){
    step(root, i == 0 ? Q[0].time : Q[i].time - Q[i-1].time);
    res[Q[i].id] = calc_height(root, Q[i].pos);
  }
  REP(i, L) cout << fixed << setprecision(20) << res[i] << endl;
}

int main(){
  int D, N, M, F, A;
  cin >> D;
  while(D--){
    cin >> N;
    fill(R, R + MAXN * MAXN * 2, rect());
    B[0] = 0, B[N+1] = 100;
    H[0] = H[N+1] = 50;
    REP(i, N) cin >> B[i+1] >> H[i+1];
    N+=2;
    _N = N;
    
    REP(r, N)REP(l, r){
      int id = makeID(l, r, N);
      int m = 0;
      R[id].L = B[l];
      R[id].R = B[r];
      R[id].topH = min(H[l], H[r]);
      REP2(i, l + 1, r)if(R[id].bottomH < H[i]){
        R[id].bottomH = H[i];
        m = i;
      }
      if(R[id].bottomH < R[id].topH && l < m && m < r){ // valid area
        R[id].chl = makeID(l, m, N);
        R[id].chr = makeID(m, r, N);
      }
    }
    cin >> M;
    REP(i, M){
      cin >> F >> A;
      REP(j, N) if(B[j] < F && F < B[j+1]) R[makeID(j, j + 1, N)].supply += A;
    }
    ans_query(N);
  }
  return 0;
}

Measured memory_bytes: 1280