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

using VI = vector<int>;
using VVI = vector<VI>;
using PII = pair<int, int>;
using LL = long long;
using VL = vector<LL>;
using VVL = vector<VL>;
using PLL = pair<LL, LL>;
using VS = vector<string>;

#define ALL(a)  begin((a)),end((a))
#define RALL(a) (a).rbegin(), (a).rend()
#define PB push_back
#define EB emplace_back
#define MP make_pair
#define SZ(a) int((a).size())
#define SORT(c) sort(ALL((c)))
#define RSORT(c) sort(RALL((c)))
#define UNIQ(c) (c).erase(unique(ALL((c))), end((c)))

#define FOR(i,a,b) for(int i=(a);i<(b);++i)
#define REP(i,n)  FOR(i,0,n)

#define FF first
#define SS second
template<class S, class T>
istream& operator>>(istream& is, pair<S,T>& p){
  return is >> p.FF >> p.SS;
}
template<class S, class T>
ostream& operator<<(ostream& os, const pair<S,T>& p){
  return os << p.FF << " " << p.SS;
}
template<class T>
void maxi(T& x, T y){
  if(x < y) x = y;
}
template<class T>
void mini(T& x, T y){
  if(x > y) x = y;
}


const double EPS = 1e-10;
const double PI  = acos(-1.0);
const LL MOD = 1e9+7;

struct S{
  double l, r, lh, rh, in, cap;
  S(): l(0), r(0), lh(0), rh(0), in(0), cap(0)
  {
  }
};

void solve(vector<S>& xs, double T){
  int N = SZ(xs);

  double mt = T;
  int mi = -1;
  REP(i,N){
	if(xs[i].in <= EPS) continue;
	double t = xs[i].cap / xs[i].in;
	if(t < mt){
		mt = t;
		mi = i;
	}
  }
  REP(i,N){
	xs[i].cap -= mt * xs[i].in;
  }
  if(mi == -1){
	return;
  }
  /*
  cout<<mi<<endl;
  for(auto&& c: xs){
	cout<< c.lh <<" |_ " << c.l << " _ " << "/ " <<c.in<<" " << c.cap << " "<< c.r << " _| " << c.rh << endl;
  }
  */
  if(xs[mi].lh < xs[mi].rh){
	assert(mi>0);
	if(xs[mi-1].cap <= EPS && xs[mi-1].lh > xs[mi].lh){
	  xs[mi].l = xs[mi-1].l;
	  xs[mi].cap += (min(xs[mi].rh, xs[mi-1].lh) - xs[mi].lh) * 30 * (xs[mi].r - xs[mi].l);
	  xs[mi].lh = xs[mi-1].lh;
	  xs[mi].in += xs[mi-1].in;
	  xs.erase(begin(xs) + mi - 1);
	}
	else{
	  xs[mi-1].in += xs[mi].in;
	  xs[mi].in = 0;
	}
  }
  else{
	assert(mi+1<N);
	if(xs[mi+1].cap <= EPS && xs[mi+1].rh > xs[mi].rh){
	  xs[mi].r = xs[mi+1].r;
	  xs[mi].cap += (min(xs[mi].lh, xs[mi+1].rh) - xs[mi].rh) * 30 * (xs[mi].r - xs[mi].l);
	  xs[mi].rh = xs[mi+1].rh;
	  xs[mi].in += xs[mi+1].in;
	  xs.erase(begin(xs) + mi + 1);
	}
	else{
	  xs[mi+1].in += xs[mi].in;
	  xs[mi].in = 0;
	}
  }
  solve(xs, T-mt);
}


int main(){
  cin.tie(0);
  ios_base::sync_with_stdio(false);

  int D;
  cin >> D;
  while(D--){
	int N;
	cin >> N;
	vector<S> ran(N+1);
	ran[0].l = 0;
	ran[0].lh = 50;
	ran[N].r = 100;
	ran[N].rh = 50;
	REP(i,N){
	  int b, h;
	  cin >> b >> h;
	  ran[i].r = b;
	  ran[i].rh = h;
	  ran[i+1].l = b;
	  ran[i+1].lh = h;
	}
	REP(i,N+1){
	  ran[i].cap = (ran[i].r - ran[i].l) * 30. * min(ran[i].lh, ran[i].rh);
	}
	int M;
	cin >> M;
	REP(i,M){
	  int f, a;
	  cin >> f >> a;
	  REP(j,N+1)
		if(ran[j].l < f && f < ran[j].r){
		  ran[j].in += a;
		}
	}
	ran.insert(begin(ran), S());
	ran[0].l = -1e9, ran[0].r = 0, ran[0].lh = 1e9, ran[0].rh = 50, ran[0].in = 0, ran[0].cap = 1e18;
	ran.EB();
	ran.back().l = -1e9, ran.back().r = 0, ran.back().lh = 1e9, ran.back().rh = 50, ran.back().in = 0, ran.back().cap = 1e18;
	
	int L;
	cin >> L;
	while(L--){
	  LL x, t;
	  cin >> x >> t;
	  vector<S> crt = ran;
	  solve(crt, t);
	  /*
	  cout<<"==="<<endl;for(auto&& c: crt){
		cout<< c.lh <<" |_ " << c.l << " _ " << "/ " <<c.in<<" " << c.cap << " "<< c.r << " _| " << c.rh << endl;
	  }
	  */
	  for(auto&& s: crt){
		if(s.l < x && x < s.r){
		  double c = (s.r - s.l) * 30. * min(s.lh, s.rh) - s.cap;
		  double h = c / 30. / (s.r - s.l);
		  cout << fixed << setprecision(9) << min(50., h) << endl;
		  break;
		}
	  }
	}
  }

  return 0;
}

Measured memory_bytes: 3248