#include <iostream>
#include <vector>
#include <cstring>
#include <cmath>

struct Node {
    int value;
    int height = 1;
    Node* left = nullptr;
    Node* right = nullptr;
};

class AVL {
private:


public:
    Node* head = nullptr;
    int Height(Node* x){
        if(x == nullptr){
            return 0;
        }
        return x->height;
    }


    void fixHeight(Node* x){
        if(x == nullptr){
            return;
        }
        x->height = std::max(Height(x->left), Height(x->right)) + 1;
    }

    int CheckBalance(Node* x){
        if(x == nullptr){
            return 0;
        }
        return Height(x->right) - Height(x->left);
    }



    Node* RotateRight(Node* x){
        Node* y = x->left;
        x->left = y->right;
        y->right = x;
        fixHeight(x);
        fixHeight(y);
        return y;
    }

    Node* RotateLeft(Node* x){
        Node* y = x->right;
        x->right = y->left;
        y->left = x;
        fixHeight(x);
        fixHeight(y);
        return y;
    }

    Node* BalanceTree(Node* x){
        fixHeight(x);
        if(CheckBalance(x) == 2){
            if(CheckBalance(x->right) < 0){
                x->right = RotateRight(x->right);
            }
            return RotateLeft(x);
        }
        if(CheckBalance(x) == -2){
            if(CheckBalance(x->left) > 0){
                x->left = RotateLeft(x->left);
            }
            return RotateRight(x);
        }
        return x;
    }
    Node* Insert(Node* x, int value){
        if(x == nullptr){
            x = new Node;
            x->value = value;
            return x;
        }
        else if(x->value > value){
            x->left = Insert(x->left, value);
        }
        else if( x-> value < value){
            x->right = Insert(x->right, value);
        }
        return BalanceTree(x);
    }

    bool Exists(int value){
        if(head == nullptr){
            return false;
        }
        Node* head_copy = head;
        while(head_copy != nullptr){
            if(value == head_copy->value){
                return true;
            }
            else if(head_copy->value > value){
                head_copy = head_copy->left;
            }
            else{
                head_copy = head_copy->right;
            }
        }
        return false;
    }


    Node* remove(int value, Node* head) {
        if (head->value > value) {
            head->left = remove(value, head->left);
        } else if (head->value < value) {
            head->right = remove(value, head->right);
        } else {
            if (head->left == nullptr && head->right == nullptr) {
                delete head;
                return nullptr;
            }

            if (head->left == nullptr && head->right != nullptr) {
                Node* temp = head->right;
                delete head;
                return temp;
            }

            if (head->left != nullptr && head->right == nullptr) {
                Node* temp = head->left;
                delete head;
                return temp;
            }

            // Если осталось два ребенка

            Node* max_deleted = head->left;

            head->height--;

            if (head->left->right == nullptr) {
                head->left->height--;
            }


            while (max_deleted->right != nullptr) {
                max_deleted->height--;
                max_deleted = max_deleted;
            }

            std::swap(head->value, max_deleted->value);
            head->left = remove(max_deleted->value, head->left);

        }

        return BalanceTree(head);

    }
};






int main() {

    int n;
    std::cin >> n;
    AVL avl_tree;

    while (n--) {
        char c;
        int i;

        std::cin >> c >> i;

        switch(c){
            case 'A':
                if (avl_tree.Exists(i)) {
                    break;
                }
                avl_tree.head = avl_tree.Insert(avl_tree.head, i);
                std::cout << avl_tree.CheckBalance(avl_tree.head) << '\n';
                break;
            case 'D':
                if (!avl_tree.Exists(i)) {
                    break;
                }

                avl_tree.head = avl_tree.remove(i, avl_tree.head);
                std::cout << avl_tree.CheckBalance(avl_tree.head) << '\n';
                break;
            case 'C':
                std::cout << (avl_tree.Exists(i) ? 'Y' : 'N') << '\n';
                break;
        }
    }


}