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

const int NMAX = 2005,
           NIL = -1,
           MOD =(1<<17) - 1;

class InParser {
private:
    FILE *fin;
    char *buff;
    int sp;

    char read_ch() {
        ++sp;
        if (sp == 4096) {
            sp = 0;
            fread(buff, 1, 4096, fin);
        }
        return buff[sp];
    }

public:
    InParser(const char* nume) {
        fin = fopen(nume, "r");
        buff = new char[4096]();
        sp = 4095;
    }

    InParser& operator >> (int &n) {
        char c;
        while (!isdigit(c = read_ch()) && c != '-');
        int sgn = 1;
        if (c == '-') {
            n = 0;
            sgn = -1;
        } else {
            n = c - '0';
        }
        while (isdigit(c = read_ch())) {
            n = 10 * n + c - '0';
        }
        n *= sgn;
        return *this;
    }

    InParser& operator >> (long long &n) {
        char c;
        n = 0;
        while (!isdigit(c = read_ch()) && c != '-');
        long long sgn = 1;
        if (c == '-') {
            n = 0;
            sgn = -1;
        } else {
            n = c - '0';
        }
        while (isdigit(c = read_ch())) {
            n = 10 * n + c - '0';
        }
        n *= sgn;
        return *this;
    }
};

struct LL {
    int val, nxt;
};

int buff;
int  fst[MOD],
     lst[MOD],
      v[NMAX];
LL pile[NMAX];

void hclear(void) {
    buff = 0;
    memset(fst, 0xff, sizeof(fst));
}

void hput(int arg) {
    int b = arg % MOD;

    if(fst[b] == NIL) {
        fst[b] = buff;
        lst[b] = buff;

        pile[buff].nxt = NIL;
        pile[buff].val = arg;
        ++buff;
    }
    else {
        pile[lst[b]].nxt = buff;

        pile[buff].nxt = NIL;
        pile[buff].val = arg;
        ++buff;
    }
}

bool hfind(int arg) {
    int b = arg % MOD,
        c = fst[b];

    while(c!=NIL) {
        if(pile[c].val==arg)
            return true;
        else
            c = pile[c].nxt;
    }

    return false;
}

int main(void) {
    InParser fi("progr.in");
    ofstream fo("progr.out");
    int tsk, ant, n, t;

    fi>>tsk;
    while(tsk--) {
        hclear();

        fi>>n;#include <cstdio>
#include <vector>
using namespace std;

const int MOD = 99991;

vector<int> v[MOD];
FILE *fi = fopen("hashuri.in","r");
FILE *fo = fopen("hashuri.out","w");

inline void insert(int arg) {
    int p = arg % MOD;
    for(int i=0; i<v[p].size(); ++i)
        if(v[p][i]==arg)
            return;
    v[p].push_back(arg);
}

inline void remove(int arg) {
    int p = arg % MOD;
    for(int i=0; i<v[p].size(); ++i) {
        if(v[p][i]==arg) {
            v[p][i] = v[p].back();
            v[p].pop_back();
            return;
        }
    }
}

inline void query(int arg) {
    int p = arg % MOD;
    for(int i=0; i<v[p].size(); ++i) {
        if(v[p][i]==arg) {
            fprintf(fo,"1\n");
            return;
        }
    }
    fprintf(fo,"0\n");
}

int main(void) {
    int q, tsk, arg;

    fscanf(fi,"%d",&q);
    while(q--) {
        fscanf(fi,"%d%d",&tsk,&arg);
        switch(tsk) {
        case 1:
            insert(arg);
            break;
        case 2:
            remove(arg);
            break;
        case 3:
            query(arg);
            break;
        }
    }
    return 0;
}
        for(int i=0; i<n; ++i) {
            fi>>v[i];
            hput(v[i]);
        }
        sort(v, v+n);

        ant = 0;
        for(int i=0;   i<n;  ++i)
        for(int j=i-1; j>=0; --j)
            if(!hfind(v[i]+v[i]-v[j]))
                ++ant;

        fo<<ant<<'\n';
    }

    return 0;
}