using System;
using System.Collections.Generic;
using System.Linq;
using static System.Console;
using static System.Convert;
using static System.Math;
//using Debug;
//using static System.Globalization.CultureInfo;
//using Edge = Pair<long, int>;
using System.Text;
class Program
{ 
    static void Main(string[] args)
    {
        Solve();
        //WriteLine(Solve());
    }
    static void Solve()
    {
        var q = Input.num;
        var res = new List<string>();
        var b = 0L;
        var sma = 0L;
        var pq = new PriorityQueue<long>();
        var pqM = new PriorityQueue<long>(false);
        var big = 0L;
        while (q-- > 0)
        {
            var que = Input.ar;
            if (que[0] == 1)
            {
                if (pq.Count == 0 || pq.Peek > que[1])
                    sma += pq.Enqueue(que[1]);
                else big += pqM.Enqueue(que[1]);
                if (pq.Count + 1 == pqM.Count)
                {
                    var t = pqM.Dequeue();
                    big -= t;
                    sma += pq.Enqueue(t);
                }
                if (pq.Count == pqM.Count + 2)
                {
                    var t = pq.Dequeue();
                    sma -= t;
                    big += pqM.Enqueue(t);
                }
                b += que[2];
            }
            else
            {
                var calc = pq.Count * pq.Peek - sma;
                calc += big - pqM.Count * pq.Peek;
                res.Add($"{pq.Peek} {calc + b}");
            }
        }
        if(res.Count!=0)
            WriteLine(string.Join("\n", res));
    }
}

public class Input
{
    public static string read => ReadLine().Trim();
    public static int[] ar => read.Split(' ').Select(int.Parse).ToArray();
    public  static int num => ToInt32(read);
    public static long[] arL => read.Split(' ').Select(long.Parse).ToArray();
    public  static long numL => ToInt64(read);
    public static char[][] gred(int h) 
        => Enumerable.Repeat(0, h).Select(_ => read.ToCharArray()).ToArray();
    public static int[] ar1D(int n)
        => Enumerable.Repeat(0, n).Select(_ => num).ToArray();
    public static long[] arL1D(int n)
        => Enumerable.Repeat(0, n).Select(_ => numL).ToArray();
    public static int[][] ar2D(int n)
        => Enumerable.Repeat(0, n).Select(_ => ar).ToArray();
    public static long[][] arL2D(int n)
        => Enumerable.Repeat(0, n).Select(_ => arL).ToArray();
    public static T getValue<T>(string g)
    {
        var t = typeof(T);
        if (t == typeof(int))
            return (T)(object)int.Parse(g);
        if (t == typeof(long))
            return (T)(object)long.Parse(g);
        if (t == typeof(string))
            return (T)(object)g;
        if (t == typeof(char))
            return (T)(object)char.Parse(g);
        if (t == typeof(double))
            return (T)(object)double.Parse(g);
        if (t == typeof(bool))
            return (T)(object)bool.Parse(g);
        return default(T);
    }
    public const long Inf = (long)1e18;
    public const double eps = 1e-6;
    public  const string Alfa = "abcdefghijklmnopqrstuvwxyz";
    public  const int MOD = 1000000007;
}

public class PriorityQueue<T> where T : IComparable<T>
{
    private List<T> _item;
    public int Count { get { return _item.Count; } }
    public bool IsMaxHeap { get; set; }
    public T Peek { get { return _item[0]; } }
    public PriorityQueue(bool IsMaxHeap = true) { _item = new List<T>(); this.IsMaxHeap = IsMaxHeap; }
    private int Compare(int i, int j) => (IsMaxHeap ? 1 : -1) * _item[i].CompareTo(_item[j]);
    private int Parent(int i)
        => (i - 1) >> 1;
    private int Left(int i)
        => (i << 1) + 1;
    public T Enqueue(T val)
    {
        int i = _item.Count;
        _item.Add(val);
        while (i > 0)
        {
            int p = Parent(i);
            if (Compare(i, p) > 0)
            {
                var tmp = _item[i];
                _item[i] = _item[p];
                _item[p] = tmp;
            }
            i = p;
        }
        return val;
    }
    public T Dequeue()
    {
        T val = _item[0];
        _item[0] = _item[_item.Count-1];
        _item.RemoveAt(_item.Count - 1);
        for (int i = 0, j; (j = Left(i)) < _item.Count; i = j)
        {
            if (j != _item.Count - 1 && Compare(j, j + 1) < 0) j++;
            if (Compare(i, j) < 0)
            {
                var tmp = _item[i];
                _item[i] = _item[j];
                _item[j] = tmp;
            }
        }
        return val;
    }
}


Measured memory_bytes: 43124