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

typedef struct {
    int* parent;
    int* locked;  // -1 means unlocked, otherwise user_id
    int n;
} LockingTree;

LockingTree* lockingTreeCreate(int* parent, int parentSize) {
    LockingTree* obj = (LockingTree*)malloc(sizeof(LockingTree));
    obj->parent = (int*)malloc(parentSize * sizeof(int));
    obj->locked = (int*)malloc(parentSize * sizeof(int));
    obj->n = parentSize;
    
    for (int i = 0; i < parentSize; i++) {
        obj->parent[i] = parent[i];
        obj->locked[i] = -1;
    }
    
    return obj;
}

bool lockingTreeLock(LockingTree* obj, int num, int user) {
    if (obj->locked[num] != -1) {
        return false;
    }
    obj->locked[num] = user;
    return true;
}

bool lockingTreeUnlock(LockingTree* obj, int num, int user) {
    if (obj->locked[num] != user) {
        return false;
    }
    obj->locked[num] = -1;
    return true;
}

bool isDescendant(LockingTree* obj, int node, int ancestor) {
    int curr = node;
    while (obj->parent[curr] != -1) {
        curr = obj->parent[curr];
        if (curr == ancestor) {
            return true;
        }
    }
    return false;
}

bool lockingTreeUpgrade(LockingTree* obj, int num, int user) {
    // Check if node is unlocked
    if (obj->locked[num] != -1) {
        return false;
    }
    
    // Check if any ancestor is locked
    int curr = num;
    while (obj->parent[curr] != -1) {
        curr = obj->parent[curr];
        if (obj->locked[curr] != -1) {
            return false;
        }
    }
    
    // Find all descendants and check if any are locked
    int descendants[1000];
    int descendantCount = 0;
    bool hasLockedDescendant = false;
    
    for (int i = 0; i < obj->n; i++) {
        if (isDescendant(obj, i, num) && obj->locked[i] != -1) {
            descendants[descendantCount++] = i;
            hasLockedDescendant = true;
        }
    }
    
    if (!hasLockedDescendant) {
        return false;
    }
    
    // Unlock all descendants and lock current node
    for (int i = 0; i < descendantCount; i++) {
        obj->locked[descendants[i]] = -1;
    }
    obj->locked[num] = user;
    return true;
}

LockingTree* solution(int* parent, int parentSize) {
    return lockingTreeCreate(parent, parentSize);
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    line[strcspn(line, "\n")] = 0;
    
    // Simple array parsing
    int parent[1000];
    int size = 0;
    char* token = strtok(line + 1, ",]");
    while (token != NULL) {
        parent[size++] = atoi(token);
        token = strtok(NULL, ",]");
    }
    
    LockingTree* lt = lockingTreeCreate(parent, size);
    printf("LockingTree initialized\n");
    return 0;
}