# include <stdio.h>
#include<stdlib.h>
#include<ctype.h>
struct Node{
    int key;
    struct Node*left,*right;
    int height;
};

int height(struct Node*n)
{
    return (n==NULL)?0:n->height;
    
}
int max(int a,int b)
{
    return(a>b)?a:b;
    
}
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*right(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*left(struct Node*x)
{
    struct Node*y=x->right;
    struct Node*t2=y->left;
    y->left=x;
    x->right=t2;
    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)
{
    return(n==NULL)?0: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+max(height(node->left),height(node->right));
    int balance=getbalance(node);
    if(balance>1&&key<node->left->key)
    return right(node);
    if(balance<-1&&key>node->right->key)
    return left(node);
    if(balance>1&&key>node->left->key)
    {
        node->left=left(node->left);
        return right(node);
        
    }
    if(balance<-1&&key<node->right->key)
    {
        node->right=right(node->right);
        return left(node);
        
    }
    return node;
    
}
struct Node*min(struct Node*node)
{
    struct Node*current=node;
    while(current ->left!=NULL)
    current=current->left;
    return current;
    
}
struct Node*delete(struct Node*root,int key)
{
    if(root==NULL)
    return root;
    if(key<root->key)
    root->left=delete(root->left,key);
    else if(key>root->key)
    root->right=delete(root->right,key);
    else{
        if((root->left==NULL)||(root->right==NULL))
        {
struct Node*temp=root->left?rppt->left:root->right;
if(temp==NULL)
{
    temp=root;
    root=NULL;
}
else
*root=*temp;
free(temp);

}
else{
    struct Node*temp=min(root->right);
    root->key=temp->key;
    root->right=delete(root->right,temp->key);
    
    
}
        }
        if(root==NULL)
        return root;
        root->height=1+max(height(root->left),height(root->right));
        int balance=getbalance(root);
        if(balance>1&&getbalance(root->left)>=0)
return right(root);
if(balance>1&&getbalance(root->left)<0)
    root->left=left(root->left);
    return right(root);
    
}
if(balance<-1&&getbalance(root->right)<=0)
return left(root);
if(balance<-1&&getbalance(root->right)>0)
{
    root->right=right(root->right);
    return left(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;
        
    }
    struct Node*root=NULL;
    for(int i=0;i<n;i++)
    {
        int val;
        if(scanf("%d",&val)!=1)
        {
            print("Invalid input");
            return 0;
            
        }
        root=inser(root,val);
}
root=delete(root,x);
if(root!=NULL)
preorder(root);
return 0;
}