#include "bits/stdc++.h"


#define rep(i, n) for (int i = 0; i < (n); ++i)
#define rep1(i, n) for (int i = 1; i < (n); ++i)
#define rep1n(i, n) for (int i = 1; i <= (n); ++i)
#define repr(i, n) for (int i = (n) - 1; i >= 0; --i)
#define pb push_back
#define eb emplace_back
#define all(a) (a).begin(), (a).end()
#define rall(a) (a).rbegin(), (a).rend()
#define each(x, a) for (auto &x : a)
#define ar array
#define vec vector
#define range(i, n) rep(i, n)

using namespace std;

using ll = long long;
using ull = unsigned long long;
using ld = long double;
using str = string;
using pi = pair<int, int>;
using pl = pair<ll, ll>;

using vi = vector<int>;
using vl = vector<ll>;
using vpi = vector<pair<int, int>>;
using vvi = vector<vi>;

int Bit(int mask, int b) { return (mask >> b) & 1; }

template<class T>
bool ckmin(T &a, const T &b) {
    if (b < a) {
        a = b;
        return true;
    }
    return false;
}

template<class T>
bool ckmax(T &a, const T &b) {
    if (b > a) {
        a = b;
        return true;
    }
    return false;
}

// [l, r)
template<typename T, typename F>
T FindFirstTrue(T l, T r, const F &predicat) {
    --l;
    while (r - l > 1) {
        T mid = l + (r - l) / 2;
        if (predicat(mid)) {
            r = mid;
        } else {
            l = mid;
        }
    }
    return r;
}


template<typename T, typename F>
T FindLastFalse(T l, T r, const F &predicat) {
    return FindFirstTrue(l, r, predicat) - 1;
}

const int INFi = 2e9;
const ll INF = 2e18;

namespace FFT {
    template<typename T>
    struct complex {
        T x, y;

        complex() : x(0), y(0) {}
        complex(T x, T y) : x(x), y(y) {}

        complex operator*(const complex &c) const {
            return complex(x * c.x - y * c.y, x * c.y + y * c.x);
        }

        complex operator+(const complex &c) const {
            return complex(x + c.x, y + c.y);
        }

        complex operator-(const complex &c) const {
            return complex(x - c.x, y - c.y);
        }

        template<typename value_t>
        complex operator/(const value_t &value) const {
            return complex(x / value, y / value);
        }

        complex conj() const {
            return complex(x, -y);
        }
    };

    template<typename float_t = long double>
    void fft(std::vector<complex<float_t>> &a) {
        static std::vector<int> reversed_mask;
        static std::vector<complex<float_t>> roots = std::vector<complex<float_t>>(1);
        static const float_t PI = acosl(-1);

        if (a.empty())
            return;

        int n = int(a.size());
        assert((n & (n - 1)) == 0);

        if (int(reversed_mask.size()) != n) {
            int lg = std::__lg(n);
            reversed_mask.resize(n);
            for (int mask = 1; mask < n; mask++)
                reversed_mask[mask] = (reversed_mask[mask >> 1] >> 1) + ((mask & 1) << (lg - 1));
        }

        if (int(roots.size()) < n) {
            int prev_size = roots.size();
            roots.resize(n);
            for (int len = prev_size; len < n; len <<= 1)
                for (int i = 0; i < len; i++)
                    roots[len + i] = complex<float_t>(cosl(PI * i / len), sinl(PI * i / len));
        }

        for (int i = 0; i < n; i++)
            if (i < reversed_mask[i])
                std::swap(a[i], a[reversed_mask[i]]);

        for (int len = 1; len < n; len <<= 1)
            for (int i = 0; i < n; i += (len << 1))
                for (int j = 0; j < len; j++) {
                    complex<float_t> value = a[i + j + len] * roots[len + j];
                    a[i + j + len] = a[i + j] - value;
                    a[i + j] = a[i + j] + value;
                }
    }

