#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>
#include <cjson/cjson.h>

struct TreeNode {
    int val;
    struct TreeNode* left;
    struct TreeNode* right;
};

typedef struct {
    struct TreeNode** stack;
    int top;
    int capacity;
} BSTIterator;

void pushLeft(BSTIterator* obj, struct TreeNode* node) {
    while (node) {
        obj->stack[++(obj->top)] = node;
        node = node->left;
    }
}

BSTIterator* bSTIteratorCreate(struct TreeNode* root) {
    BSTIterator* obj = (BSTIterator*)malloc(sizeof(BSTIterator));
    obj->stack = (struct TreeNode**)malloc(10000 * sizeof(struct TreeNode*));
    obj->top = -1;
    obj->capacity = 10000;
    
    pushLeft(obj, root);
    return obj;
}

int bSTIteratorNext(BSTIterator* obj) {
    struct TreeNode* node = obj->stack[obj->top--];
    pushLeft(obj, node->right);
    return node->val;
}

bool bSTIteratorHasNext(BSTIterator* obj) {
    return obj->top >= 0;
}

struct TreeNode* buildTree(cJSON* arr) {
    if (!arr || !cJSON_IsArray(arr) || cJSON_GetArraySize(arr) == 0) {
        return NULL;
    }
    
    cJSON* first = cJSON_GetArrayItem(arr, 0);
    if (!first || cJSON_IsNull(first)) {
        return NULL;
    }
    
    struct TreeNode* root = (struct TreeNode*)malloc(sizeof(struct TreeNode));
    root->val = first->valueint;
    root->left = root->right = NULL;
    
    struct TreeNode** queue = (struct TreeNode**)malloc(10000 * sizeof(struct TreeNode*));
    int front = 0, rear = 0;
    queue[rear++] = root;
    
    int i = 1;
    int size = cJSON_GetArraySize(arr);
    
    while (front < rear && i < size) {
        struct TreeNode* node = queue[front++];
        
        if (i < size) {
            cJSON* item = cJSON_GetArrayItem(arr, i);
            if (item && !cJSON_IsNull(item)) {
                node->left = (struct TreeNode*)malloc(sizeof(struct TreeNode));
                node->left->val = item->valueint;
                node->left->left = node->left->right = NULL;
                queue[rear++] = node->left;
            }
            i++;
        }
        
        if (i < size) {
            cJSON* item = cJSON_GetArrayItem(arr, i);
            if (item && !cJSON_IsNull(item)) {
                node->right = (struct TreeNode*)malloc(sizeof(struct TreeNode));
                node->right->val = item->valueint;
                node->right->left = node->right->right = NULL;
                queue[rear++] = node->right;
            }
            i++;
        }
    }
    
    free(queue);
    return root;
}

int main() {
    char line1[1000], line2[1000];
    fgets(line1, sizeof(line1), stdin);
    fgets(line2, sizeof(line2), stdin);
    
    cJSON* commands = cJSON_Parse(line1);
    cJSON* values = cJSON_Parse(line2);
    
    cJSON* result = cJSON_CreateArray();
    BSTIterator* iterator = NULL;
    
    int cmdCount = cJSON_GetArraySize(commands);
    for (int i = 0; i < cmdCount; i++) {
        cJSON* cmd = cJSON_GetArrayItem(commands, i);
        char* cmdStr = cmd->valuestring;
        
        if (strcmp(cmdStr, "BSTIterator") == 0) {
            cJSON* valArray = cJSON_GetArrayItem(values, i);
            cJSON* treeArray = cJSON_GetArrayItem(valArray, 0);
            struct TreeNode* root = buildTree(treeArray);
            iterator = bSTIteratorCreate(root);
            cJSON_AddItemToArray(result, cJSON_CreateNull());
        } else if (strcmp(cmdStr, "next") == 0) {
            int val = bSTIteratorNext(iterator);
            cJSON_AddItemToArray(result, cJSON_CreateNumber(val));
        } else if (strcmp(cmdStr, "hasNext") == 0) {
            bool has = bSTIteratorHasNext(iterator);
            cJSON_AddItemToArray(result, cJSON_CreateBool(has));
        }
    }
    
    char* output = cJSON_Print(result);
    printf("%s\n", output);
    
    free(output);
    cJSON_Delete(commands);
    cJSON_Delete(values);
    cJSON_Delete(result);
    
    return 0;
}