class PriorityQueue
  attr_accessor :data, :compare, :compare_method_name

  def initialize(array = [], compare_proc = nil)
    @data = []
    array.each { |a| push(a) }
    @compare_proc = compare_proc
    @compare = "small_compare"
  end

  def change_to_bigger
    @compare = "large_compare"
  end

  def push(element)
    current = @data.size
    while current > 0
      p = parent(current)
      break if compare_equal(@data[p], element)
      @data[current] = @data[p]
      current = p
    end
    @data[current] = element
  end

  def pop
    ret = @data[0]
    x = @data[-1]
    current = 0
    while have_child?(current)
      a = left_child(current)
      b = right_child(current)
      a = b if b < @data.size - 1 && compare(@data[b], @data[a])
      break if compare_equal(x, @data[a])
      @data[current] = @data[a]
      current = a
    end
    @data[current] = x
    @data.pop

    ret
  end

  def front
    @data[0]
  end

  def empty?
    @data.empty?
  end

  def size
    @data.size
  end

  private
  def parent(num)
    (num - 1) / 2
  end

  def left_child(num)
    num * 2 + 1
  end

  def right_child(num)
    num * 2 + 2
  end

  def have_child?(num)
    left_child(num) < @data.size - 1
  end

  def small_compare(a, b)
    a < b
  end

  def large_compare(a, b)
    a > b
  end

  def compare(a, b)
    return @compare_proc.call(a, b) unless @compare_proc.nil?
    send(@compare, a, b)
  end

  def compare_equal(a, b)
    return true if a == b
    compare(a, b)
  end
end

def add(a, b)
  @value += (@current - a).abs + b if @small.size == @large.size
  if @small.size == @large.size
    if a < @current
      @large.push(@current)
      @small.push(a)
      @current = @small.pop
    else
      @large.push(a)
    end
  else
    if a < @current
      @small.push(a)
    else
      @small.push(@current)
      @large.push(a)
      @current = @large.pop
    end
  end
  @value += (@current - a).abs + b if @small.size == @large.size
end

N = gets.chomp.to_i

@small = PriorityQueue.new
@small.change_to_bigger
@large = PriorityQueue.new

query = gets.chomp.split.map(&:to_i)
@current = query[1]
@value = query[2]

(N - 1).times do
  query = gets.chomp.split.map(&:to_i)
  if query[0] == 1
    add(query[1], query[2])
  else
    puts "#{@current} #{@value}"
  end
end
