#include <stdio.h>
#include <string.h>

#include <queue>
#include <algorithm>

#define LOG(FMT...) fprintf(stderr, FMT)

#define fi first
#define se second
#define em emplace
#define eb emplace_back

using namespace std;

typedef long long LL;
constexpr int N = 1005, LB = 1, B = 1 << LB;

vector<int> operator + (const vector<int> &a, const vector<int> &b) {
	vector<int> c(max(a.size(), b.size()));
	int x = 0;
	for (int i = 0; i < a.size() || i < b.size(); ++i) {
		if (i < a.size()) x += a[i];
		if (i < b.size()) x += b[i];
		c[i] = x & B - 1;
		x >>= LB;
	}
	if (x) {
		c.eb(x);
	}
	return c;
}

bool operator < (const vector<int> &a, const vector<int> &b) {
	if (a.size() != b.size()) {
		return a.size() < b.size();
	}
	for (int i = (int)a.size() - 1; ~i; --i) {
		if (a[i] != b[i]) {
			return a[i] < b[i];
		}
	}
	return false;
}

vector<int> operator - (vector<int> a, const vector<int> &b) {
	if (a < b) {
		LOG("ERR\n");
		exit(0);
	}
	for (int i = 0; i < (int)a.size(); ++i) {
		if (i < (int)b.size()) a[i] -= b[i];
		if (a[i] < 0) {
			a[i] += B;
			a[i + 1] -= 1;
		}
	}
	while (a.size() && !a.back()) {
		a.pop_back();
	}
	return a;
}

vector<int> operator * (const vector<int> &a, const vector<int> &b) {
	vector<int> c(a.size() + b.size() - 1, 0);
	for (int i = 0; i < (int)a.size(); ++i) {
		for (int j = 0; j < (int)b.size(); ++j) {
			c[i + j] += a[i] * b[j];
		}
	}
	int x = 0;
	for (int i = 0; i < (int)c.size(); ++i) {
		x += c[i];
		c[i] = x & B - 1;
		x >>= LB;
	}
	while (x) {
		c.eb(x & B - 1);
		x >>= LB;
	}
	return c;
}

void wr(const vector<int> &v) {
	if (v.empty()) {
		printf(" 0");
		return;
	}
	LL t = 0;
	for (int i = (int)v.size() - 1; ~i; --i) {
		t = t << 1 | v[i];
	}
	printf(" %lld", t);
}

vector<int> operator / (vector<int> a, const vector<int> &b) {
	if (a < b) {
		LOG("ERR div\n");
		exit(0);
	}
	if (b.empty() || b.back() == 0) {
		LOG("ERR div b\n");
		exit(0);
	}
	vector<int> ret((int)a.size() - (int)b.size() + 1, 0);
	int x = 0;
	while (a.size() >= b.size()) {
		a.back() += 2 * x;
		bool greater = true;
		for (int j = 0; j < (int)b.size(); ++j) {
			if (a[(int)a.size() - 1 - j] != b[(int)b.size() - 1 - j]) {
				if (a[(int)a.size() - 1 - j] < b[(int)b.size() - 1 - j]) {
					greater = false;
				}
				break;
			}
		}
		if (greater) {
			ret[(int)a.size() - (int)b.size()] = 1;
			for (int j = 0; j < (int)b.size(); ++j) {
				a[(int)a.size() - 1 - j] -= b[(int)b.size() - 1 - j];
				if (a[(int)a.size() - 1 - j] < 0) {
					a[(int)a.size() - 1 - j] += B;
					a[(int)a.size() - j] -= 1;
				}
			}
		}
		x = a.back(), a.pop_back();
	}
	while (ret.size() && !ret.back()) {
		ret.pop_back();
	}
	for (int x : a) {
		if (x) {
			LOG("ERR\n");
			exit(0);
		}
	}
	return ret;
}

vector<int> lshift(vector<int> a) {
	if (a.empty()) {
		return a;
	}
	for (int i = 1; i < (int)a.size(); ++i) {
		a[i - 1] = a[i];
	}
	a.pop_back();
	return a;
}

