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

// Definition for binary tree node
typedef struct Node {
    int data;
    struct Node* left;
    struct Node* right;
} Node;

// Queue for level order construction
typedef struct Queue {
    Node** arr;
    int front, rear, size, cap;
} Queue;

Queue* createQueue(int cap) {
    Queue* q = (Queue*)malloc(sizeof(Queue));
    q->arr = (Node**)malloc(sizeof(Node*) * cap);
    q->front = q->rear = q->size = 0;
    q->cap = cap;
    return q;
}
void enqueue(Queue* q, Node* node) {
    if (q->size < q->cap) {
        q->arr[q->rear++] = node;
        q->size++;
    }
}
Node* dequeue(Queue* q) {
    if (q->size == 0) return NULL;
    q->size--;
    return q->arr[q->front++];
}
int isEmpty(Queue* q) {
    return q->size == 0;
}
void freeQueue(Queue* q) {
    free(q->arr);
    free(q);
}

// Function to build tree from level order input
Node* buildTree(int* arr, int n) {
    if (n == 0 || arr == -1) return NULL;
    Node* root = (Node*)malloc(sizeof(Node));
    root->data = arr;
    root->left = root->right = NULL;
    Queue* q = createQueue(n);
    enqueue(q, root);
    int i = 1;
    while (!isEmpty(q) && i < n) {
        Node* curr = dequeue(q);
        if (arr[i] != -1) {
            curr->left = (Node*)malloc(sizeof(Node));
            curr->left->data = arr[i];
            curr->left->left = curr->left->right = NULL;
            enqueue(q, curr->left);
        }
        i++;
        if (i < n && arr[i] != -1) {
            curr->right = (Node*)malloc(sizeof(Node));
            curr->right->data = arr[i];
            curr->right->left = curr->right->right = NULL;
            enqueue(q, curr->right);
        }
        i++;
    }
    freeQueue(q);
    return root;
}

// Helper to check if tree is balanced and calculate height
int isBalancedUtil(Node* root, int* balanced) {
    if (!root) return 0;
    int left = isBalancedUtil(root->left, balanced);
    int right = isBalancedUtil(root->right, balanced);
    if (abs(left - right) > 1) *balanced = 0; // Math.abs usage as required
    return 1 + (left > right ? left : right);
}

// Driver function
int main() {
    int n;
    scanf("%d", &n);
    int* arr = (int*)malloc(sizeof(int)*n);
    for (int i = 0; i < n; ++i) scanf("%d", &arr[i]);
    Node* root = buildTree(arr, n);
    int balanced = 1;
    isBalancedUtil(root, &balanced);
    if (balanced) printf("Balanced\n");
    else printf("Not Balanced\n");
    free(arr);
    return 0;
}