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

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

// Utility to create new node
Node* newNode(int data) {
    Node* node = (Node*)malloc(sizeof(Node));
    node->data = data;
    node->left = node->right = NULL;
    return node;
}

// Build balanced BST from sorted array
Node* buildBalancedBST(int arr[], int start, int end) {
    if (start > end) return NULL;

    int mid = (start + end) / 2;
    Node* root = newNode(arr[mid]);

    root->left = buildBalancedBST(arr, start, mid - 1);
    root->right = buildBalancedBST(arr, mid + 1, end);

    return root;
}

// Print BST in required format
void printTree(Node* root) {
    if (!root) return;
    int left = (root->left) ? root->left->data : -1;
    int right = (root->right) ? root->right->data : -1;
    printf("%d %d %d\n", root->data, left, right);
    printTree(root->left);
    printTree(root->right);
}

// Check duplicates in sorted array
int hasDuplicates(int arr[], int n) {
    for (int i = 1; i < n; i++) {
        if (arr[i] == arr[i-1]) return 1;
    }
    return 0;
}

// Comparator for qsort
int cmpfunc(const void *a, const void *b) {
    return ((int)a - (int)b);
}

int main() {
    int N;
    if (scanf("%d", &N) != 1 || N <= 0) {
        printf("Invalid Input\n");
        return 0;
    }

    int arr[N];
    for (int i = 0; i < N; i++) {
        if (scanf("%d", &arr[i]) != 1) {
            printf("Invalid Input\n");
            return 0;
        }
    }

    int R;
    if (scanf("%d", &R) != 1) {
        printf("Invalid Input\n");
        return 0;
    }

    // Find R
    int found = 0;
    int newArr[N-1], idx = 0;
    for (int i = 0; i < N; i++) {
        if (arr[i] == R) {
            found = 1;
            continue;
        }
        newArr[idx++] = arr[i];
    }

    if (!found) {
        printf("Invalid Input\n");
        return 0;
    }

    // Sort remaining
    qsort(newArr, N-1, sizeof(int), cmpfunc);

    // Check duplicates
    if (hasDuplicates(newArr, N-1)) {
        printf("Invalid Input\n");
        return 0;
    }

    // Build balanced BST
    Node* root = buildBalancedBST(newArr, 0, N-2);

    // Print result
    printTree(root);

    return 0;
}