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

struct node{
  struct node *right;
  struct node *left;
  struct node *parent;
  int key;
};
typedef struct node * Node;
#define NIL NULL

Node root;

Node tree_left_max(Node x){
	Node left_biggest, parent_node;

	left_biggest = x->left;
	parent_node=x;
	while(left_biggest->right!=NULL){
		parent_node = left_biggest;
	    left_biggest = left_biggest->right;
	}
	return left_biggest;
}

Node tree_search(Node u, int k){

	if(u->key > k){
		if(u->left==NIL){ 
			return NIL;
		}
		return tree_search(u->left, k);
	}
	
	if(u->key < k){
		if(u->right == NULL){
			return NULL;     
		}
		return tree_search(u->right, k);
	}

	return u;
}

Node tree_successor(Node x){

	return root;
}

void tree_delete(Node z){
  Node left_max;
  int direction; //if z is left child: -1, right child: 1, other: 0
  if(z->parent->right == z){
	  direction = 1;
  } else if(z->parent->left == z){
	  direction = -1;
  } else {
	  direction = 0;
  }
  if(z != NIL){
	  if(z->left == NIL || z->right == NIL){
            
		  if(z->left == NIL){
                
			  if(direction == -1){
                     z->parent->left = z->right;
			  }
              if(direction == 1){
                     z->parent->right = z->right;
              }
              if(direction == 0){
                     root = z->right;
              }
		  } else {
               
              if(direction == -1){
                  z->parent->left = z->left;
              }
              if(direction == 1){
                  z->parent->right = z->left;
              }
              if(direction == 0){
                  root = z->left;
              }
           }
             free(z);
         } else {
            
        	left_max = tree_left_max(z);

             z->key = left_max->key;
             if(direction==-1){
                 z->parent->left = left_max->left;
             } else {
                 z->parent->right = left_max->left;
             }
          free(left_max);
       }
    }


}

Node new_node(Node n, int k){
	Node z;

	z = malloc(sizeof(struct node));
	z->key = k;
	z->left = NIL;
	z->right = NIL;
	z->parent = n;
	return z;
}

void insert(int k, Node x){

  if(x->key > k){
	  if(x->left != NIL){
		  insert(x->left, k);
	  } else {
		  
		  x->left = new_node(x, k);
	  }
  } else {
  
	  if(x->right != NIL){
		  insert(x->right, k);
	  } else {
		 
		  x->right=new_node(x, k);
	  }
   }
  return;
}

void inorder(Node u){
	if(u != NIL){
		inorder(u->left);
		printf("%d", u->key);
		inorder(u->right);
	}
}

void preorder(Node u){
	printf(u->key);
	if (u->left != NIL){
		preorder(u->left);
	}

	if (u->right != NIL){
	    preorder(u->right);
	}
}


int main(){
  int n, i, x;
  char com[20];
  scanf("%d", &n);

  for ( i = 0; i < n; i++ ){
    scanf("%s", com);
    if ( com[0] == 'f' ){
      scanf("%d", &x);
      Node t = tree_search(root, x);
      if ( t != NIL ) printf("yes\n");
      else printf("no\n");
    } else if ( com[0] == 'i' ){
      scanf("%d", &x);
      insert(x, root);
    } else if ( com[0] == 'p' ){
      inorder(root);
      printf("\n");
      preorder(root);
      printf("\n");
    } else if ( com[0] == 'd' ){
      scanf("%d", &x);
      tree_delete(tree_search(root, x));
    }
  }

  return 0;
}