#include <cstdio>
#include <algorithm>
#include <vector>
#include <iostream>
#include <queue>
using namespace std;
struct TreeNode {
    int value;
    TreeNode *left, *right;
    TreeNode(const int x) :value(x), left(nullptr), right(nullptr) {}
};
TreeNode *root = nullptr
 
;
TreeNode* leftRotate(TreeNode *root) {//左旋
    TreeNode *temp = root->right;
    root->right = temp->left;
    temp->left = root;
    return temp;
}
TreeNode* rightRotate(TreeNode *root) {//右旋
    TreeNode *temp = root->left;
    root->left = temp->right;
    temp->right = root;
    return
 
 temp;
}
TreeNode* leftRightRotate(TreeNode *root) {////左子樹左旋，整棵樹右旋
    root->left = leftRotate(root->left);
    TreeNode *newRoot = rightRotate(root);
    return newRoot;
}
TreeNode* rightLeftRotate(TreeNode *root) {//右子樹右旋，整棵樹左旋
    root->right= rightRotate(root->right);
    TreeNode *newRoot = leftRotate(root);
    return
 
 newRoot;
}
int getHeight(TreeNode* node)//遞迴求該節點的高度
{
    if (node == nullptr)return 0;
    int left = getHeight(node->left);
    int right = getHeight(node->right);
    return max(left, right) + 1;
}
TreeNode* Insert(TreeNode* node, int insertNum)//二叉排序樹插入
{
    if(node == nullptr)
    {
        node = new TreeNode(insertNum);
    }else
    {
        if(node->value < insertNum)//右插
        {
            node->right = Insert(node->right, insertNum);//右插完之後獲取插完的根節點
            int leftH = getHeight(node->left);//插完之後，通過高度判斷這個節點是否平衡
            int rightH = getHeight(node->right);
            if (abs(rightH - leftH) >= 2)//開始旋轉達到平衡
            {
                if(insertNum > node->right->value)
                {
                    node = leftRotate(node);
                }else
                {
                    node = rightLeftRotate(node);
                }
            }
        }else//左插
        {
            node->left = Insert(node->left, insertNum);//左插完之後獲取插完的根節點
            int leftH = getHeight(node->left);//插完之後，通過高度判斷這個節點是否平衡
            int rightH = getHeight(node->right);
            if (abs(rightH - leftH) >= 2)//開始旋轉達到平衡
            {
                if (insertNum > node->left->value)
                {
                    node = leftRightRotate(node);
                }else
                {
                    node = rightRotate(node);
                }
            }
        }
    }
    return node;
}
using namespace std;
int main() {
    int N, inputNum;
    scanf_s("%d", &N);
    for (int i = 0; i < N; ++i) {
        scanf_s("%d", &inputNum);
        root = Insert(root, inputNum);
    }
    bool isACompletedTree = true;
    int nodeNum = 0;
    queue<TreeNode*>Q;
    Q.push(root);
    while (!Q.empty())//廣搜，判斷是否是完全二叉樹
    {
        TreeNode* popNode = Q.front();
        Q.pop();
        ++nodeNum;
        if (isACompletedTree && popNode->left != nullptr)
            Q.push(popNode->left);
        else
            isACompletedTree = false;
        if (isACompletedTree && popNode->right != nullptr)
            Q.push(popNode->right);
        else
            isACompletedTree = false;
    }
    vector<int>result;
    queue<TreeNode*>QQ;
    QQ.push(root);
    while (!QQ.empty())//廣搜，每層節點
    {
        TreeNode* popNode = QQ.front();
        QQ.pop();
        result.push_back(popNode->value);
        if (popNode->left != nullptr)
            QQ.push(popNode->left);
        if (popNode->right != nullptr)
            QQ.push(popNode->right);
    }
    for (int i = 0; i < result.size() - 1; ++i)
        cout << result[i] << " ";
    cout << result[result.size() - 1] << endl;
    if (nodeNum == N)
        printf("YES\n");
    else
        printf("NO\n");
}