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

// Define the Node structure
typedef struct Node {
    int data;
    struct Node *left;
    struct Node *right;
} Node;

// Function to create a new node
Node* createNode(int data) {
    Node* newNode = (Node*)malloc(sizeof(Node));
    if (newNode == NULL) {
        fprintf(stderr, "Memory allocation failed\n");
        exit(1);
    }
    newNode->data = data;
    newNode->left = NULL;
    newNode->right = NULL;
    return newNode;
}

// Function to build the binary tree from level order traversal
Node* buildTree(int arr[], int n) {
    if (n == 0 || arr[0] == -1) {
        return NULL;
    }

    Node* root = createNode(arr[0]);
    Node** queue = (Node*)malloc(sizeof(Node) * n);
    if (queue == NULL) {
        fprintf(stderr, "Memory allocation failed\n");
        exit(1);
    }
    int front = 0, rear = 0;
    queue[rear++] = root;

    int i = 1;
    while (front < rear && i < n) {
        Node* current = queue[front++];

        if (i < n && arr[i] != -1) {
            current->left = createNode(arr[i]);
            queue[rear++] = current->left;
        }
        i++;

        if (i < n && arr[i] != -1) {
            current->right = createNode(arr[i]);
            queue[rear++] = current->right;
        }
        i++;
    }
    free(queue);
    return root;
}

// Function to check if two subtrees are mirror images
int isMirror(Node* node1, Node* node2) {
    if (node1 == NULL && node2 == NULL) {
        return 1;
    }

    if (node1 == NULL || node2 == NULL || node1->data != node2->data) {
        return 0;
    }

    return isMirror(node1->left, node2->right) && isMirror(node1->right, node2->left);
}

// Function to check if a binary tree is symmetric
int isSymmetric(Node* root) {
    if (root == NULL) {
        return 1;
    }
    return isMirror(root->left, root->right);
}

// Function to free tree memory (optional but good practice)
void freeTree(Node* root) {
    if (root == NULL) {
        return;
    }
    freeTree(root->left);
    freeTree(root->right);
    free(root);
}

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

    int arr = (int)malloc(sizeof(int) * n);
    if (arr == NULL) {
        fprintf(stderr, "Memory allocation failed\n");
        return 1;
    }

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

    Node* root = buildTree(arr, n);

    if (isSymmetric(root)) {
        printf("Symmetric\n");
    } else {
        printf("Not Symmetric\n");
    }

    freeTree(root); // Free allocated memory
    free(arr);
    return 0;
}