#include <cstdlib>
#include <fstream>

using namespace std;

ifstream cin ("hashuri.in");
ofstream cout ("hashuri.out");

int n;

inline int Random()  {
  return rand() % 128 + (1 << 7) * (rand() % 128) + (1 << 14) * (rand() % 128) + (1 << 21) * rand() % 128;
}

class TreapType {
public:
  int key, val, cnt;
  TreapType* lfSon;
  TreapType* rgSon;
  TreapType* parent;

  TreapType(int _val = 0, int _cnt = 0, int _key = Random(), TreapType* _lfSon = nullptr, TreapType* _rgSon = nullptr, TreapType* _parent = nullptr) {
    val = _val;
    cnt = _cnt;
    key = _key;
    lfSon = _lfSon;
    rgSon = _rgSon;
    parent = _parent;
  }

  bool find(int valSr) {
    if (val == valSr) {
      return true;
    }

    if (lfSon != nullptr and valSr < val) {
      return lfSon->find(valSr);
    }

    if (rgSon != nullptr and valSr > val) {
      return rgSon->find(valSr);
    }

    return false;
  }

  //rotate son in parameter
  inline void rotateTrig(TreapType*& currSon) {
    if (currSon->rgSon != nullptr and currSon->rgSon->lfSon != nullptr) {
      currSon->rgSon = currSon->rgSon->lfSon;
      currSon->rgSon->lfSon = currSon;
    } 

    if (currSon->rgSon != nullptr) {
      currSon = currSon->rgSon;
    }
  }

  //rotate son in parameter
  inline void rotateCounterTrig(TreapType*& currSon) {
    if (currSon->lfSon != nullptr and currSon->lfSon->rgSon != nullptr) {
      currSon->lfSon = currSon->lfSon->rgSon;
      currSon->lfSon->rgSon = currSon;
    }

    if (currSon->lfSon != nullptr) {
      currSon = currSon->lfSon;
    }
  }
};

TreapType* Rt;

void Insert(int valSr, TreapType* node = Rt) {
  if (node->val == valSr) {
    ++node->cnt;
    return;
  }

  if (node->lfSon != nullptr and valSr < node->val) {
    Insert(valSr, node->lfSon);
  }
  else if (node->rgSon != nullptr and valSr > node->val) {
    Insert(valSr, node->rgSon);
  }
  else if (valSr < node->val) {
    node->lfSon = new TreapType(valSr, 1);
    node->lfSon->parent = node;
  }
  else {
    node->rgSon = new TreapType(valSr, 1);
    node->rgSon->parent = node;

  }

  if (node->lfSon != nullptr and node->lfSon->key < node->key) {
    node->parent->rotateCounterTrig(node);
  }
  else if (node->rgSon != nullptr and node->rgSon->key <= node->key) {
    node->parent->rotateTrig(node);
  }
}

void DeleteNode(TreapType* node) {
  if (node->lfSon != nullptr and node->lfSon->key < node->rgSon->key) {
    node->parent->rotateCounterTrig(node);
    DeleteNode(node->rgSon);
  }
  else if (node->rgSon != nullptr and node->rgSon->key <= node->lfSon->key) {
    node->parent->rotateTrig(node);
    DeleteNode(node->lfSon);
  }
  else {
    delete node;
  }
}

void Erase(int valSr, TreapType* node = Rt) {
  if (node->val == valSr) {
    // --node->cnt;
    DeleteNode(node);
    return;
  }

  if (node->lfSon != nullptr and valSr < node->val) {
    Erase(valSr, node->lfSon);
  }
  else if (node->rgSon != nullptr and valSr > node->val) {
    Erase(valSr, node->rgSon);
  }
}

int main() {
  cin >> n;
  Rt = new TreapType;
  for (int i = 1; i <= n; ++i) {
    int type;
    cin >> type;
    if (type == 1) {
      int x;
      cin >> x;
      Insert(x);
    }
    else if (type == 2) {
      int x;
      cin >> x;
      Erase(x);
    }
    else {
      int x;
      cin >> x;
      cout << Rt->find(x) << '\n';
    }
  }
  return 0;
}