output_description: Print T lines. The i-th line should contain the answer to the i-th test case.
  
  * * *
input_description: Input is given from Standard Input in the following format:
  
      
      
      T
      \mathrm{case}_1
      \vdots
      \mathrm{case}_T
      
  
  Each case is given in the following format:
  
      
      
      N
      K_1 L_1 R_1
      \vdots
      K_N L_N R_N
attempt: class BinaryIndexedTree:
      def __init__(self, size):
          self.data = [0] * (size + 1)
          self.msb = 1 << (size.bit_length() - 1)
  
      def _add(self, i, w):
          i += 1
          while i < len(self.data):
              self.data[i] += w
              i += i & -i
  
      def _get_sum(self, i):
          res = 0
          while i > 0:
              res += self.data[i]
              i -= i & -i
          return res
  
      def __getitem__(self, i):
          """
          [0,i)
          """
          if isinstance(i, slice):
              if i.start is None:
                  return self._get_sum(i.stop)
              else:
                  return self._get_sum(i.stop) - self._get_sum(i.start)
          else:
              return 0  # fake value
  
      __setitem__ = _add
  
      def bisect_left(self, v):
          """
          return smallest i s.t v <= sum[:i]
          """
          i = 0
          k = self.msb
          while k > 0:
              i += k
              if i < len(self.data) and self.data[i] < v:
                  v -= self.data[i]
              else:
                  i -= k
              k >>= 1
          return i
  
      def bisect_right(self, v):
          """
          return smallest i s.t v < sum[:i]
          """
          i = 0
          k = self.msb
          while k > 0:
              i += k
              if i < len(self.data) and self.data[i] <= v:
                  v -= self.data[i]
              else:
                  i -= k
              k >>= 1
          return i
  
      bisect = bisect_right
  
  
  def solve(KLR):
      min2 = lambda x, y: x if x < y else y
  
      N = len(KLR)
      offset = sum(min2(l, r) for k, l, r in KLR)
      KLR.sort()
      p = sorted(
          (l - r, k, i, True) if l > r else (r - l, k, i, False)
          for i, (k, l, r) in enumerate(KLR)
      )
  
      lbit = BinaryIndexedTree(N)
      rbit = BinaryIndexedTree(N)
      res = 0
      for v, k, i, is_l in p:
          if is_l:
              if lbit[:i] + 1 <= k:
                  lbit[i] += 1
                  res += v
              else:
                  rbit[i] += 1
          else:
              if rbit[i + 1 : N] + 1 <= N - k:
                  rbit[i] += 1
                  res += v
              else:
                  lbit[i] += 1
      return res + offset
  
  
  if __name__ == "__main__":
      T = int(input())
      for t in range(T):
          N = int(input())
          KLR = [tuple(map(int, input().split())) for _ in range(N)]
          print(solve(KLR))
  
problem_description: Statement
  
  We have N camels numbered 1,2,\ldots,N. Snuke has decided to make them line up
  in a row.
  
  The happiness of Camel i will be L_i if it is among the K_i frontmost camels,
  and R_i otherwise.
  
  Snuke wants to maximize the total happiness of the camels. Find the maximum
  possible total happiness of the camel.
  
  Solve this problem for each of the T test cases given.
samples: [{"input": "3\n    2\n    1 5 10\n    2 15 5\n    3\n    2 93 78\n    1 71 59\n    3 57 96\n    19\n    19 23 16\n    5 90 13\n    12 85 70\n    19 67 78\n    12 16 60\n    18 48 28\n    5 4 24\n    12 97 97\n    4 57 87\n    19 91 74\n    18 100 76\n    7 86 46\n    9 100 57\n    3 76 73\n    6 84 93\n    1 6 84\n    11 75 94\n    19 15 3\n    12 11 34", "output": "25\n    221\n    1354\n    \n\n  * In the first test case, it is optimal to line up the camels in the order 2, 1.\n    * Camel 1 is not the frontmost camel, so its happiness will be 10.\n    * Camel 2 is among the two frontmost camels, so its happiness will be 15.\n  * In the second test case, it is optimal to line up the camels in the order 2, 1, 3.\n    * Camel 1 is among the two frontmost camels, so its happiness will be 93.\n    * Camel 2 is the frontmost camel, so its happiness will be 71.\n    * Camel 3 is among the three frontmost camels, so its happiness will be 57."}]