#include <bits/stdc++.h>

#define forn(i, n) for (int (i) = 0; (i) < int(n); ++(i))

using ll=long long;
using ull=unsigned long long;
using ld=long double;
using pii = std::pair<int, int>;
#define x first
#define y second
#define all(x) (x).begin(),(x).end()
#define pb push_back

template<typename T>
static inline T gcd(T a, T b) {
    a = std::abs(a);
    b = std::abs(b);
    while (b > 0) {
        a %= b;
        std::swap(a, b);
    }
    return a;
}

template<typename T>
static inline T lcm(T a, T b) {
    return a / gcd(a, b) * b;
}

template<typename T>
static inline T sqr(T a) {
    return a * a;
}

template<typename T>
static inline bool remin(T &a, const T &val) {
    if (a > val) {
        a = val;
        return true;
    }
    return false;
}

template<typename T>
static inline bool remax(T &a, const T &val) {
    if (a < val) {
        a = val;
        return true;
    }
    return false;
}

static inline ll nxt() {
    int64_t x;
    scanf("%" PRId64, &x);
    return x;
}

static inline void skipEndLine() {
    char c = getchar();
    while (c != '\n') {
        c = getchar();
    }
}

static inline std::string nxtLine() {
    std::string ret;
    char c = '\n';
    while (true) {
        c = getchar();
        if (c == '\n' || c == '\r' || c == -1) {
            break;
        }
        ret.push_back(c);
    }
    return ret;
}

static inline std::string nxtString() {
    std::string ret;
    char c = '\n';
    while (true) {
        c = getchar();
        if (!isspace(c)) {
            break;
        }
    }
    if (c == -1) {
        return ret;
    }
    ret.push_back(c);
    while (true) {
        c = getchar();
        if (isspace(c) || c == -1) {
            break;
        }
        ret.push_back(c);
    }
    return ret;
}

static std::chrono::system_clock::time_point clock_t0;

static inline void init_time() {
    clock_t0 = std::chrono::system_clock::now();
}

static inline double get_time() {
    auto t = std::chrono::system_clock::now();
    return std::chrono::duration<double>((t - clock_t0)).count();
}

static inline void print_time(const std::string &name) {
    std::cerr << name << " " << get_time() << "s." << std::endl;
}

template <class T>
static inline T pw(T a, ll n) {
    T ret = T(1);
    while (n > 0) {
        if (n & 1) ret = ret * a;
        a = a * a;
        n >>= 1;
    }
    return ret;
}

static inline ll pw(ll a, ll n, ll m) {
//    if (a == 0) return 0;
    a %= m;
    ll ret = 1;
    while (n > 0) {
        if (n & 1) ret = ret * a % m;
        a = a * a % m;
        n >>= 1;
    }
    return ret;
}

typedef std::thread thread_type;

class ThreadPool {
public:
    ThreadPool(size_t);

    template<class F, class... Args>
    auto enqueue(F &&f, Args &&... args)
    -> std::future<typename std::result_of<F(Args...)>::type>;

    ~ThreadPool();

private:
    // need to keep track of threads so we can join them
    std::vector<thread_type> workers;
    // the task queue
    std::queue<std::function<void()> > tasks;

    // synchronization
    std::mutex queue_mutex;
    std::condition_variable condition;
    bool stop;
};

// the constructor just launches some amount of workers
inline ThreadPool::ThreadPool(size_t threads)
        : stop(false) {
    for (size_t i = 0; i < threads; ++i) {
        auto f = [this] {
            for (;;) {
                std::function<void()> task;

                {
                    std::unique_lock<std::mutex> lock(this->queue_mutex);
                    this->condition.wait(lock,
                                         [this] { return this->stop || !this->tasks.empty(); });
                    if (this->stop && this->tasks.empty())
                        return;
                    task = std::move(this->tasks.front());
                    this->tasks.pop();
                }

                task();
            }
        };
        workers.emplace_back(f);
    }
}

// add new work item to the pool
template<class F, class... Args>
auto ThreadPool::enqueue(F &&f, Args &&... args) -> std::future<typename std::result_of<F(Args...)>::type> {
    using return_type = typename std::result_of<F(Args...)>::type;

    auto task = std::make_shared<std::packaged_task<return_type()> >(
            std::bind(std::forward<F>(f), std::forward<Args>(args)...)
    );

    std::future<return_type> res = task->get_future();
    {
        std::unique_lock<std::mutex> lock(queue_mutex);

        // don't allow enqueueing after stopping the pool
        if (stop) {
            throw std::runtime_error("enqueue on stopped ThreadPool");
        }

        tasks.emplace([task]() { (*task)(); });
    }
    condition.notify_one();
    return res;
}

// the destructor joins all threads
inline ThreadPool::~ThreadPool() {
    {
        std::unique_lock<std::mutex> lock(queue_mutex);
        stop = true;
    }
    condition.notify_all();
    for (thread_type &worker: workers) {
        worker.join();
    }
}

static const ld PI = acosl(-1.0);
static std::mt19937_64 generator{123123123};

using namespace std;

void prepare() {

}

static const ll mod = 998244353;

int query(int l1, int r1, int l2, int r2) {
    if (l1 >= r1) return 0;
    if (l2 >= r2) return 0;

    cout << "? " << (r1 - l1) << " " << (r2 - l2) << "\n";
    for (int i = l1; i < r1; ++i) {
        cout << i + 1 << " ";
    }
    cout << "\n";
    for (int i = l2; i < r2; ++i) {
        cout << i + 1 << " ";
    }
    cout << endl;
    int v;
    cin >> v;
    return v;
}

void solve(int test) {
    int n;
    cin >> n;
    int p = 1;
    while (p + 1 < n) {
        int v = query(0, p, p, p + 1);
        if (v != 0) {
            break;
        }
        ++p;
    }
    vector<int> ans(n, 0);
    ans[p] = 1;
    for (int i = p + 1; i < n; ++i) {
        int v = query(p, p + 1, i, i + 1);
        if (v != 0) {
            ans[i] = 1;
        }
    }
    int l = 0, r = p - 1;
    while (l < r) {
        int m = (l + r + 1) >> 1;
        int v = query(m, p, p, p + 1);
        if (v != 0) {
            l = m;
        } else {
            r = m - 1;
        }
    }
    ans[l] = 1;
    int cnt = 0;
    forn(i, n) {
        cnt += int(ans[i] == 0);
    }
    cout << "! " << cnt;
    forn(i, n) {
        if (ans[i] == 0) {
            cout << " " << i + 1;
        }
    }
    cout << endl;
}

int main() {
#ifdef LOCAL
//    freopen("input.txt", "r", stdin);
//    freopen("output.txt", "w", stdout);
#endif
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr);
    init_time();

    prepare();
    int t = 1;
//    t = nxt();
    cin >> t;
    for (int i = 0; i < t; ++i) {
        solve(i + 1);
    }

    print_time("Time:");
    return 0;
}
