#include <cassert>
#include <cmath>
#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <functional>
#include <iostream>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>

using namespace std;

using Int = long long;

template <class T1, class T2> ostream &operator<<(ostream &os, const pair<T1, T2> &a) { return os << "(" << a.first << ", " << a.second << ")"; };
template <class T> ostream &operator<<(ostream &os, const vector<T> &as) { const int sz = as.size(); os << "["; for (int i = 0; i < sz; ++i) { if (i >= 256) { os << ", ..."; break; } if (i > 0) { os << ", "; } os << as[i]; } return os << "]"; }
template <class T> void pv(T a, T b) { for (T i = a; i != b; ++i) cerr << *i << " "; cerr << endl; }
template <class T> bool chmin(T &t, const T &f) { if (t > f) { t = f; return true; } return false; }
template <class T> bool chmax(T &t, const T &f) { if (t < f) { t = f; return true; } return false; }
#define COLOR(s) ("\x1b[" s "m")


#ifdef LOCAL
// #define DEBUG
#endif

int N;

#ifdef DEBUG
vector<vector<Int>> calc(const vector<Int> &as) {
  assert((int)as.size() == N);
  vector<vector<Int>> dp(N + 1, vector<Int>(N + 1, 0));
  for (int l = 0; l < N; ++l) {
    for (int i = l; i < N; ++i) {
      dp[l][i + 1] = dp[l][i] + as[i];
    }
  }
  for (int l = N; --l >= 0; ) {
    for (int r = l + 1; r <= N; ++r) {
      chmax(dp[l][r], dp[l + 1][r]);
      chmax(dp[l][r], dp[l][r - 1]);
    }
  }
  return dp;
}

mt19937_64 rng;
vector<Int> secret;
vector<vector<Int>> secretDP;
int Q;

void gen() {
  N = 1 + rng() % 10;
  secret.resize(N);
  for (int i = 0; i < N; ++i) {
    secret[i] = -10 + rng() % 21;
  }
  secretDP = calc(secret);
  Q = 0;
}
#endif

Int ask(int l, int r) {
  assert(0 <= l); assert(l < r); assert(r <= N);
#ifdef DEBUG
  ++Q;
  return secretDP[l][r];
#else
  printf("? %d %d\n", l + 1, r);
  fflush(stdout);
  Int ret;
  scanf("%lld", &ret);
  return ret;
#endif
}

vector<Int> rec(const vector<int> &xs, const vector<Int> &as) {
// cerr<<"[rec] "<<xs<<" "<<as<<endl;
  const int len = as.size();
  assert(len >= 1);
  assert((int)xs.size() == len + 1);
  if (len == 1) {
    return as;
  }
  auto ys = xs;
  auto bs = as;
  auto merge = [&](int l, int r) -> void {
    ys.erase(ys.begin() + (l + 1), ys.begin() + r);
    bs.erase(bs.begin() + (l + 1), bs.begin() + r);
  };
  vector<Int> ret;
  auto split = [&](int l, int r) -> void {
    ret = rec(ys, bs);
    ret.insert(ret.begin() + (l + 1), r - (l + 1), 0);
  };
// #define re cerr<<"[rec:"<<__LINE__<<"] "<<xs<<" "<<as<<": "<<ret<<endl; return ret
#define re return ret
  // merge ++
  for (int i = 1; i < len; ++i) if (as[i - 1] > 0 && as[i] > 0) {
    merge(i - 1, i + 1);
    bs[i - 1] = as[i - 1] + as[i];
    split(i - 1, i + 1);
    ret[i - 1] = as[i - 1];
    ret[i] = as[i];
    re;
  }
  // merge --
  for (int i = 1; i < len; ++i) if (as[i - 1] == 0 && as[i] == 0) {
    merge(i - 1, i + 1);
    bs[i - 1] = 0;
    split(i - 1, i + 1);
    re;
  }
  // remove [-
  if (as[0] == 0) {
    ys.erase(ys.begin());
    bs.erase(bs.begin());
    ret = rec(ys, bs); ret.insert(ret.begin(), 0);
    re;
  }
  // remove -]
  if (as[len - 1] == 0) {
    ys = xs; ys.pop_back();
    bs = as; bs.pop_back();
    ret = rec(ys, bs); ret.push_back(0);
    re;
  }
  // min +
  int im = -1;
  for (int i = 0; i < len; i += 2) {
    assert(as[i] > 0);
    if (!~im || as[im] > as[i]) im = i;
  }
  if (im == 0) {
    // merge [+-+ or remove [+-
    merge(0, 3);
    // Q += 1, len -= 2
    bs[0] = ask(xs[0], xs[3]);
    split(0, 3);
    ret[0] = as[0];
    ret[1] = bs[0] - (as[0] + as[2]);
    ret[2] = as[2];
    re;
  }
  if (im == len - 1) {
    // merge [+-+ or remove [+-
    merge(len - 3, len);
    // Q += 1, len -= 2
    bs[len - 3] = ask(xs[len - 3], xs[len]);
    split(len - 3, len);
    ret[len - 3] = as[len - 3];
    ret[len - 2] = bs[len - 3] - (as[len - 3] + as[len - 1]);
    ret[len - 1] = as[len - 1];
    re;
  }
  // merge +-+ or +-+-+
  // Q += 2, len -= 2
  const Int bL = ask(xs[im - 2], xs[im + 1]);
  const Int bR = ask(xs[im], xs[im + 3]);
  if (bL > as[im - 2] && bL > as[im]) {
    merge(im - 2, im + 1);
    bs[im - 2] = bL;
    split(im - 2, im + 1);
    ret[im - 2] = as[im - 2];
    ret[im - 1] = bL - (as[im - 2] + as[im]);
    ret[im    ] = as[im];
    re;
  }
  if (bR > as[im] && bR > as[im + 2]) {
    merge(im, im + 3);
    bs[im] = bR;
    split(im, im + 3);
    ret[im    ] = as[im];
    ret[im + 1] = bR - (as[im] + as[im + 2]);
    ret[im + 2] = as[im + 2];
    re;
  }
  merge(im - 1, im + 2);
  bs[im - 1] = 0;
  split(im - 1, im + 2);
  ret[im    ] = as[im];
  ret[im + 1] = -as[im];
  re;
#undef re
}

vector<Int> solve() {
  vector<int> xs(N + 1);
  for (int i = 0; i <= N; ++i) {
    xs[i] = i;
  }
  vector<Int> as(N);
  for (int i = 0; i < N; ++i) {
    as[i] = ask(i, i + 1);
  }
  return rec(xs, as);
}

int main() {
#ifdef DEBUG
  for (; ; ) {
    gen();
    const auto ans = solve();
    cerr << COLOR("33") << secret << " " << ans << " " << Q << COLOR() << endl;
    const auto ansDP = calc(ans);
    for (int w = 0; w <= N; ++w) {
      for (int l = 0, r; (r = l + w) <= N; ++l) {
        if (secretDP[l][r] != ansDP[l][r]) {
          cerr << COLOR("91") << "FAIL [" << l << ", " << r << "): " << secretDP[l][r] << " " << ansDP[l][r] << COLOR() << endl;
          assert(false);
        }
      }
    }
    assert(Q <= 2 * N);
  }
#endif
  
  int numCases;
  scanf("%d", &numCases);
  for (int caseId = 1; caseId <= numCases; ++caseId) {
    scanf("%d", &N);
    const auto ans = solve();
    printf("!");
    for (int i = 0; i < N; ++i) {
      printf(" %lld", ans[i]);
    }
    puts("");
    fflush(stdout);
  }
  return 0;
}