    template<typename result_t, typename float_t = long double, typename T1, typename T2>
    std::vector<result_t> multiply(T1 a_begin, T1 a_end, T2 b_begin, T2 b_end) {
        static const float_t PI = acosl(-1);

        if (a_begin == a_end || b_begin == b_end)
            return {};

        static constexpr int BUBEN = 20;
        int n = std::distance(a_begin, a_end);
        int m = std::distance(b_begin, b_end);
        if (std::min(n, m) <= BUBEN) {
            vector<result_t> product(n + m - 1);
            for (int i = 0; a_begin != a_end; i++, a_begin++) {
                T2 iterator = b_begin;
                for (int j = 0; iterator != b_end; j++, iterator++)
                    product[i + j] += result_t(*a_begin) * result_t(*iterator);
            }
            return product;
        }

        int real_size = n + m - 1;
        int base = 2;
        while (base < real_size)
            base <<= 1;

        std::vector<complex<float_t>> res(base);
        for (int i = 0; a_begin != a_end; i++, a_begin++)
            res[i].x = *a_begin;

        for (int i = 0; b_begin != b_end; i++, b_begin++)
            res[i].y = *b_begin;

        fft<float_t>(res);
        complex<float_t> coeff(0, float_t(-0.25) / base);
        for (int i = 0; i <= (base >> 1); i++) {
            int j = (base - i) & (base - 1);
            complex<float_t> num = (res[j] * res[j] - (res[i] * res[i]).conj()) * coeff;
            res[j] = (res[i] * res[i] - (res[j] * res[j]).conj()) * coeff;
            res[i] = num;
        }
        // fft(product) == res

        for (int i = 0; i < (base >> 1); i++) {
            complex<float_t> a0 = (res[i] + res[i + (base >> 1)]);
            complex<float_t> a1 = (res[i] - res[i + (base >> 1)]) * complex<float_t>(cosl(PI * i / (base >> 1)), sinl(PI * i / (base >> 1)));
            res[i] = a0 + a1 * complex<float_t>(0, 1);
        }

        res.resize(base >> 1);
        fft<float_t>(res);
        std::vector<result_t> product(real_size);

        for (int i = 0; i < real_size; i++)
            product[i] = ((i & 1) ? res[i >> 1].y : res[i >> 1].x) + (std::is_integral<result_t>::value) * float_t(0.5);

        return product;
    }

    template<typename T>
    std::vector<T> normalize(std::vector<T> pol) {
        while (!pol.empty() && pol.back() == 0)
            pol.pop_back();

        return pol;
    }

    template<typename float_t = long double>
    void fft_2d(std::vector<std::vector<complex<float_t>>> &a, bool invert) {
        for (int rot : {0, 1}) {
            for (auto &v : a) {
                fft<float_t>(v);
                if (invert) {
                    std::reverse(v.begin() + 1, v.end());
                    for (auto &x : v)
                        x = x / v.size();
                }
            }

            for (int i = 0; i < int(a.size()); i++)
                for (int j = 0; j < i; j++)
                    std::swap(a[i][j], a[j][i]);
        }
    }

    template<typename result_t, typename float_t = long double, typename T1, typename T2>
    std::vector<std::vector<result_t>> multiply_2d(T1 a_begin, T1 a_end, T2 b_begin, T2 b_end) {
        if (a_begin == a_end || b_begin == b_end || (*a_begin).empty() || (*b_begin).empty())
            return {};

        int real_size_x = std::distance(a_begin, a_end) + std::distance(b_begin, b_end) - 1;
        int real_size_y = int((*a_begin).size() + (*b_begin).size()) - 1;
        int base = 2;
        while (base < std::max(real_size_x, real_size_y))
            base <<= 1;

        auto get = [&](auto a_begin, auto a_end) {
            std::vector<std::vector<complex<float_t>>> a(base, std::vector<complex<float_t>>(base));
            for (int i = 0; a_begin != a_end; i++, a_begin++)
                for (int j = 0; j < int((*a_begin).size()); j++)
                    a[i][j].x = (*a_begin)[j];

            return a;
        };

        auto a = get(a_begin, a_end), b = get(b_begin, b_end);
        fft_2d<float_t>(a, false);
        fft_2d<float_t>(b, false);

        for (int i = 0; i < base; i++)
            for (int j = 0; j < base; j++)
                a[i][j] = a[i][j] * b[i][j];

        fft_2d<float_t>(a, true);

        std::vector<std::vector<result_t>> product(real_size_x, std::vector<result_t>(real_size_y));
        for (int i = 0; i < real_size_x; i++)
            for (int j = 0; j < real_size_y; j++)
                product[i][j] = a[i][j].x + (std::is_integral<result_t>::value) * float_t(0.5);

        return product;
    }
} // namespace FFT

struct bigint {
    std::vector<int> digits;
    bool positive;

