using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;

namespace AtCoder.AISing
{
    class E
    {
        struct Camel
        {
            public int K;
            public long D;

            public Camel(int k, long d)
            {
                K = k;
                D = d;
            }
        }

        public static void Main()
        {
            var caseN = int.Parse(Console.ReadLine());

            for (int iCase = 0; iCase < caseN; iCase++)
            {
                var n = int.Parse(Console.ReadLine());
                var left = new List<Camel>();
                var right = new List<Camel>();
                long score = 0;
                for (int i = 0; i < n; i++)
                {
                    var klr = Console.ReadLine().Split(' ').Select(x => long.Parse(x)).ToArray();
                    if (klr[1] == klr[2] || klr[0] == n)
                        score += klr[1];
                    else
                    {
                        score += klr[2];
                        var camel = new Camel((int)klr[0] - 1, klr[1] - klr[2]);
                        if (klr[1] > klr[2])
                            left.Add(camel);
                        else
                            right.Add(camel);
                    }
                }


                if (left.Any())
                {
                    left.Sort((a, b) => b.K - a.K);
                    var queue = new PriorityQueue<Camel>(left.Count, (a, b) => Math.Sign(b.D - a.D));
                    for (int i = n - 1, j = 0; i >= 0; i--)
                    {
                        while (j < left.Count && left[j].K == i)
                            queue.Enqueue(left[j++]);
                        if (queue.Any())
                            score += queue.Dequeue().D;
                    }
                }

                if (right.Any())
                {
                    right.Sort((a, b) => a.K - b.K);
                    var queue = new PriorityQueue<Camel>(right.Count, (a, b) => Math.Sign(a.D - b.D));
                    for (int i = 1, j = 0; i <= n; i++)
                    {
                        while (j < right.Count && right[j].K + 1 == i)
                            queue.Enqueue(right[j++]);
                        if (queue.Any())
                            queue.Dequeue();
                    }
                    if (queue.Any())
                        score += queue.Dequeue().D;
                }
                Console.WriteLine(score);
            }
        }

        class PriorityQueue<T>
        {
            public int Count
            {
                get;
                private set;
            }

            private Comparison<T> comparison;

            private T[] heap;

            public PriorityQueue(int maxSize, Comparison<T> comparison)
            {
                heap = new T[maxSize];
                this.comparison = comparison;
            }

            public void Enqueue(T value)
            {
                int i = Count;
                while (i > 0)
                {
                    int parent = (i - 1) / 2;
                    if (comparison(heap[parent], value) <= 0)
                        break;
                    heap[i] = heap[parent];
                    i = parent;
                }
                heap[i] = value;
                Count++;
            }

            public T Dequeue()
            {
                T ret = heap[0];
                Count--;
                T foot = heap[Count];
                heap[Count] = default(T);

                int i = 0;
                while (i < Count)
                {
                    int next = i * 2 + 1;
                    if (next >= Count)
                        break;
                    if (next + 1 < Count && comparison(heap[next], heap[next + 1]) > 0)
                        next++;
                    if (comparison(heap[next], foot) >= 0)
                        break;
                    heap[i] = heap[next];
                    i = next;
                }
                heap[i] = foot;
                return ret;
            }

            public T Peek => Count > 0 ? heap[0] : throw new IndexOutOfRangeException();

            public void Clear() => Count = 0;

            public bool Contains(T item)
            {
                for (int i = 0; i < Count; i++)
                    if (item.Equals(heap[i]))
                        return true;
                return false;
            }

            public bool Any() => Count > 0;

            public T[] ToArray => heap.ToArray();
        }
    }
}