vector<int> rshift(vector<int> a) {
	a.eb(0);
	for (int i = (int)a.size() - 1; i; --i) {
		a[i] = a[i - 1];
	}
	a[0] = 0;
	return a;
}

vector<int> gcd(const vector<int> &a, const vector<int> &b) {
	if (a.empty()) {
		return b;
	}
	if (b.empty()) {
		return a;
	}
	if (!(a[0] & 1) && !(b[0] & 1)) {
		return rshift(gcd(lshift(a), lshift(b)));
	}
	if (!(a[0] & 1)) {
		return gcd(lshift(a), b);
	}
	if (!(b[0] & 1)) {
		return gcd(a, lshift(b));
	}
	return a < b ? gcd(a, b - a) : gcd(a - b, b);
}

void setv(vector<int> &v, LL t) {
	v.clear();
	LL x = t;
	while (x) {
		v.eb(x & B - 1);
		x >>= LB;
	}
}

LL gcd(LL x, LL y) {
	return y ? gcd(y, x % y) : x;
}

pair<LL, LL> simp(LL a, LL b) {
	if (a == 0ll) {
		return {0ll, 1ll};
	}
	LL d = gcd(a, b);
	a = a / d, b = b / d;
	return {a, b};
}

pair<LL, LL> operator + (const pair<LL, LL> &s, const pair<LL, LL> &t) {
	return simp(s.fi * t.se + s.se * t.fi, s.se * t.se);
}

pair<LL, LL> operator * (const pair<LL, LL> &s, int t) {
	return simp(s.fi * t, s.se);
}

pair<LL, LL> operator / (const pair<LL, LL> &s, int t) {
	return simp(s.fi, s.se * t);
}

struct Frac {
	vector<int> x, y;
	Frac() : x{}, y{1} {}
	Frac(const vector<int> &_x, const vector<int> &_y) : x(_x), y(_y) {}
	Frac simp(vector<int> a, vector<int> b) const {
		vector<int> d = gcd(a, b);
		a = a / d, b = b / d;
		return Frac(a, b);
	}
	Frac(const pair<LL, LL> &t) {
		setv(x, t.fi), setv(y, t.se);
	}
	Frac operator + (const Frac &t) const {
		return simp(x * t.y + y * t.x, y * t.y);
	}
	void write() const {
		printf("!");
		wr(x), wr(y);
		puts("");
		fflush(stdout);
	}
};

pair<LL, LL> Q(pair<LL, LL> t) {
	printf("? %lld %lld\n", t.fi, t.se);
	fflush(stdout);
	pair<LL, LL> ret;
	scanf("%lld%lld", &ret.fi, &ret.se);
	return ret;
}

int n;
int xs[N], szd;
pair<LL, LL> v[N];

void solve1() {
	for (int i = 1; i < n - 1; ++i) {
		v[i] = Q(simp(xs[i], 1ll));
	}
	Frac res;
	v[0] = v[n - 1] = {0ll, 1ll};
	for (int i = 1; i < n; ++i) {
		res = res + Frac((v[i] + v[i - 1]) * (xs[i] - xs[i - 1]) / 2);
	}
	res.write();
	fflush(stdout);
}

void solve2() {
	Frac res;
	for (int i = 1; i < szd; ++i) {
		res = res + Frac(Q(simp(xs[i] + xs[i - 1], 2ll)) * (xs[i] - xs[i - 1]));
	}
	res.write();
	fflush(stdout);
}

int main() {
	int task;
	for (scanf("%d", &task); task--; ) {
		scanf("%d", &n);
		for (int i = 0, y; i < n; ++i) {
			scanf("%d%d", xs + i, &y);
		}
		sort(xs, xs + n);
		szd = unique(xs, xs + n) - xs;
		if (szd == n) {
			solve1();
		} else {
			solve2();
		}
	}
	return 0;
}