#include <iostream>
#include <vector>
#include <numeric>
#include <algorithm>

// Use long long for sums to avoid overflow
using ll = long long;
using namespace std;
struct Interval {
    int id;
    ll l, r;
    ll val_A; // Value if chosen as the first element in a pair: r - 2*l
    ll val_B; // Value if chosen as the second element in a pair: 2*r - l
    ll gain_C; // Gain if chosen as second instead of first: B - A = r + l
};

// Comparator to sort intervals by their "gain" in descending order
bool compareIntervals(const Interval& a, const Interval& b) {
    return a.gain_C > b.gain_C;
}

ll solve() {
    int n;
    std::cin >> n;
    std::vector<Interval> intervals(n);
    ll total_A_sum = 0;

    for (int i = 0; i < n; ++i) {
        intervals[i].id = i;
        std::cin >> intervals[i].l >> intervals[i].r;
        intervals[i].val_A = intervals[i].r - 2 * intervals[i].l;
        intervals[i].val_B = 2 * intervals[i].r - intervals[i].l;
        intervals[i].gain_C = intervals[i].r + intervals[i].l;
        total_A_sum += intervals[i].val_A;
    }

    // Sort by the gain 'C' in descending order. This is the crucial step.
    std::sort(intervals.begin(), intervals.end(), compareIntervals);

    if (n % 2 == 0) {
        // EVEN CASE:
        // We must choose n/2 intervals to be 'second' elements (set J)
        // and n/2 to be 'first' elements (set I). To maximize the sum,
        // we greedily pick the n/2 intervals with the highest gain (C)
        // to form set J. The rest form set I.
        ll total_C_gain = 0;
        for (int i = 0; i < n / 2; ++i) {
            total_C_gain += intervals[i].gain_C;
        }
        return total_A_sum + total_C_gain;
    } else {
        // ODD CASE:
        // We have (n-1)/2 pairs and one singleton. We need to choose
        // one interval 's' to be a singleton and (n-1)/2 intervals to be 'second'.
        // The total value is Sum(A_k) + Sum(C_j for j in J) + (S_s - A_s).
        // Let D_s = S_s - A_s = l_s.
        // We want to maximize Sum(C_j) + D_s.

        // First, calculate the sum of the top (n-1)/2 C_j values.
        ll top_C_sum = 0;
        for (int i = 0; i < (n - 1) / 2; ++i) {
            top_C_sum += intervals[i].gain_C;
        }

        ll max_extra_gain = -2e18; // A very small number

        // Iterate through all n intervals, considering each as a potential singleton 's'.
        for (int i = 0; i < n; ++i) {
            ll current_C_sum = top_C_sum;
            ll singleton_gain_D = intervals[i].l;

            // Check if the current interval 'i' was part of the original top C sum.
            bool is_in_top_group = (i < (n - 1) / 2);

            if (is_in_top_group) {
                // If 'i' was in the top group, we can't use its C gain.
                // We must remove it and add the next best C gain from outside the group.
                current_C_sum -= intervals[i].gain_C;
                current_C_sum += intervals[(n - 1) / 2].gain_C;
            }
            
            // The total extra gain for this choice of singleton is the adjusted C sum plus the D gain.
            max_extra_gain = std::max(max_extra_gain, current_C_sum + singleton_gain_D);
        }
        return total_A_sum + max_extra_gain;
    }
}

int main() {
    // Fast I/O
    std::ios_base::sync_with_stdio(false);
    std::cin.tie(NULL);

    int t;
    cin>>t;
    while(t--){
    std::cout << solve() << std::endl;
    }
    return 0;
}

void solve() {
    int n;
    cin >> n;
    vector<pair<int, int>> v(n);
    for (int i = 0; i < n; i++) {
        cin >> v[i].first >> v[i].second;
    }
 
    const int K = 1000000000;
 
    int max_sum_xy = -4e9 - 7; // A sufficiently small initial value
    for (int i = 0; i < n; i++) {
        if (v[i].first + v[i].second > max_sum_xy) {
            max_sum_xy = v[i].first + v[i].second;
        }
    }
 
    cout << "? U " << K << endl;
    cout.flush(); 
    int s1;
    cin >> s1;
    if (s1 == -1) return;
 
    cout << "? R " << K << endl;
    cout.flush();
    int s2;
    cin >> s2;
    if (s2 == -1) return;
 
    int C1 = s2 - 2 * K + max_sum_xy;
 
 
    int max_diff_xy = -4e9 - 7; 
    for (int i = 0; i < n; i++) {
        if (v[i].first - v[i].second > max_diff_xy) {
            max_diff_xy = v[i].first - v[i].second;
        }
    }
 
    cout << "? D " << 2 * K << endl;
    cout.flush();
    int k;
    cin>>k;
    cout << "? D " << 2 * K << endl;
    cout.flush();
    int s3;
    cin >> s3;
    if (s3 == -1) return;
    
    int C2 = s3 - 2 * K + max_diff_xy;
 
    int X = (C1 + C2) / 2;
    int Y = (C1 - C2) / 2;
 
    cout << "! " << X << " " << Y << endl;
    cout.flush();
}