// editor1v
#include<stdio.h>
#include<stdlib.h>
#include<ctype.h>
typedef struct Node
{
    int data;
    struct Node*left,*right,*parent;
    int height;
}
Node;
int max(int a,int b)
{
    return a>b?a:b;}
    int height(Node*N)
    {
        return N?N->height :0;
    }
    Node* newNode(int key)
    {
        Node*node=(Node*)malloc(sizeof(Node));
        node->data=key;
        node->left=node->right=node->parent=NULL;
        node->height=1;
        return node;
        
    }
    Node*rightRotate(Node *y)
    {
        Node *x=y->left;
        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;
        
        
    }
    Node* leftRotate(Node*x)
    {
        Node*y=x->right;
        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(Node*N)
    {
        return N?height(N->left)-height(N->right):0;
    }
    Node*insert(Node*node,int key)
    {
        if(!node)return newNode(key);
        if(key<node->data)
        node->left=insert(node->left,key);
        else if(key>node->data)
        node->right=insert(node->right,key);
        else
        return node;
        node->height=max(height(node->left),height(node->right))+1;
        int balance=getbalance(node);
        if(balance>1&&key<node->left->data)
        return rightRotate(node);
        if(balance<-1&&key>node->right->data)
        return leftRotate(node);
        if(balance>1&&key>node->left->data)
        {
            node->left=leftRotate(node->left);
            return rightRotate(node);
        }
        if(balance<-1&&key<node->right->data)
        {
            node->right=rightRotate(node->right);
            return leftRotate(node);
            
        }
        return node;
    }
    Node*minvaluenode(Node*node)
    {
        Node*current=node;
        while(current->left!=NULL)
        current=current->left;
        return current;
        
    }
    Node*deletenode(Node*root,int key)
    {
        if(!root)
        return root;
        if(key<root->data)
        root->left=deletenode(root->left,key);
        else if(key>root->data)
        root->right=deletenode(root->right,key);
        else
        {
            if((root->left==NULL)||(root->right==NULL))
            
            {
                Node*temp=root->left?root->left:root->right;
                if(!temp)
                {
                    temp=root;
                    root=NULL;
                }
                else
                *root=*temp;
                free(temp);
            
                }
                else{
                    Node*temp=minvaluenode(root->right);
                    root->data=temp->data;
                    root->right=deletenode(root->right,temp->data);
                }
        }
        if(!root)
        return root;
        root->height=1+max(height(root->left),height(root->right));
        int balance=getbalance(root);
        if(balance>1&&getbalance(root->left)>=0)
        return rightRotate(root);
        if(balance>1&&getbalance(root->left)<0){
            root->left=leftRotate(root->left);
            return rightRotate(root);
            
        }
        if(balance<-1&&getbalance(root->right)<=0)
return leftRotate(root);
if(balance<-1&&getbalance(root->right)>0)
{
    root->right=rightRotate(root->right);
    return leftRotate(root);
}
return root;

}
void preorder(Node*root,int *first)
{
    if(root)
    {
        preorder(root->right,first);
        if(*first){
        {
        printf("%d",root->data);
        *first=0;
        } else{
            printf(" %d",root->data);
        }
        preorder(root->left,first);
        
    }
    
    }
    int main()
    {
        int n,k,i,valid=1;
        char c;
        if(scanf("%d %d",&n,&k)!=2||n<1||n>20||k<0)
        {
        printf("Invalid input\n");
        return 0;
        
    }
    Node*root=NULL;
    int id,foundk=0;
    for(i=0;i<n;i++)
    {
        if(scanf("%d",&id)!=1||id<0||id>1000)
        {
            printf("Invalid input\n");
            return 0;
        }
    
    if(id==k) foundk=1;
    root=insert(root,id);
    }
    if(!foundk)
    {
        printf("Invalid input\n");
        return 0;
    }
    root=deletenode(root,k);
    preorder(root);
    printf("\n");
    return 0;
    }