#include <map>
#include <set>
#include <array>
#include <cmath>
#include <deque>
#include <bitset>
#include <random>
#include <string>
#include <vector>
#include <cassert>
#include <complex>
#include <iomanip>
#include <iostream>
#include <algorithm>
#include <unordered_map>
#include <unordered_set>

using namespace std;
#define int long long

const int inf = 1e15;

int n;
vector<int> a_test;

void gen_test() {
    n = rand() % 50 + 1;
    a_test.resize(n);
    for (int i = 0; i < n; ++i) {
        a_test[i] = rand() % 100 - 50;
    }
}

int get(int l, int r, vector<int>& a) {
    int res = 0;
    for (int i = l; i < r; ++i) {
        int sum = 0;
        for (int j = i; j < r; ++j) {
            sum += a[j];
            res = max(res, sum);
        }
    }
    return res;
}

int ask(int l, int r) {
    // return get(l, r, a_test);

    cout << "? " << l + 1 << ' ' << r << endl;
    int res;
    cin >> res;
    return res;
}

struct Block {
    int l;
    int r;
    int sum;
};

void check(vector<int> ans) {
    // cerr << "check:\n";
    // cerr << "give = ";
    // for (int i : ans) cerr << i << ' ';
    // cerr << '\n';

    // cerr << "need = ";
    // for (int i : a_test) cerr << i << ' ';
    // cerr << '\n';

    // for (int l = 0; l < n; ++l) {
    //     for (int r = l + 1; r <= n; ++r) {
    //         assert(get(l, r, ans) == get(l, r, a_test));
    //     }
    // }

    cout << "! ";
    for (int i = 0; i < n; ++i) {
        cout << ans[i] << ' ';
    }
    cout << endl;
}

void solve() {
    gen_test();
    cin >> n;

    vector<Block> b;
    vector<int> ans(n, 0);

    for (int i = 0; i < n; ++i) {
        ans[i] = ask(i, i + 1);
        if (ans[i] > 0) {
            int s = ans[i];
            for (int j = i + 1; j <= n; ++j) {
                if (j != n) ans[j] = ask(j, j + 1);
                if (j == n || ans[j] == 0) {
                    // stop
                    b.push_back(Block{i, j, s});
                    i = j;
                    break;
                } else {
                    s += ans[j];
                }
            }
        } else {
            continue;
        }
    }

    while (b.size() >= 2) {
        // cerr << "blocks:\n";
        // for (auto bb : b) {
        //     cerr << bb.l << ' ' << bb.r << ' ' << bb.sum << ",   ";
        // }
        // cerr << '\n';

        if (b[0].sum <= b[1].sum) {
            int r = ask(b[0].l, b[1].r);
            if (r == b[1].sum) {
                ans[b[0].r] = -inf;
                b.erase(b.begin());
            } else {
                ans[b[0].r] = - (b[0].sum + b[1].sum - r);

                auto l0 = b[0].l;
                auto r1 = b[1].r;
                b.erase(b.begin(), b.begin() + 2);
                b.insert(b.begin(), Block(l0, r1, r));
            }
        } else if (b[b.size() - 1].sum <= b[b.size() - 2].sum) {
            int r = ask(b[b.size() - 2].l, b[b.size() - 1].r);
            if (r == b[b.size() - 2].sum) {
                ans[b[b.size() - 2].r] = -inf;
                b.erase(--b.end());
            } else {
                ans[b[b.size() - 2].r] = - (b[b.size() - 2].sum + b[b.size() - 1].sum - r);

                auto l0 = b[b.size() - 2].l;
                auto r1 = b[b.size() - 1].r;
                b.pop_back();
                b.pop_back();
                b.insert(b.end(), Block(l0, r1, r));
            }
        } else {
            for (int i = 0; i + 2 < b.size(); ++i) {
                if (b[i].sum >= b[i + 1].sum && b[i + 1].sum <= b[i + 2].sum) {
                    int rl = ask(b[i].l, b[i + 1].r);
                    if (rl == b[i].sum) {
                        int rr = ask(b[i + 1].l, b[i + 2].r);
                        if (rr == b[i + 2].sum) {
                            // hmm
                            ans[b[i + 1].r] = -b[i + 1].sum;
                            b.erase(b.begin() + i + 1);
                        } else {
                            ans[b[i + 1].r] = -(b[i + 1].sum + b[i + 2].sum - rr);
                            auto l0 = b[i + 1].l;
                            auto r1 = b[i + 2].r;
                            b.erase(b.begin() + i + 1, b.begin() + i + 3);
                            b.insert(b.begin() + i + 1, Block(l0, r1, rr));
                        }
                    } else {
                        ans[b[i].r] = -(b[i].sum + b[i + 1].sum - rl);
                        auto l0 = b[i].l;
                        auto r1 = b[i + 1].r;
                        b.erase(b.begin() + i, b.begin() + i + 2);
                        b.insert(b.begin() + i, Block(l0, r1, rl));
                    }
                    break;
                }
            }
        }
    }

    check(ans);
    // cerr << "ok\n\n\n";
}

signed main() {
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);

    int t = 10000;
    cin >> t;
    while (t--) solve();
    
    return 0;
}