class PQueue
  def initialize(&block)
    @compare_fn = block || lambda { |x, y| (x <=> y) == -1 }
    @heap = []
  end

  def push(val)
    i = @heap.size

    while i > 0
      p = (i - 1) / 2
      break if compare(@heap[p], val)
      @heap[i] = @heap[p]
      i = p
    end

    @heap[i] = val
  end

  def pop
    val = @heap[0]
    n = @heap.pop
    unless @heap.empty?
      @heap[0] = n
      heapify(0)
    end
    val
  end

  def size
    @heap.size
  end

  def empty?
    @heap.empty?
  end

  def peek
    @heap[0]
  end

  private

  def heapify(i)
    left_idx = i * 2 + 1
    right_idx = i * 2 + 2

    next_idx = i

    next_idx = left_idx if left_idx < @heap.size && compare(@heap[left_idx], @heap[i])
    next_idx = right_idx if right_idx < @heap.size && compare(@heap[right_idx], @heap[next_idx])

    if i != next_idx
      @heap[i], @heap[next_idx] = @heap[next_idx], @heap[i]
      heapify(next_idx)
    end
  end

  def compare(x, y)
    @compare_fn.call(x, y)
  end
end

N = gets.chomp.to_i

left = PQueue.new { |x, y| (x <=> y) == 1 }
right = PQueue.new

query = gets.chomp.split.map(&:to_i)

value = query[2]

left.push(query[1])
right.push(query[1])

(N - 1).times do
  query = gets.chomp.split.map(&:to_i)
  if query[0] == 1
    value += query[2]

    value += left.peek - query[1] if query[1] < left.peek
    value += query[1] - right.peek if right.peek < query[1]

    left.push(query[1])
    right.push(query[1])

    l_max = left.pop
    r_min = right.pop
    left.push(r_min)
    right.push(l_max)
  else
    puts "#{left.peek} #{value}"
  end
end
