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

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

// Queue structure for level order tree creation
typedef struct Queue {
    TreeNode** data;
    int front, rear, size;
} Queue;

Queue* createQueue(int size) {
    Queue* q = (Queue*)malloc(sizeof(Queue));
    q->data = (TreeNode*)malloc(sizeof(TreeNode) * size);
    q->front = q->rear = 0;
    q->size = size;
    return q;
}

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

void enqueue(Queue* q, TreeNode* node) {
    if (q->rear < q->size)
        q->data[q->rear++] = node;
}

TreeNode* dequeue(Queue* q) {
    if (!isEmpty(q))
        return q->data[q->front++];
    return NULL;
}

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

// Return -1 if not balanced, otherwise return height
int checkBalanced(TreeNode* root) {
    if (!root) return 0;
    int left = checkBalanced(root->left);
    if (left == -1) return -1;
    int right = checkBalanced(root->right);
    if (right == -1) return -1;

    if (abs(left - right) > 1) return -1;

    return 1 + (left > right ? left : right);
}

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

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

    TreeNode* root = newNode(values[0]);
    Queue* q = createQueue(n);
    enqueue(q, root);

    int i = 1;
    while (i < n && !isEmpty(q)) {
        TreeNode* curr = dequeue(q);
        if (curr) {
            curr->left = (i < n) ? newNode(values[i++]) : NULL;
            if (curr->left) enqueue(q, curr->left);
            curr->right = (i < n) ? newNode(values[i++]) : NULL;
            if (curr->right) enqueue(q, curr->right);
        }
    }

    if (checkBalanced(root) != -1)
        printf("Balanced\n");
    else
        printf("Not Balanced\n");

    return 0;
}