import java.io._
import java.util.StringTokenizer
import scala.util.control.Breaks.{breakable,break}
import scala.collection.mutable.{Map, Stack, Queue, PriorityQueue}

object Main extends App {
  val in = new InputReader(System.in)
  val pw = new PrintWriter(System.out)

  // val ar = new Array[Int](N)

  val lpq = new PriorityQueue[Int]()
  val rpq = new PriorityQueue[Int]()(Ordering.Int.reverse)
  var lnum = 0
  var rnum = 0
  var handFlag = false
  var hand: Int = 0

  var lcnt = 0L
  var rcnt = 0L

  var ans = 0L

  val Q = in.next().toInt
  for (_ <- 1 to Q) {
    val c = in.next().toInt

    if (c == 1) {
      val a, b = in.next().toInt

      ans += b

      if (!handFlag) {
        hand = a
        handFlag = true
      }
      else {
        if (a == hand) {
          if (lnum < rnum) {
            lnum += 1
            lpq.enqueue(a)
            lcnt += a
          }
          else {
            rnum += 1
            rpq.enqueue(a)
            rcnt += a
          }
        }
        else if (a < hand) {
          if (lnum <= rnum) {
            lnum += 1
            lpq.enqueue(a)
            lcnt += a
          }
          else {
            rnum += 1

            rpq.enqueue(hand)
            rcnt += hand

            lpq.enqueue(a)
            lcnt += a

            hand = lpq.dequeue()
            rcnt -= hand
          }
        }
        else if (a > hand) {
          if (lnum >= rnum) {
            rnum += 1
            rpq.enqueue(a)
            rcnt += a
          }
          else {
            lnum += 1

            lpq.enqueue(hand)
            lcnt += hand

            rpq.enqueue(a)
            rcnt += a

            hand = rpq.dequeue()
            rcnt -= hand
          }
        }
      }
    }
    else if (c == 2) {
      if (lnum > rnum) {
        rpq.enqueue(hand)
        rcnt += hand

        hand = lpq.dequeue()
        lcnt -= hand

        lnum -= 1
        rnum += 1
      }


      var hoge = ans
      // println(hand, ncnt, pcnt)

      if (hand < 0) {
        hoge += Math.abs(rcnt - (hand.toLong * rnum))
        hoge += Math.abs(lcnt - (hand.toLong * lnum))
      }
      else {
        hoge += Math.abs(rcnt - (hand.toLong * rnum))
        hoge += Math.abs(lcnt - (hand.toLong * lnum))
      }
      
      pw.println(s"$hand $hoge")
    }
  }

  pw.flush()
}

object Sub {
  def print2DimArray[A](mat: Array[Array[A]]): Unit = {
    mat.foreach(lin => println(lin.deep))
  }
}

class InputReader(stream: InputStream) {
  private val reader = new BufferedReader(new InputStreamReader(stream))
  private var tokenizer: StringTokenizer = new StringTokenizer(reader.readLine())
  def next(): String = {
    while (!tokenizer.hasMoreTokens()) {
      tokenizer = new StringTokenizer(reader.readLine())
    }
    tokenizer.nextToken()
  }
}