    bigint(long long value = 0) {
        *this = bigint(std::to_string(value));
    }

    template<typename T>
    bigint(const std::vector<T> &v) : digits(v.begin(), v.end()), positive(true) {
        normalize();
    }

    bigint(std::string s) : positive(true) {
        assert(!s.empty());
        if (s[0] == '-') {
            positive = false;
            s = s.substr(1);
        }

        for (auto c : s)
            assert(std::isdigit(c));

        std::reverse(s.begin(), s.end());
        digits.resize(s.size());
        for (int i = 0; i < int(s.size()); i++)
            digits[i] = s[i] - '0';
    }

    explicit operator std::string() const {
        std::string res;
        if (!positive)
            res += '-';

        for (int i = int(digits.size()) - 1; i >= 0; i--)
            res += '0' + digits[i];

        return res;
    }

    template<typename T>
    explicit operator T() const {
        static_assert(std::is_integral<T>::value);
        T coeff = 1, value = 0;
        for (auto &x : digits) {
            value += x * coeff;
            coeff *= 10;
        }
        return value;
    }

    void normalize() {
        for (int i = 0; i < int(digits.size()); i++) {
            if (i == int(digits.size()) - 1 && digits[i] < 0) {
                positive = !positive;
                for (auto &x : digits)
                    x *= -1;

                normalize();
                return;
            }

            int delta = digits[i] < 0 ? -((-digits[i] + 9) / 10) : digits[i] / 10;
            digits[i] -= delta * 10;

            if (delta) {
                if (i == int(digits.size()) - 1)
                    digits.push_back(delta);
                else
                    digits[i + 1] += delta;
            }
        }

        while (digits.size() > 1 && digits.back() == 0)
            digits.pop_back();

        if (digits.size() == 1 && digits[0] == 0)
            positive = true;

        if (digits.empty()) {
            digits = {0};
            positive = true;
        }
    }

    bool operator==(const bigint&) const = default;

    std::strong_ordering operator<=>(const bigint &x) const {
        if (!positive && x.positive)
            return std::strong_ordering::less;

        if (positive && !x.positive)
            return std::strong_ordering::greater;

        if (digits.size() != x.digits.size())
            return ((digits.size() < x.digits.size()) ^ (!positive))
                ? std::strong_ordering::less : std::strong_ordering::greater;

        for (int i = int(digits.size()) - 1; i >= 0; i--)
            if (digits[i] != x.digits[i])
                return (digits[i] < x.digits[i]) ^ (!positive)
                    ? std::strong_ordering::less : std::strong_ordering::greater;

        return std::strong_ordering::equal;
    }

    void to_positive() {
        if (!positive) {
            positive = true;
            for (auto &x : digits)
                x *= -1;
        }
    }

    bigint& operator+=(const bigint &x) {
        to_positive();
        if (digits.size() < x.digits.size())
            digits.resize(x.digits.size());

        for (int i = 0; i < int(x.digits.size()); i++)
            digits[i] += x.positive ? x.digits[i] : -x.digits[i];

        normalize();
        return *this;
    }

    bigint& operator-=(const bigint &x) {
        to_positive();
        if (digits.size() < x.digits.size())
            digits.resize(x.digits.size());

        for (int i = 0; i < int(x.digits.size()); i++)
            digits[i] -= x.positive ? x.digits[i] : -x.digits[i];

        normalize();
        return *this;
    }

    bigint& operator*=(const bigint &x) {
        positive = !(positive ^ x.positive);
        digits = FFT::multiply<int, double>(digits.begin(), digits.end(),
                                    x.digits.begin(), x.digits.end());
        normalize();
        return *this;
    }

    bigint shift_right(int shift) const {
        bigint res;
        if (shift >= int(digits.size())) {
            res.digits = {0};
            res.positive = true;
            return res;
        }

        res.digits = std::vector<int>(digits.begin() + shift, digits.end());
        return res;
    }

    bigint shift_left(int shift) const {
        bigint res;
        res.digits = std::vector<int>(shift, 0);
        res.digits.insert(res.digits.end(), digits.begin(), digits.end());
        return res;
    }

