from collections import namedtuple
from pprint import pp

Camel = namedtuple("Camel", "k v".split(" "))
def read_int():
    return int(input())

def read_int_array():
    return [int(ss) for ss in input().split()]

class SegmentNode:
    def __init__(self, minidx, maxidx, capacity, occupied, left, right):
        self.minidx = minidx
        self.maxidx = maxidx
        self.capacity = capacity
        self.occupied = occupied
        self.left = left
        self.right = right

    def __repr__(self):
        return f"[{self.minidx}-{self.maxidx}, {self.occupied}/{self.capacity}]"

    def print_tree(self, lvl = 0):
        print((" " * lvl) + self.__repr__())
        if self.left:
            self.left.print_tree(lvl + 2)
        if self.right:
            self.right.print_tree(lvl + 2)

    def occupy(self, rightmost_idx):
        if self.minidx > rightmost_idx:
            return False
        if self.capacity == self.occupied:
            return False
        is_leaf = not(self.left or self.right)
        if is_leaf:
            self.occupied += 1
            return True

        if self.right:
            result = self.right.occupy(rightmost_idx)
            if result:
                self.occupied += 1
                return True

        result = self.left.occupy(rightmost_idx)
        if result:
            self.occupied += 1
            return True
        return False


def buildtree(size):
    row = [SegmentNode(i, i, 1, 0, None, None) for i in range(size)]

    while len(row) > 1:
        newrow = []
        for i in range(0, len(row), 2):
            left = row[i]
            right = row[i + 1] if i + 1 < len(row) else None
            minidx = left.minidx
            maxidx = left.maxidx
            capacity = left.capacity
            if right:
                maxidx = right.maxidx
                capacity += right.capacity
            newrow.append(SegmentNode(minidx, maxidx, capacity, 0, left, right))
        row = newrow

    return row[0]

# st = buildtree(5)
# print(st.occupy(2))
# # print(st.occupy(1))
# st.print_tree()

def solution():
    n = read_int()

    lefties = []
    righties = []

    total = 0

    for _ in range(n):
        k, l, r = read_int_array()
        total += min(l, r)
        if l > r:
            lefties.append(Camel(k - 1, l - r))
        if r > l:
            righties.append(Camel(k - 1, r - l))

    lefties = sorted(lefties, key = lambda c: -c.v)
    righties = sorted(righties, key = lambda c: -c.v)

    ltree = buildtree(len(lefties))
    rtree = buildtree(len(righties))

    for l in lefties:
        if ltree.occupy(l.k):
            total += l.v

    for r in righties:
        if rtree.occupy(n - r.k - 2):
            total += r.v

    return total




def main():
    t = read_int()

    for i in range(t):
        s = solution()
        print(s)


main()
