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

typedef struct Node {
    int id;
    struct Node *left, *right;
} Node;

// Function to create a new tree node
Node* newNode(int id) {
    Node* node = (Node*)malloc(sizeof(Node));
    node->id = id;
    node->left = node->right = NULL;
    return node;
}

// Function to find a node given id
Node* findNode(Node* root, int id) {
    if (!root || root->id == id)
        return root;
    Node* res = findNode(root->left, id);
    if (res) return res;
    return findNode(root->right, id);
}

// Insert nodes by id mapping
void insertNode(Node** nodes, int idx, int left, int right) {
    if (left != -1) nodes[idx]->left = nodes[left];
    if (right != -1) nodes[idx]->right = nodes[right];
}

// Find minimum node in the right subtree
Node* minValueNode(Node* node) {
    Node* current = node;
    while (current && current->left)
        current = current->left;
    return current;
}

// Remove a node and rebalance
Node* removeNode(Node* root, int key) {
    if (!root) return NULL;
    if (key < root->id)
        root->left = removeNode(root->left, key);
    else if (key > root->id)
        root->right = removeNode(root->right, key);
    else {
        // Node found
        if (!root->left) {
            Node* temp = root->right;
            free(root);
            return temp;
        } else if (!root->right) {
            Node* temp = root->left;
            free(root);
            return temp;
        }
        Node* temp = minValueNode(root->right);
        root->id = temp->id;
        root->right = removeNode(root->right, temp->id);
    }
    return root;
}

// In-order traversal print
void inorder(Node* root) {
    if (!root) return;
    inorder(root->left);
    printf("%d ", root->id);
    inorder(root->right);
}

int main() {
    int N;
    scanf("%d", &N);
    Node* nodes = {NULL};
    int id, left, right;

    for (int i = 0; i < N; ++i) {
        scanf("%d %d %d", &id[i], &left[i], &right[i]);
        nodes[id[i]] = newNode(id[i]);
    }
    for (int i = 0; i < N; ++i)
        insertNode(nodes, id[i], left[i], right[i]);

    int D;
    scanf("%d", &D);

    // Root assumed to be the first entered person
    Node* root = nodes[id];
    root = removeNode(root, D);
    inorder(root);
    return 0;
}