    std::pair<bigint, bigint> divide21(const bigint &a, const bigint &b, int n) const {
        if (a < b)
            return {bigint(0), a};

        if (n <= 9) {
            long long first = (long long) a, second = (long long) b;
            return {bigint(first / second), bigint(first % second)};
        }

        auto c = a.shift_right(n / 2);
        auto [coeff, rem] = divide32(c, b, n / 2);

        auto [coeff2, rem2] = divide32(rem.shift_left(n / 2)
            + bigint(std::vector<int>(a.digits.begin(), a.digits.begin() + std::min<int>(n / 2, a.digits.size()))),
        b, n / 2);

        return {coeff.shift_left(n / 2) + coeff2, rem2};
    }

    std::pair<bigint, bigint> divide32(const bigint &a, const bigint &b, int n) const {
        if (a < b)
            return {bigint(0), a};

        if (int(b.digits.size()) <= n)
            return divide21(a, b, n);

        if (n <= 6) {
            long long first = (long long) a, second = (long long) b;
            return {bigint(first / second), bigint(first % second)};
        }

        bigint coeff;
        int k = int(b.digits.size()) - n;
        auto a1 = a.shift_right(k), b1 = b.shift_right(k);

        if (b1.shift_left(n) < a1)
            coeff = bigint(1).shift_left(n);
        else
            coeff = divide21(a1, b1, n).first;

        auto current = a - b * coeff;
        while (current < 0) {
            current += b;
            coeff--;
        }

        return {coeff, current};
    }

    std::pair<bigint, bigint> divide(bigint a, bigint b) const {
        if (a < b)
            return {bigint(0), b};

        int size = 1;
        while (size < int(std::max(a.digits.size(), b.digits.size())))
            size <<= 1;

        auto [coeff, rem] = divide32(a, b, size);
        coeff.normalize();
        rem.normalize();
        return {coeff, rem};
    }

    bigint& operator/=(const bigint &x) {
        *this = divide(*this, x).first;
        positive = !(positive ^ x.positive);
        return *this;
    }

    bigint& operator%=(const bigint &x) {
        *this -= x * (*this / x);
        // *this = divide(*this, x).second;
        positive = true;
        return*this;
    }

    friend bigint operator+(const bigint &a, const bigint &b) {
        return bigint(a) += b;
    }

    friend bigint operator-(const bigint &a, const bigint &b) {
        return bigint(a) -= b;
    }

    friend bigint operator*(const bigint &a, const bigint &b) {
        return bigint(a) *= b;
    }

    friend bigint operator/(const bigint &a, const bigint &b) {
        return bigint(a) /= b;
    }

    friend bigint operator%(const bigint &a, const bigint &b) {
        return bigint(a) %= b;
    }

    bigint& operator++() {
        return *this += 1;
    }

    bigint& operator--() {
        return *this -= 1;
    }

    bigint operator++(int) {
        return *this += 1;
    }

    bigint operator--(int) {
        return *this -= 1;
    }

    friend std::istream& operator>>(std::istream &in, bigint &x) {
        std::string s;
        in >> s;
        x = bigint(s);
        return in;
    }

    friend std::ostream& operator<<(std::ostream &out, const bigint &x) {
        return out << std::string(x);
    }
};

bigint gcd(const bigint &a, const bigint &b) {
    if (b == bigint(0)) {
        return a;
    }
    return gcd(b, a % b);
}

template<class T>
class Frac {
public:
    T num;
    T den;
    void normalize() {
        bigint g = gcd(num, den);
        if (g < bigint(0)) {
            g = bigint(0) - g;
        }
        num /= g;
        den /= g;
    }

