#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <string.h>
#include <ctype.h>

#define MAX_LEVEL 16

typedef struct SkipListNode {
    int val;
    struct SkipListNode** forward;
} SkipListNode;

typedef struct {
    int level;
    SkipListNode* header;
} Skiplist;

SkipListNode* createNode(int val, int level) {
    SkipListNode* node = (SkipListNode*)malloc(sizeof(SkipListNode));
    node->val = val;
    node->forward = (SkipListNode**)calloc(level + 1, sizeof(SkipListNode*));
    return node;
}

int randomLevel() {
    int level = 0;
    while ((rand() & 1) && level < MAX_LEVEL) {
        level++;
    }
    return level;
}

Skiplist* skiplistCreate() {
    Skiplist* obj = (Skiplist*)malloc(sizeof(Skiplist));
    obj->level = 0;
    obj->header = createNode(-1, MAX_LEVEL);
    return obj;
}

bool skiplistSearch(Skiplist* obj, int target) {
    SkipListNode* current = obj->header;
    for (int i = obj->level; i >= 0; i--) {
        while (current->forward[i] && current->forward[i]->val < target) {
            current = current->forward[i];
        }
    }
    current = current->forward[0];
    return current && current->val == target;
}

void skiplistAdd(Skiplist* obj, int num) {
    SkipListNode* update[MAX_LEVEL + 1];
    SkipListNode* current = obj->header;
    for (int i = obj->level; i >= 0; i--) {
        while (current->forward[i] && current->forward[i]->val < num) {
            current = current->forward[i];
        }
        update[i] = current;
    }
    int newLevel = randomLevel();
    if (newLevel > obj->level) {
        for (int i = obj->level + 1; i <= newLevel; i++) {
            update[i] = obj->header;
        }
        obj->level = newLevel;
    }
    SkipListNode* newNode = createNode(num, newLevel);
    for (int i = 0; i <= newLevel; i++) {
        newNode->forward[i] = update[i]->forward[i];
        update[i]->forward[i] = newNode;
    }
}

bool skiplistErase(Skiplist* obj, int num) {
    SkipListNode* update[MAX_LEVEL + 1];
    SkipListNode* current = obj->header;
    for (int i = obj->level; i >= 0; i--) {
        while (current->forward[i] && current->forward[i]->val < num) {
            current = current->forward[i];
        }
        update[i] = current;
    }
    current = current->forward[0];
    if (current && current->val == num) {
        for (int i = 0; i <= obj->level; i++) {
            if (update[i]->forward[i] != current) break;
            update[i]->forward[i] = current->forward[i];
        }
        while (obj->level > 0 && !obj->header->forward[obj->level]) {
            obj->level--;
        }
        free(current->forward);
        free(current);
        return true;
    }
    return false;
}

void skiplistFree(Skiplist* obj) {
    SkipListNode* current = obj->header;
    while (current) {
        SkipListNode* temp = current;
        current = current->forward[0];
        free(temp->forward);
        free(temp);
    }
    free(obj);
}

/* ---- stdin parsing helpers ---- */

/* Parse array of strings from JSON array like ["Skiplist","add","add","search"] */
int parseOps(const char* line, char ops[][32], int maxOps) {
    int count = 0;
    const char* p = line;
    while (*p && count < maxOps) {
        if (*p == '"') {
            p++;
            int i = 0;
            while (*p && *p != '"' && i < 31) ops[count][i++] = *p++;
            ops[count][i] = '\0';
            count++;
            if (*p == '"') p++;
        } else {
            p++;
        }
    }
    return count;
}

/* Parse array of arrays like [[],[1],[2],[0]] into flat int params and a count per entry */
int parseParams(const char* line, int params[][2], int* paramCounts, int maxEntries) {
    int count = 0;
    const char* p = line;
    /* skip outer [ */
    while (*p && *p != '[') p++;
    if (*p == '[') p++;

    while (*p && count < maxEntries) {
        /* find inner [ */
        while (*p && *p != '[' && *p != ']') p++;
        if (*p == ']') break; /* end of outer array */
        if (*p == '[') {
            p++; /* skip inner [ */
            paramCounts[count] = 0;
            while (*p && *p != ']') {
                while (*p && !isdigit((unsigned char)*p) && *p != '-' && *p != ']') p++;
                if (*p == ']') break;
                if (isdigit((unsigned char)*p) || *p == '-') {
                    char* end;
                    params[count][paramCounts[count]] = (int)strtol(p, &end, 10);
                    paramCounts[count]++;
                    p = end;
                }
            }
            if (*p == ']') p++;
            count++;
        }
    }
    return count;
}

int main() {
    /* Fixed seed for deterministic behavior */
    srand(42);

    static char opsLine[4096];
    static char valsLine[4096];

    if (!fgets(opsLine, sizeof(opsLine), stdin)) return 1;
    if (!fgets(valsLine, sizeof(valsLine), stdin)) return 1;

    static char ops[256][32];
    int opCount = parseOps(opsLine, ops, 256);

    static int params[256][2];
    static int paramCounts[256];
    int paramCount = parseParams(valsLine, params, paramCounts, 256);

    if (opCount == 0 || paramCount == 0) return 1;

    Skiplist* obj = NULL;
    printf("[");

    for (int i = 0; i < opCount; i++) {
        if (i > 0) printf(",");
        if (strcmp(ops[i], "Skiplist") == 0) {
            obj = skiplistCreate();
            printf("null");
        } else if (strcmp(ops[i], "add") == 0) {
            skiplistAdd(obj, params[i][0]);
            printf("null");
        } else if (strcmp(ops[i], "search") == 0) {
            printf("%s", skiplistSearch(obj, params[i][0]) ? "true" : "false");
        } else if (strcmp(ops[i], "erase") == 0) {
            printf("%s", skiplistErase(obj, params[i][0]) ? "true" : "false");
        }
    }

    printf("]\n");

    if (obj) skiplistFree(obj);
    return 0;
}