一堆tle一个WA

#include <iostream>
#include <cstdio>
#include <vector>
#include <queue>
#include <cstring>
#include <algorithm>
inline int read() {
	char c = getchar();
	int f = 1;
	int res = 0;
	while(c < '0' || c > '9') {
		if(c == '-') f = -1;
		c = getchar();
	}
	while(c >= '0' && c <= '9') {
		res = (res << 1) + (res << 3) + c - '0';
		c = getchar();
	}
	return res;
}
int write(int x) {
	if(x < 0) putchar('-'), x = -x;
	if(x > 9) write(x / 10);
	putchar(x % 10 + '0');
}
const int N = 2e5 + 7;
const int M = 4e5 + 7;
const int J = 20;
int logn[N << 1];
int T;
int n, m;
int last;
//Graph
class edge {
	public:
		int u;
		int v;
		int l;
		int a;
		friend bool operator > (edge x, edge y) {
			return x.a > y.a;
		}
};
edge e[M];
int cnt;
int head[N], nex[M], to[M], len[M], alt[M];
void add(int u, int v, int l, int a) {
	nex[++cnt] = head[u];
	to[cnt] = v;
	len[cnt] = l;
	alt[cnt] = a;
	head[u] = cnt;
}
//Shortest Path
class S {
	public:
		int d;
		int id;
		friend bool operator > (S a, S b) {
			return a.d > b.d;
		}
};
int mi[N << 1];
bool vis[N];
std::priority_queue <S, std::vector <S>, std::greater <S> > heap;
void dijkstra() {
	std::memset(mi + 1, 0x7f, n * sizeof(int));
	std::memset(vis + 1, 0, n * sizeof(bool));
	mi[1] = 0;
	heap.push((S){0, 1});
	while(!heap.empty()) {
		int u = heap.top().id;
		heap.pop();
		if(vis[u]) continue;
		vis[u] = 1;
		for(int i = head[u]; i; i = nex[i]) {
			int v = to[i];
			int w = len[i];
			if(mi[v] > mi[u] + w) {
				mi[v] = mi[u] + w;
				heap.push((S){mi[v], v});
			}
		}
	}
}
//Kruskal
int lch[N << 1], rch[N << 1], fas[N << 1], wei[N << 1];
int idx;
void init() {
	for(int i = 1; i <= n * 2 - 1; i++)
		fas[i] = i;
}
int find(int x) {
	return x == fas[x] ? x : (fas[x] = find(fas[x]));
}
void kruskal() {
	idx = n;
	std::sort(e + 1, e + 1 + m, std::greater<edge>());
	for(int i = 1; i <= m; i++) {
		int u = e[i].u;
		int v = e[i].v;
		u = find(u);
		v = find(v);
		if(u != v) {
			idx++;
			fas[u] = idx;
			fas[v] = idx;
			lch[idx] = u;
			rch[idx] = v;
			wei[idx] = e[i].a;
			mi[idx] = std::min(mi[u], mi[v]);
		}
	}
}
//Binary Lift
int fa[J][N << 1];
int dep[N << 1];
void dfs(int u, int f) {
	fa[0][u] = f;
	dep[u] = dep[f] + 1;
	for(int i = 1; i <= logn[dep[u]]; i++)
		fa[i][u] = fa[i - 1][fa[i - 1][u]];
	if(lch[u] != 0) dfs(lch[u], u);
	if(rch[u] != 0) dfs(rch[u], u);
}
int cal(int u, int w) {
	for(int i = logn[dep[u]]; i >= 0; i--)
		if(wei[fa[i][u]] > w) u = fa[i][u];
	return mi[u];
}
int main() {
	//std::freopen("test.in", "r", stdin);
	//std::freopen("test.out", "w", stdout);
	logn[1] = 0;
	for(int i = 2; i < N << 1; i++)
		logn[i] = logn[i / 2] + 1;
	T = read();
	for(int i = 0; i < T; i++) {
		last = 0;
		std::cin >> n >> m;
		if(i > 0) {
			std::memset(head + 1, 0, n * sizeof(int));
			std::memset(to + 1, 0, (m << 1) * sizeof(int));
			std::memset(nex + 1, 0, (m << 1) * sizeof(int));
		}
		cnt = 0;
		for(int j = 1; j <= m; j++) {
			int u, v, l, a;
			u = read(); v = read(); l = read(); a = read();
			add(u, v, l, a);
			add(v, u, l, a);
			e[j] = (edge){u, v, l, a};
		}
		dijkstra();
		init();
		if(i > 0) {
			std::memset(lch, 0, n * 2 * sizeof(int));
			std::memset(rch, 0, n * 2 * sizeof(int));
		}
		kruskal();
		dfs(idx, 0);
		int q, k, s;
		q = read(); k = read(); s = read();
		for(int j = 0; j < q; j++) {
			int vv, pp, v, p;
			vv = read();
			pp = read();
			v = (vv + k * last - 1) % n + 1;
			p = (pp + k * last) % (s + 1);
			write(last = cal(v, p)); putchar('\n');
		}
	}
	return 0;
}