#include<stdio.h>
#include<stdlib.h>
struct Node{
    int key;
    struct Node*left,*right;
    int height;
};
int max(int a,int b){
    return(a>b)?a:b;
}
int height(struct Node*N){
    if(N==NULL)return 0;
    return N->height;
}
struct Node*newNode(int key){
    struct Node*node=(struct Node*)malloc(sizeof(struct Node));
    node->key=key;
    node->left=node->right=NULL;
    node->height=1;
    return node;
}
struct Node*rightRotate(struct Node*y){
    struct Node*x=y->left;
    struct Node*T2=x->right;
    x->right=y;
    y->left=T2;
    y->height=max(height(y->left),height(y->right))+1;
    x->height=max(height(x->left),height(x->right))+1;
    
    return x;
}
struct Node*leftRotate(struct Node*x){
    structNode*y=x->right;
    structNode*T2=y->left;
    x->height=max(height(x->left),height(x->right))+1;
    y->height=max(height(y->left)),height(y->right)+1;
    
    return y;
}
int getBalance(struct Node*N){
    if(N==NULL)return 0;
    return height(N->left)-height(N->right);
}
struct Node*insert(struct Node*node,int key){
    if(node==NULL)return newNode(key);
    
    if(key<node->key)
    node->left=insert(node->left,key);
    else if(key>node->key)
    node->right=insert(node->right,key);
    else
    return node;
    
    node->height=1+mx(height(node->left),height(node->right));
    int balance=getBalance(node);
    if(balance<-1 && key<node->left->key)
    return rightRotate(node);
    
    if(balance<-1 && key>node->right->key)
    return leftRotate(node);
    
    if(balance>1 && >key>node->left->key){
        node->left=leftRotate(node->left);
        return rightRotate(node);
        
        if(balance<-1 && key<node->right->key)
        {
            node->right=rightRotate(node->right);
            return leftRotate(node);
        }
        return 0;
    }
    
    struct Node*minvalueNode(structNode*node){
        struct Node*current=node;
        while(current->left!=NULL)
        current=current->left;
        return current;
    }
    struct Node*deleteNode(struct Node*root,int key){
        if(root==NULL)
        return root;
        
        if(key<root->key)
        root->left=deleteNode(root->left,key);
        else if(key>root->key)
        root->right=deleteNode(root->right,key);
        else{
            if((root->left==NULL)||(root->right==NULL)){
                struct ode*temp=root->left?root->left:root->right;
                
                if(temp==NULL){
                    temp=root;
                    root=NULL;
                }else{
                    struct Node*temp=minvalueNode(root->right);
                    root->key=temp->key;
                    root->right=deleteNode(root->right,temp->key);
                }
            }
            if(root==NULL)
            return root;
          root->height=1+max(height(root->left),height(root->right));
          int balance=getBlance(root);
          
          if(balance>1 &&getBalance(root->left)<0){
              root->left=leftRotate(root->left);
              return rightRotate(root);
          }
          if(balance<-1&&getBalance(root->right)<=0){
              root->right=rightRotate((root->right)>0){
                  root->right=rightRotate(root->right);
                  return leftRotation(root);
              }
              return root;
          }
          void preOrder(struct Node*root){
              if(root!NULL){
                  printf("%d",root->key);
                  preOrder(root->left);
                  preOrder(root->right);
              }
          }
          int main(){
              int n,x;
              if(scanf("%d %d" ,&n,&x)!=2||n<0){
                  printf("Invalid input");
                  return 0;
              }
              root=insert(root,id);
          }
          root =deletenode(root,x);
          preOrder(root);
          return 0;
        }
              }
          }
                  
              }