    Frac &operator+=(const Frac &rhs) {
        num = num * rhs.den + rhs.num * den;
        den *= rhs.den;
        return *this;
    }
    Frac &operator-=(const Frac &rhs) {
        num = num * rhs.den - rhs.num * den;
        den *= rhs.den;
        return *this;
    }
    Frac &operator*=(const Frac &rhs) {
        num *= rhs.num;
        den *= rhs.den;
        return *this;
    }
    Frac &operator/=(const Frac &rhs) {
        num *= rhs.den;
        den *= rhs.num;
        if (den < bigint(0)) {
            num = bigint(0) - num;
            den = bigint(0) - den;
        }
        return *this;
    }
    friend Frac operator+(Frac lhs, const Frac &rhs) {
        return lhs += rhs;
    }
    friend Frac operator-(Frac lhs, const Frac &rhs) {
        return lhs -= rhs;
    }
    friend Frac operator*(Frac lhs, const Frac &rhs) {
        return lhs *= rhs;
    }
    friend Frac operator/(Frac lhs, const Frac &rhs) {
        return lhs /= rhs;
    }
    friend Frac operator-(const Frac &a) {
        return Frac(bigint(0) - a.num, a.den);
    }
    friend bool operator==(const Frac &lhs, const Frac &rhs) {
        return lhs.num * rhs.den == rhs.num * lhs.den;
    }
    friend bool operator!=(const Frac &lhs, const Frac &rhs) {
        return lhs.num * rhs.den != rhs.num * lhs.den;
    }
    friend bool operator<(const Frac &lhs, const Frac &rhs) {
        return lhs.num * rhs.den < rhs.num * lhs.den;
    }
    friend bool operator>(const Frac &lhs, const Frac &rhs) {
        return lhs.num * rhs.den > rhs.num * lhs.den;
    }
    friend bool operator<=(const Frac &lhs, const Frac &rhs) {
        return lhs.num * rhs.den <= rhs.num * lhs.den;
    }
    friend bool operator>=(const Frac &lhs, const Frac &rhs) {
        return lhs.num * rhs.den >= rhs.num * lhs.den;
    }
};

using Fraction = Frac<bigint>;

Fraction ask(bigint p, bigint q) {
    cout << "? " << p << " " << q << endl;
    bigint r, s; cin >> r >> s;
    // return {0, 1};
    return {r, s};
}

void solve() {
    map<int, int> cnt;
    int n; cin >> n;
    rep(_, n) {
        int x, y; cin >> x >> y;
        cnt[x]++;
    }

    vector<pair<ll, ll>> a(all(cnt));
    if (a.size() <= 1) {
        cout << "! 0 1" << endl;
        return;
    }

    Fraction result = {bigint(0), bigint(1)};

    auto Add = [&] (Fraction len1, Fraction len2, Fraction xdiff, Fraction ladd, Fraction radd) {
        assert(xdiff.num != bigint(0));
        Fraction L = len1;
        if (ladd.num != bigint(0)) {
            auto df = len1 - len2;
            df /= xdiff;
            df *= (xdiff + ladd);
            L = df + len2;
        }
        Fraction R = len2;
        if (radd.num != bigint(0)) {
            auto df = len2 - len1;
            df /= xdiff;
            df *= (xdiff + radd);
            R = df + len1;
        }
        auto h = xdiff + ladd + radd;
        h *= Fraction{bigint(1), bigint(2)};
        auto res = (L + R) * h;
        result += res;
    };


    Fraction len1, ladd, prv;
    if (a[0].second == 1) {
        len1 = {bigint(0), bigint(1)};
        ladd = {bigint(0), bigint(1)};
        prv = {bigint(a[0].first), bigint(1)};
    } else {
        len1 = ask(bigint(a[0].first), bigint(1));
        ladd = {bigint(0), bigint(1)};
        prv = {bigint(a[0].first), bigint(1)};
    }

    for(int i = 1; i + 1 < (int)a.size(); ++i) {
        if (a[i].second == 1) {
            Fraction nx = {bigint(a[i].first), bigint(1)};
            Fraction cur = ask(bigint(a[i].first), bigint(1));

            Add(len1, cur, nx - prv, ladd, Fraction{bigint(0), bigint(1)});

            prv = nx;
            ladd = {bigint(0), bigint(1)};
            len1 = cur;
            continue;
        }
        Fraction radd = {bigint(1), bigint(4)};
        Fraction nx = {bigint(a[i].first), bigint(1)};
        Fraction rp = nx - radd;

        Fraction len2 = ask(rp.num, rp.den);

        Fraction xdiff = rp - prv;
        Add(len1, len2, xdiff, ladd, radd);

        prv = nx + radd;
        ladd = radd;
        len1 = ask(prv.num, prv.den);
    }
    {
        Fraction radd = {bigint(0), bigint(1)};
        Fraction nx = {a.back().first, 1};
        Fraction len2 = {bigint(0), bigint(1)};
        if (a.back().second > bigint(1)) {
            len2 = ask(nx.num, nx.den);
        }

        Add(len1, len2, nx - prv, ladd, radd);
    }
    result.normalize();
    cout << "! " << result.num << ' ' << result.den << endl;
}

signed main() {
    ios_base::sync_with_stdio(false);
    cin.tie(0);
    cout << setprecision(12) << fixed;
    int t = 1;
    cin >> t;

    rep(i, t) {
        solve();
    }
    return 0;
}