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

namespace AtCoder.AISing
{
    class E
    {

        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<int[]>();
                var right = new List<int[]>();
                var same = new List<int>();

                for (int i = 0; i < n; i++)
                {
                    var klr = Console.ReadLine().Split(' ').Select(x => int.Parse(x)).ToArray();
                    var k = --klr[0];
                    var l = klr[1];
                    var r = klr[2];

                    if (l == r || k == n - 1)
                        same.Add(klr[1]);
                    else if (l > r)
                        left.Add(klr);
                    else
                        right.Add(klr);
                }

                left.Sort((a, b) => b[0] - a[0]);
                right.Sort((a, b) => a[0] - b[0]);


                int score = same.Sum();
                if (left.Any())
                {
                    var queue = new PriorityQueue<int[]>(left.Count, (a, b) => b[1] - a[1]);
                    for (int i = left[0][0], j = 0; i >= 0; i--)
                    {
                        while (j < left.Count && left[j][0] == i)
                        {
                            queue.Enqueue(left[j]);
                            j++;
                        }
                        if (queue.Any())
                            score += queue.Dequeue()[1];
                    }
                    if (queue.Any())
                        score += queue.GetValues().Sum(x => x[2]);
                }

                if (right.Any())
                {
                    var queue = new PriorityQueue<int[]>(right.Count, (a, b) => b[2] - a[2]);
                    for (int i = right[0][0], j = 0; i < n - 1; i++)
                    {
                        while (j < right.Count && right[j][0] == i)
                        {
                            queue.Enqueue(right[j]);
                            j++;
                        }
                        if (queue.Any())
                            score += queue.Dequeue()[2];
                    }
                    if (queue.Any())
                        score += queue.GetValues().Sum(x => x[1]);
                }
                Console.WriteLine(score);
            }
        }

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

            private Comparison<T> comparison;

            private T[] heap;

            private int index;

            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 IEnumerable<T> GetValues() => heap.Take(Count);

            public IEnumerable<T> GetSortedValues()
            {
                var list = heap.Take(Count).ToList();
                list.Sort(comparison);
                return list;
            }
        }
    }
}
