class Node
  attr_accessor :priority, :key, :left, :right
  def initialize(key, pri)
    @key = key
    @priority = pri
  end
end

def find(node, key)
  return node if node.nil? || node.key == key
  if key < node.key
    find(node.left, key)
  else
    find(node.right, key)
  end
end
def in_order(node, arr = [])
  return if node.nil?
  in_order(node.left, arr)
  arr << node.key
  in_order(node.right, arr)
  arr
end

def pre_order(node, arr = [])
  return if node.nil?
  arr << node.key
  pre_order(node.left, arr)
  pre_order(node.right, arr)
  arr
end
def rightRotate(t)
    s = t.left
    t.left = s.right
    s.right = t
    return s #root of the subtree
end
def leftRotate(t)
    s = t.right
    t.right = s.left
    s.left = t
    return s # root of the subtre
end
def insert(t,key, priority)    # 再帰的に探索
  if t == nil
    return Node.new(key, priority)               # 葉に到達したら新しい節点を生成して返す
  end
  if key == t.key
    return t                                 # 重複したkeyは無視
  end

  if key < t.key                             # 左の子へ移動
    t.left = insert(t.left, key, priority)   # 左の子へのポインタを更新
    if t.priority < t.left.priority          # 左の子の方が優先度が高い場合右回転
      t = rightRotate(t)
    end
  else                                       # 右の子へ移動
    t.right = insert(t.right, key, priority) # 右の子へのポインタを更新
    if t.priority < t.right.priority         # 右の子の方が優先度が高い場合左回転
      t = leftRotate(t)
    end
  end

  return t
end

def delete(t, key)
    if t == nil
        return nil
    end
    if key < t.key                                # 削除対象を検索
        t.left = delete(t.left, key)
    elsif key > t.key
        t.right = delete(t.right, key)
    else
        return _delete(t, key)
    end
    return t
end

def _delete(t, key) # 削除対象の節点の場合
    if t.left == nil && t.right == nil           # 葉の場合
        return nil
    elsif t.left == nil                        # 右の子のみを持つ場合左回転
        t = leftRotate(t)
    elsif t.right == nil                       # 左の子のみを持つ場合右回転
        t = rightRotate(t)
    else                                       # 左の子と右の子を両方持つ場合
        if t.left.priority > t.right.priority  # 優先度が高い方を持ち上げる
            t = rightRotate(t)
        else
            t = leftRotate(t)
        end
    end
    return delete(t, key)
end

node = nil
$n=gets.to_i
$n.times{|i|
  cmd, key, priority = gets.split
  case cmd
  when 'insert'
    node = insert(node, key.to_i, priority.to_i)
  when 'find'
    puts find(node, key.to_i) ? 'yes' : 'no'
  when 'delete'
    node = delete(node, key.to_i)
  when 'print'
    puts "\s" + in_order(node).join("\s")
    puts "\s" + pre_order(node).join("\s")
  end
}
