#include <bits/stdc++.h>

template <typename T>
class BinarySearchTree {

  struct Node {
    T key;
    Node *par, *lhs, *rhs;
    Node() {}
    Node(T k, Node *p = 0, Node *l = 0, Node *r = 0) : key(k), par(p), lhs(l), rhs(r) {}
  };

  Node *root;

  // 入力：現在のノード curr, 中間順巡回のノードの順番を保存した配列 order
  // 出力：なし
  void inorder_dfs(Node *curr, std::vector<int> &order) {
    if (!curr) return;
    inorder_dfs(curr->lhs, order);
    order.push_back(curr->key);
    inorder_dfs(curr->rhs, order);
  }

  // 入力：現在のノード curr, 中間順巡回のノードの順番を保存した配列 order
  // 出力：なし
  void preorder_dfs(Node *curr, std::vector<int> &order) {
    if (!curr) return;
    order.push_back(curr->key);
    preorder_dfs(curr->lhs, order);
    preorder_dfs(curr->rhs, order);
  }

  // 入力：親ノード curr、値 x
  // 出力：curr->key > x なら左の子、それ以外なら右の子
  Node *child(Node *curr, T x) {
    return (curr->key > x ? curr->lhs : curr->rhs);
  }

  // 入力：現在のノード curr
  // 出力：curr の次節点
  Node *successor(Node *curr) {
    if (curr->rhs) return minimum(curr->rhs);
    Node *prev = curr->par;
    while (prev && curr == prev->rhs) {
      curr = prev;
      prev = prev->par;
    }
    return prev;
  }

  // 入力：現在のノード curr
  // 出力：curr の部分木で最小の要素を持つノード
  Node *minimum(Node *curr) {
    while (curr->lhs) curr = curr->lhs;
    return curr;
  }

public:

  BinarySearchTree() : root(0) {}

  // 入力：なし
  // 出力：中間順巡回のノードの順番を保存した配列
  std::vector<int> inorder() {
    std::vector<int> res;
    inorder_dfs(root, res);
    return res;
  }

  // 入力：なし
  // 出力：先行順巡回のノードの順番を保存した配列
  std::vector<int> preorder() {
    std::vector<int> res;
    preorder_dfs(root, res);
    return res;
  }

  // 入力：値 x
  // 出力：なし
  void insert(const T &x) {
    Node *curr = root, *prev = 0;
    while (curr) {
      prev = curr;
      if (curr->key == x) return;
      curr = child(curr, x);
    }
    (curr == root ? root : prev->key > x ? prev->lhs : prev->rhs) = new Node(x, prev);
  }

  // 入力：値 x
  // 出力：キーに x を持つノードのポインタ (存在しない場合は 0)
  Node *find(const T &x) {
    Node *curr = root;
    while (curr) {
      if (curr->key == x) return curr;
      curr = child(curr, x);
    }
    return 0;
  }

  // 入力：値 x
  // 出力：なし
  void erase(const T &x) {
    Node *curr = find(x);
    if (!curr) return;
    if (!curr->lhs || !curr->rhs) {
      Node *tmp = (curr->lhs ? curr->lhs : curr->rhs ? curr->rhs : 0);
      (curr == root ? root : curr->par->key > curr->key ? curr->par->lhs : curr->par->rhs) = tmp;
      if (tmp) tmp->par = curr->par;
      delete curr;
    } else {
      Node *succ = successor(curr);
      T tmp = succ->key;
      erase(succ->key);
      curr->key = tmp;
    }
  }

};

void insert(BinarySearchTree<int> &BST) {
  int x;
  std::cin >> x;
  BST.insert(x);
}

void find(BinarySearchTree<int> &BST) {
  int x;
  std::cin >> x;
  std::cout << (BST.find(x) ? "yes" : "no") << std::endl;
}

void erase(BinarySearchTree<int> &BST) {
  int x;
  std::cin >> x;
  BST.erase(x);
}

void print(BinarySearchTree<int> &BST) {
  std::vector<int> inorder = BST.inorder();
  std::vector<int> preorder = BST.preorder();
  for (size_t i = 0; i < inorder.size(); i++) {
    std::cout << " " << inorder[i];
  }
  std::cout << std::endl;
  for (size_t i = 0; i < preorder.size(); i++) {
    std::cout << " " << preorder[i];
  }
  std::cout << std::endl;
}

void ALDS1_8_A() {
  BinarySearchTree<int> BST;
  size_t N;
  std::cin >> N;
  for (size_t i = 0; i < N; i++) {
    std::string s;
    std::cin >> s;
    if (s == "insert") insert(BST);
    else print(BST);
  }
}

void ALDS1_8_B() {
  BinarySearchTree<int> BST;
  size_t N;
  std::cin >> N;
  for (size_t i = 0; i < N; i++) {
    std::string s;
    std::cin >> s;
    if (s == "insert") insert(BST);
    else if (s == "find") find(BST);
    else print(BST);
  }
}

void ALDS1_8_C() {
  BinarySearchTree<int> BST;
  size_t N;
  std::cin >> N;
  for (size_t i = 0; i < N; i++) {
    std::string s;
    std::cin >> s;
    if (s == "insert") insert(BST);
    else if (s == "find") find(BST);
    else if (s == "delete") erase(BST);
    else print(BST);
  }
}

int main() {

  std::cin.tie(nullptr);
  std::ios::sync_with_stdio(false);

  // ALDS1_8_A();
  // ALDS1_8_B();
  ALDS1_8_C();

}


Measured memory_bytes: 26320