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

#define MAX 10000
struct Node {
    int data;
    struct Node *left, *right;
};
struct Queue {
    struct Node* arr[MAX];
    int front, rear;
};

void initQueue(struct Queue* q) {
    q->front = q->rear = 0;
}

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

void enqueue(struct Queue* q, struct Node* node) {
    q->arr[q->rear++] = node;
}

struct Node* dequeue(struct Queue* q) {
    return q->arr[q->front++];
}
struct Node* newNode(int data) {
    if (data == -1) return NULL;
    struct Node* node = (struct Node*)malloc(sizeof(struct Node));
    node->data = data;
    node->left = node->right = NULL;
    return node;
}

struct Node* buildTree(int arr[], int n) {
    if (n == 0 || arr[0] == -1) return NULL;

    struct Node* root = newNode(arr[0]);
    struct Queue q;
    initQueue(&q);
    enqueue(&q, root);

    int i = 1;
    while (i < n && !isEmpty(&q)) {
        struct Node* curr = dequeue(&q);
        if (curr != NULL) {
            if (i < n) {
                curr->left = newNode(arr[i++]);
                if (curr->left) enqueue(&q, curr->left);
            }
            if (i < n) {
                curr->right = newNode(arr[i++]);
                if (curr->right) enqueue(&q, curr->right);
            }
        }
    }
    return root;
}

/
int checkHeight(struct Node* root) {
    if (!root) return 0;

    int left = checkHeight(root->left);
    if (left == -1) return -1;

    int right = checkHeight(root->right);
    if (right == -1) return -1;

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

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

int main() {
    int n;
    scanf("%d", &n);

    int arr[n];
    for (int i = 0; i < n; i++) scanf("%d", &arr[i]);

    struct Node* root = buildTree(arr, n);

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

    return 0;
}