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

#define max_len 1200
#define int __int128_t
#define gcd my_gcd
int gcd(int __m, int __n)
{
    if (__m == 0)
        return __n;
    if (__n == 0)
        return __m;

    while (true)
    {
        if (__m > __n)
        {
            int __tmp = __m;
            __m = __n;
            __n = __tmp;
        }

        __n -= __m;

        if (__n == 0)
            return __m;
    }
};

struct frac_num
{
    int fz, fm;
    frac_num() = default;
    frac_num(int zz, int mm)
    {
        fz = zz, fm = mm;
        mk_gcd();
    }
    frac_num(int zz)
    {
        fz = zz, fm = 1;
    }
    void mk_gcd()
    {
        int g = gcd(fz, fm);
        fz = fz / g, fm = fm / g;
    }
    frac_num operator+(const frac_num &r) const
    {
        return frac_num(fz * r.fm + fm * r.fz, fm * r.fm);
    }
    frac_num operator-(const frac_num &r) const
    {
        return frac_num(fz * r.fm - fm * r.fz, fm * r.fm);
    }
    frac_num operator+(const int &r) const
    {
        return frac_num(fz + fm * r, fm);
    }
    frac_num operator-(const int &r) const
    {
        return frac_num(fz - fm * r, fm);
    }
    frac_num operator*(const frac_num &r) const
    {
        return frac_num(fz * r.fz, fm * r.fm);
    }
    frac_num operator*(const int r) const
    {
        return frac_num(fz * r, fm);
    }
    frac_num operator/(const int r) const
    {
        return frac_num(fz, fm * r);
    }
    bool operator==(const int r) const
    {
        return fm == 1 && fz == r;
    }
    // bool operator<(const int r) const
    // {
    //     return 1.0 * fz / fm < r;
    // }
    bool operator<(const frac_num &r) const
    {
        return fz * r.fm < fm * r.fz;
    }
};

frac_num print_ques(frac_num fn)
{
    fn.mk_gcd();
    cout << "? " << int32_t(fn.fz) << " " << int32_t(fn.fm) << endl;
    int32_t zz, mm;
    cin >> zz >> mm;
    return frac_num(zz, mm);
}
void print_ans(frac_num fn)
{
    fn.mk_gcd();
    cout << "! " << int32_t(fn.fz) << " " << int32_t(fn.fm) << endl;
}

int32_t N;
map<int, set<int>> poi_map;
void input()
{
    poi_map.clear();
    cin >> N;
    for (int i = 0; i < N; i++)
    {
        int32_t x, y;
        cin >> x >> y;
        poi_map[x].insert(y);
    }
}

void sol()
{
    input();
    // x, [y]
    vector<pair<frac_num, vector<int>>> poi_vec;
    bool is_y_cnt1 = true;
    for (auto [pir_x, pirs] : poi_map)
    {
        poi_vec.push_back({pir_x, vector<int>()});
        for (auto yy : pirs)
        {
            poi_vec.back().second.push_back(yy);
        }
        if (pirs.size() > 1)
        {
            is_y_cnt1 = false;
        }
    }
    int poi_su = poi_vec.size();
    frac_num ans = 0;

    if (is_y_cnt1 == true)
    {
        frac_num ans_m2 = 0;
        auto last_x = poi_vec.front().first;
        auto last_bian_len = frac_num(0, 1);
        for (int32_t i = 1; i < poi_su - 1; i++)
        {
            auto now_x = poi_vec[i].first;
            auto now_y_len = print_ques(now_x);
            ans_m2 = ans_m2 + (now_y_len + last_bian_len) * (now_x - last_x);
            last_bian_len = now_y_len;
            last_x = now_x;
        }
        auto end_x = poi_vec.back().first;
        ans_m2 = ans_m2 + (last_bian_len) * (end_x - last_x);

        ans = ans_m2 / 2;
    }
    else
    {
        auto last_x = poi_vec.front().first;
        for (int32_t i = 1; i < poi_su; i++)
        {
            auto now_x = poi_vec[i].first;
            auto mid_x = (last_x + now_x) / 2;
            auto now_y_len = print_ques(mid_x);
            ans = ans + (now_y_len) * (now_x - last_x);
            last_x = now_x;
        }
    }
    print_ans(ans);
}
int32_t main()
{
    int32_t T;
    cin >> T;
    while (T--)
    {
        sol();
    }
}