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

typedef struct Node {
    int val;
    struct Node* left;
    struct Node* right;
} Node;

Node* createNode(int val) {
    if (val == -1) return NULL;
    Node* newNode = (Node*)malloc(sizeof(Node));
    newNode->val = val;
    newNode->left = NULL;
    newNode->right = NULL;
    return newNode;
}

// Queue for level-order construction
typedef struct Queue {
    Node* data[100];
    int front, rear;
} Queue;

void enqueue(Queue* q, Node* node) {
    if (node != NULL)
        q->data[q->rear++] = node;
}

Node* dequeue(Queue* q) {
    return q->data[q->front++];
}

int isEmpty(Queue* q) {
    return q->front == q->rear;
}

void findLeaves(Node* root) {
    if (!root) return;
    if (root->left == NULL && root->right == NULL) {
        printf("%d ", root->val);
        return;
    }
    findLeaves(root->left);
    findLeaves(root->right);
}

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

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

    if (values[0] == -1) {
        printf("Invalid input\n");
        return 0;
    }

    Node* root = createNode(values[0]);
    Queue q = { .front = 0, .rear = 0 };
    enqueue(&q, root);

    int idx = 1;
    while (!isEmpty(&q) && idx < N) {
        Node* current = dequeue(&q);
        if (idx < N) {
            current->left = createNode(values[idx++]);
            enqueue(&q, current->left);
        }
        if (idx < N) {
            current->right = createNode(values[idx++]);
            enqueue(&q, current->right);
        }
    }

    if (idx != N) {
        printf("Invalid input\n");
        return 0;
    }

    findLeaves(root);
    return 0;
}
// editor1
#include <stdio.h>
#include <stdlib.h>

typedef struct Node {
    int val;
    struct Node* left;
    struct Node* right;
} Node;

Node* createNode(int val) {
    if (val == -1) return NULL;
    Node* newNode = (Node*)malloc(sizeof(Node));
    newNode->val = val;
    newNode->left = NULL;
    newNode->right = NULL;
    return newNode;
}

// Queue for level-order construction
typedef struct Queue {
    Node* data[100];
    int front, rear;
} Queue;

void enqueue(Queue* q, Node* node) {
    if (node != NULL)
        q->data[q->rear++] = node;
}

Node* dequeue(Queue* q) {
    return q->data[q->front++];
}

int isEmpty(Queue* q) {
    return q->front == q->rear;
}

void findLeaves(Node* root) {
    if (!root) return;
    if (root->left == NULL && root->right == NULL) {
        printf("%d ", root->val);
        return;
    }
    findLeaves(root->left);
    findLeaves(root->right);
}

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

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

    if (values[0] == -1) {
        printf("Invalid input\n");
        return 0;
    }

    Node* root = createNode(values[0]);
    Queue q = { .front = 0, .rear = 0 };
    enqueue(&q, root);

    int idx = 1;
    while (!isEmpty(&q) && idx < N) {
        Node* current = dequeue(&q);
        if (idx < N) {
            current->left = createNode(values[idx++]);
            enqueue(&q, current->left);
        }
        if (idx < N) {
            current->right = createNode(values[idx++]);
            enqueue(&q, current->right);
        }
    }

    if (idx != N) {
        printf("Invalid input\n");
        return 0;
    }

    findLeaves(root);
    return 0;
}