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

namespace Contest
{
  class Program
  {
    static void Main(string[] args)
    {
      //ABC031.D();
      Aising2020.E();
    }


    class Aising2020
    {
      public static void A()
      {
        var L = Read.Int();
        var R = Read.Int();
        var D = Read.Int();
        Console.WriteLine(R/D - (L-1)/D);
      }
      public static void B()
      {
        var N = Read.Int();
        var A = Read.IntN();
        Console.WriteLine(A.Select((x, i) => x % 2 == 1 && i % 2 == 0 ? 1 : 0).Sum());
      }
      public static void C()
      {
        var N = Read.Int();
        int[] count = new int[2000000];
        for(int x = 1; x <= 100; ++x)
        {
          for(int y = 1; y <= 100; ++y)
          {
            for(int z = 1; z <= 100; ++z)
            {
              var v = x * x + y * y + z * z + x * y + y * z + x * z;
              count[v]++;
            }
          }
        }
        Console.WriteLine(String.Join(Environment.NewLine, count.Skip(1).Take(N)));
      }
      public static void D()
      {
        var N = Read.Int();
        var X = Read.Str();
        var value = new int[N];
        var ans = Enumerable.Range(0, N).Select(i => -1).ToArray();
        int bit = 0;
        for(int i = 0; i < N; ++i) { bit += X[i] == '1' ? 1 : 0; }
        var p1 = bit + 1;
        var p2 = Math.Max(1, bit - 1);
        int a1 = 0, a2 = 0;
        for(int i = 0; i < N; ++i)
        {
          a1 = (a1 * 2 + (X[i] == '1' ? 1 : 0)) % p1;
          a2 = (a2 * 2 + (X[i] == '1' ? 1 : 0)) % p2;
        }
        var pow1 = 1;
        var pow2 = 1;
        for (int i = N - 1; i >= 0; --i)
        {
          if (X[i] == '1')
          {
            if (bit == 1) { ans[i] = 0; }
            else
            {
              var v = (a2 + p2 - (pow2 % p2)) % p2;
              int count = 1;
              while (v > 0)
              {
                var b = BitwiseOperation.Count1((ulong)v);
                v = v % b;
                count++;
              }
              ans[i] = count;
            }
          }
          else
          {
            var v = (a1 + pow1) % p1;
            int count = 1;
            while (v > 0)
            {
              var b = BitwiseOperation.Count1((ulong)v);
              v = v % b;
              count++;
            }
            ans[i] = count;
          }
          pow1 = (pow1 * 2) % p1;
          pow2 = (pow2 * 2) % p2;
        }
        Console.WriteLine(String.Join(Environment.NewLine, ans));
      }
      public static void E()
      {
        var T = Read.Int();
        var ans = new List<long>();
        for(int t = 0; t < T; ++t)
        {
          var N = Read.Int();
          var KLR = Enumerable.Range(0, N).Select(i => Read.LongN()).ToArray();
          //var list = new List<Tuple<bool, int, long>>();
          var listA = new List<Tuple<int, long>>();
          var listB = new List<Tuple<int, long>>();
          long sum = 0;
          foreach(var klr in KLR)
          {
            sum += Math.Min(klr[1], klr[2]);
            var D = klr[1] - klr[2];
            //if (D != 0)
            //{
            //  list.Add(new Tuple<bool, int, long>(D > 0, (int)klr[0] - 1, Math.Abs(D)));
            //}
            if (D > 0)
            {
              listA.Add(new Tuple<int, long>((int)klr[0] - 1, Math.Abs(D)));
            }
            else
            {
              listB.Add(new Tuple<int, long>(N - 1 - (int)klr[0], Math.Abs(D)));
            }
          }
          listA = listA.OrderBy(x => -x.Item2).ToList();
          listB = listB.OrderBy(x => -x.Item2).ToList();
          sum += E_Max(listA, N);
          sum += E_Max(listB, N);
          //int min = 0;
          //int max = listA.Count + 1;
          //while(min < max - 1)
          //{
          //  var mid = (min + max) / 2;
          //  if (E_OK(listA, mid))
          //  {
          //    min = mid;
          //  }
          //  else
          //  {
          //    max = mid;
          //  }
          //}
          //for(int i = 0; i < min; ++i)
          //{
          //  sum += listA[i].Item2;
          //}
          //min = 0;
          //max = listB.Count + 1;
          //while (min < max - 1)
          //{
          //  var mid = (min + max) / 2;
          //  if (E_OK(listB, mid))
          //  {
          //    min = mid;
          //  }
          //  else
          //  {
          //    max = mid;
          //  }
          //}
          //for (int i = 0; i < min; ++i)
          //{
          //  sum += listB[i].Item2;
          //}
          ans.Add(sum);
        }
        Console.WriteLine(String.Join(Environment.NewLine, ans));
      }
      static long E_Max(List<Tuple<int, long>> list, int N)
      {
        long sum = 0;
        var bit = new Util.BIT(N + 10);
        for(int i = 1; i <= N; ++i)
        {
          bit.Add(i, 1);
        }
        for(int i = 0; i < list.Count; ++i)
        {
          var idx = list[i].Item1 + 1;
          if (bit.Sum(idx) == 0) { continue; }
          int min = 1;
          int max = idx + 1;
          var bidx = bit.Sum(idx);
          while (min + 1 < max)
          {
            var mid = (min + max) / 2;
            if (bit.Sum(mid) == bidx)
            {
              max = mid;
            }
            else
            {
              min = mid;
            }
          }
          sum += list[i].Item2;
          //Console.WriteLine(min);
          bit.Add(min+1, -1);
        }
        return sum;
      }
      public static void F()
      {

      }
    }








    class Util
    {
      public static T[,] Gen<T>(int r, int c, T v)
      {
        var matrix = new T[r, c];
        for (int i = 0; i < r; ++i)
        {
          for (int j = 0; j < c; ++j)
          {
            matrix[i, j] = v;
          }
        }
        return matrix;
      }
      public static long[] ASum(long[] array)
      {
        var res = new long[array.Length + 1];
        for (int i = 0; i < array.Length; ++i)
        {
          res[i + 1] = res[i] + array[i];
        }
        return res;
      }
      public static long[,] ASum(long[,] matrix)
      {
        var N = matrix.GetLength(0);
        var M = matrix.GetLength(1);
        var res = new long[N + 1, M + 1];
        for(int i = 0; i < N; ++i)
        {
          for(int j = 0; j < M; ++j)
          {
            res[i + 1, j + 1] = res[i, j + 1] + res[i + 1, j] - res[i, j] + matrix[i, j];
          }
        }
        return res;
      }
      //public static Dictionary<T, long> Frequency<T>(T[] array)
      //{
      //  var dict = new Dictionary<T, long>();
      //  foreach (var a in array)
      //  {
      //    if (!dict.ContainsKey(a)) { dict.Add(a, 0); }
      //    dict[a]++;
      //  }
      //  return dict;
      //}
      public static MyDict<T, long> Frequency2<T>(T[] array)
      {
        var dict = new MyDict<T, long>();
        foreach (var a in array)
        {
          dict[a]++;
        }
        return dict;
      }

      public static long Power(long a, long n, long p)
      {
        long res = 1;
        long mult = a;
        for (int i = 0; i < 63; ++i)
        {
          if ((n & ((long)1 << i)) > 0)
          {
            res = (res * mult) % p;
          }
          mult = (mult * mult) % p;
        }
        return res;
      }
      public static long Inverse(long a, long p)
      {
        long b = p, c = 1, d = 0, e = 0, f = 0;
        while (b != 0)
        {
          e = a / b;
          f = b; b = a - e * b; a = f;
          f = d; d = c - e * d; c = f;
        }
        c %= p;
        return c + (c < 0 ? p : 0);
      }
      public static long[] Facts(int n, long p)
      {
        var facts = new long[n + 1];
        facts[0] = 1;
        for (int i = 1; i <= n; ++i)
        {
          facts[i] = (i * facts[i - 1]) % p;
        }
        return facts;
      }
      public static Func<int, int, long> Combin(int n, long P)
      {
        var fact = Facts(n, P);
        var inv = fact.Select(x => Inverse(x, P)).ToArray();
        return (N, M) =>
        {
          if (N < 0 || N < M || M < 0) { return 0; }
          return (((fact[N] * inv[M]) % P) * inv[N - M]) % P;
        };
      }
      public class BIT
      {
        int N; long[] array;
        public BIT(int m) { for (int n = 1; ; n *= 2) { if (n >= m) { N = n; array = new long[N + 1]; break; } } }
        public void Add(int idx, int v) { for (int x = idx; x <= N; x += x & -x) { array[x] += v; } }
        public long Sum(int idx) { long ret = 0; for (int x = idx; x > 0; x -= x & -x) { ret += array[x]; } return ret; }
      }
      public class BST<T> where T : IComparable
      {
        public class Node
        {
          public T V;
          public Node L, R;
          public int Count;
          public Node(T v) { V = v; Count = 1; }
        }
        static Random _rnd = new Random();
        public static int Count(Node t) { return t == null ? 0 : t.Count; }
        static Node Update(Node t) { t.Count = Count(t.L) + Count(t.R) + 1; return t; }
        public static Node Merge(Node l, Node r)
        {
          if (l == null || r == null) return l == null ? r : l;
          if ((double)Count(l) / (double)(Count(l) + Count(r)) > _rnd.NextDouble())
          { l.R = Merge(l.R, r); return Update(l); }
          else { r.L = Merge(l, r.L); return Update(r); }
        }
        public static Tuple<Node, Node> Split(Node t, int k)
        {
          if (t == null) return new Tuple<Node, Node>(null, null);
          if (k <= Count(t.L))
          {
            var s = Split(t.L, k);
            t.L = s.Item2;
            return new Tuple<Node, Node>(s.Item1, Update(t));
          }
          else
          {
            var s = Split(t.R, k - Count(t.L) - 1);
            t.R = s.Item1;
            return new Tuple<Node, Node>(Update(t), s.Item2);
          }
        }
        public static Node Remove(Node t, T v)
        {
          if (Find(t, v) == null) return t;
          return RemoveAt(t, LowerBound(t, v));
        }
        public static Node RemoveAt(Node t, int k)
        {
          var s = Split(t, k);
          var s2 = Split(s.Item2, 1);
          return Merge(s.Item1, s2.Item2);
        }
        public static bool Contains(Node t, T v) { return Find(t, v) != null; }
        public static Node Find(Node t, T v)
        {
          while (t != null)
          {
            var cmp = t.V.CompareTo(v);
            if (cmp > 0) t = t.L;
            else if (cmp < 0) t = t.R;
            else break;
          }
          return t;
        }

        public static Node FindByIndex(Node t, int idx)
        {
          if (t == null) return null;
          var currentIdx = Count(t) - Count(t.R) - 1;
          while (t != null)
          {
            if (currentIdx == idx) return t;
            if (currentIdx > idx)
            { t = t.L; currentIdx -= (Count(t == null ? null : t.R) + 1); }
            else { t = t.R; currentIdx += (Count(t == null ? null : t.L) + 1); }
          }
          return null;
        }
        public static int UpperBound(Node t, T v)
        {
          var torg = t;
          if (t == null) return -1;

          var ret = Int32.MaxValue;
          var idx = Count(t) - Count(t.R) - 1;
          while (t != null)
          {
            var cmp = t.V.CompareTo(v);

            if (cmp > 0)
            {
              ret = Math.Min(ret, idx);
              t = t.L;
              idx -= (Count(t == null ? null : t.R) + 1);
            }
            else if (cmp <= 0)
            {
              t = t.R;
              idx += (Count(t == null ? null : t.L) + 1);
            }
          }
          return ret == Int32.MaxValue ? Count(torg) : ret;
        }
        public static int LowerBound(Node t, T v)
        {
          var torg = t;
          if (t == null) return -1;

          var idx = Count(t) - Count(t.R) - 1;
          var ret = Int32.MaxValue;
          while (t != null)
          {
            var cmp = t.V.CompareTo(v);
            if (cmp >= 0)
            {
              if (cmp == 0) ret = Math.Min(ret, idx);
              t = t.L;
              if (t == null) ret = Math.Min(ret, idx);
              idx -= t == null ? 0 : (Count(t.R) + 1);
            }
            else if (cmp < 0)
            {
              t = t.R;
              idx += (Count(t == null ? null : t.L) + 1);
              if (t == null) return idx;
            }
          }
          return ret == Int32.MaxValue ? Count(torg) : ret;
        }
        public static Node Insert(Node t, T v)
        {
          var ub = LowerBound(t, v);
          return InsertByIdx(t, ub, v);
        }
        static Node InsertByIdx(Node t, int k, T v)
        {
          var s = Split(t, k);
          return Merge(Merge(s.Item1, new Node(v)), s.Item2);
        }
        public static IEnumerable<T> Enumerate(Node t)
        {
          var ret = new List<T>();
          Enumerate(t, ret);
          return ret;
        }
        static void Enumerate(Node t, List<T> ret)
        {
          if (t == null) return;
          Enumerate(t.L, ret);
          ret.Add(t.V);
          Enumerate(t.R, ret);
        }
      }
      public class Set<T> where T : IComparable
      {
        protected BST<T>.Node _root;
        public T this[int idx] { get { return ElementAt(idx); } }
        public int Count() { return BST<T>.Count(_root); }
        public virtual void Insert(T v)
        {
          if (_root == null) _root = new BST<T>.Node(v);
          else
          {
            if (BST<T>.Find(_root, v) != null) return;
            _root = BST<T>.Insert(_root, v);
          }
        }
        public void Clear() { _root = null; }
        public void Remove(T v) { _root = BST<T>.Remove(_root, v); }
        public bool Contains(T v) { return BST<T>.Contains(_root, v); }
        public T ElementAt(int k)
        {
          var node = BST<T>.FindByIndex(_root, k);
          if (node == null) throw new IndexOutOfRangeException();
          return node.V;
        }
        public int Count(T v) { return BST<T>.UpperBound(_root, v) - BST<T>.LowerBound(_root, v); }
        public int LowerBound(T v) { return BST<T>.LowerBound(_root, v); }
        public int UpperBound(T v) { return BST<T>.UpperBound(_root, v); }
        public Tuple<int, int> EqualRange(T v)
        {
          if (!Contains(v)) return new Tuple<int, int>(-1, -1);
          return new Tuple<int, int>(BST<T>.LowerBound(_root, v), BST<T>.UpperBound(_root, v) - 1);
        }
        public List<T> ToList() { return new List<T>(BST<T>.Enumerate(_root)); }
      }


      public class MyDict<T1, T2> : Dictionary<T1, T2>
      {
        public new T2 this[T1 key]
        {
          get { if (!base.ContainsKey(key)) { base.Add(key, default(T2)); } return base[key]; }
          set { base[key] = value; }
        }
      }
      public class PriorityQueue<T> where T : IComparable
      {
        private IComparer<T> _comparer = null; private bool _isAsc = true; private T[] _heap; private int _sz = 0;
        public PriorityQueue(int maxSize, IComparer<T> comparer) { _heap = new T[maxSize]; _comparer = comparer; }
        public PriorityQueue(int maxSize, bool isAsc = true) { _heap = new T[maxSize]; _isAsc = isAsc; }
        private int Compare(T x, T y) { if (_comparer != null) { return _comparer.Compare(x, y); } return _isAsc ? x.CompareTo(y) : y.CompareTo(x); }
        public void Push(T x) { var i = _sz++; while (i > 0) { var p = (i - 1) / 2; if (Compare(_heap[p], x) <= 0) { break; } _heap[i] = _heap[p]; i = p; } _heap[i] = x; }
        public T Pop() { T ret = _heap[0]; T x = _heap[--_sz]; int i = 0; while (i * 2 + 1 < _sz) { int a = i * 2 + 1; int b = i * 2 + 2; if (b < _sz && Compare(_heap[b], _heap[a]) < 0) { a = b; } if (Compare(_heap[a], x) >= 0) { break; } _heap[i] = _heap[a]; i = a; } _heap[i] = x; return ret; }
        public int Count() { return _sz; }
        public T Peek() { return _heap[0]; }
        public bool Contains(T x) { for (int i = 0; i < _sz; i++) if (x.Equals(_heap[i])) return true; return false; }
      }
      public class MyTuple<T1, T2> : IComparable where T1 : IComparable<T1>
      {
        public readonly T1 Item1; public readonly T2 Item2;
        public MyTuple(T1 item1, T2 item2) { Item1 = item1; Item2 = item2; }
        public int CompareTo(object obj) { return Item1.CompareTo(((MyTuple<T1, T2>)obj).Item1); }
      }
      public static long[] Dijkstra(Dictionary<int, Dictionary<int, long>> adj, int N, int M, int start)
      {
        long INF = 1000000000000000000;
        var dist = Enumerable.Range(0, N + 1).Select(i => INF).ToArray();
        var queue = new PriorityQueue<MyTuple<long, int>>(N + M + 100);
        dist[start] = 0;
        queue.Push(new MyTuple<long, int>(0, start));
        while (queue.Count() > 0)
        {
          var kvp = queue.Pop();
          var d = kvp.Item1; var v = kvp.Item2;
          if (dist[v] < d) { continue; }
          foreach (var kvp2 in adj[v])
          {
            var newV = kvp2.Key;
            var newD = dist[v] + kvp2.Value;
            if (newD < dist[newV])
            {
              dist[newV] = newD;
              queue.Push(new MyTuple<long, int>(newD, newV));
            }
          }
        }
        return dist;
      }
    }
    class Graph
    {
      public static HashSet<int> ConnectedComponent(Dictionary<int, HashSet<int>> adj, int idx)
      {
        HashSet<int> comp = new HashSet<int>();
        comp.Add(idx);
        List<int> target = new List<int>();
        target.Add(idx);
        while (target.Count > 0)
        {
          List<int> next = new List<int>();
          foreach (var p in target)
          {
            foreach (var f in adj[p])
            {
              if (!comp.Contains(f))
              {
                next.Add(f);
                comp.Add(f);
              }
            }
          }
          target = next;
        }
        return comp;
      }
      public static int[] CalcDistance_OnTree(Dictionary<int, HashSet<int>> adj, int N, int start)
      {
        var dist = Enumerable.Range(0, N + 1).Select(i => -1).ToArray();
        dist[start] = 0;
        Queue<int> queue = new Queue<int>();
        queue.Enqueue(start);
        while (queue.Count > 0)
        {
          var v = queue.Dequeue();
          foreach (var w in adj[v])
          {
            if (dist[w] < 0)
            {
              dist[w] = dist[v] + 1;
              queue.Enqueue(w);
            }
          }
        }
        return dist;
      }
      public static long[] CalcDistance_OnTree(Dictionary<int, Dictionary<int, long>> adj, int N, int start)
      {
        var dist = Enumerable.Range(0, N + 1).Select(i => -1L).ToArray();
        dist[start] = 0;
        Queue<int> queue = new Queue<int>();
        queue.Enqueue(start);
        while (queue.Count > 0)
        {
          var v = queue.Dequeue();
          foreach (var t in adj[v])
          {
            var w = t.Key;
            var c = t.Value;
            if (dist[w] < 0)
            {
              dist[w] = dist[v] + c;
              queue.Enqueue(w);
            }
          }
        }
        return dist;
      }
    }
    struct MOD
    {
      public static long P = 1000000007;
      public readonly long V;

      public MOD(long a) { this.V = a % P; }
      public static implicit operator MOD(long a) { return new MOD(a); }
      public static MOD operator +(MOD a, MOD b) { return new MOD((a.V + b.V) % P); }
      public static MOD operator -(MOD a, MOD b) { return new MOD((a.V - b.V + P) % P); }
      public static MOD operator *(MOD a, MOD b) { return new MOD((a.V * b.V) % P); }
      public static MOD operator /(MOD a, MOD b) { return new MOD((a.V * b.Inverse().V) % P); }
      public MOD Inverse()
      {
        long a = V, p = P; long b = p, c = 1, d = 0, e = 0, f = 0;
        while (b != 0) { e = a / b; f = b; b = a - e * b; a = f; f = d; d = c - e * d; c = f; }
        c %= p;
        return c + (c < 0 ? p : 0);
      }
      public MOD Power(long n)
      {
        long a = V, p = P; long res = 1; long mult = a;
        for (int i = 0; i < 63; ++i) { if ((n & ((long)1 << i)) > 0) { res = (res * mult) % p; } mult = (mult * mult) % p; }
        return res;
      }
      public override string ToString() { return V.ToString(); }
    }
    class BitwiseOperation
    {
      public static int Count1(UInt64 x)
      {
        UInt64 y = (x & 0x5555555555555555) + ((x >> 1) & 0x5555555555555555);
        y = (y & 0x3333333333333333) + ((y >> 2) & 0x3333333333333333);
        y = (y & 0x0f0f0f0f0f0f0f0f) + ((y >> 4) & 0x0f0f0f0f0f0f0f0f);
        y = (y & 0x00ff00ff00ff00ff) + ((y >> 8) & 0x00ff00ff00ff00ff);
        y = (y & 0x0000ffff0000ffff) + ((y >> 16) & 0x0000ffff0000ffff);
        return (int)((y & 0x00000000ffffffff) + ((y >> 32) & 0x00000000ffffffff));
      }
      public static int MSB(UInt64 x)
      {
        if (x == 0) { return -1; }
        x |= (x >> 1);
        x |= (x >> 2);
        x |= (x >> 4);
        x |= (x >> 8);
        x |= (x >> 16);
        x |= (x >> 32);
        return Count1(x) - 1;
      }
    }

    static class Read
{
static Queue<string> queue = new Queue<string>();
static void Enqueue() { var ss = Console.ReadLine().Split(' '); foreach (var s in ss) { queue.Enqueue(s); } }
public static int Int() { if (queue.Count == 0) { Enqueue(); } return Convert.ToInt32(queue.Dequeue()); }
public static long Long() { if (queue.Count == 0) { Enqueue(); } return Convert.ToInt64(queue.Dequeue()); }
public static string Str() { if (queue.Count == 0) { Enqueue(); } return queue.Dequeue(); }
public static int[] IntN() { return Console.ReadLine().Split(' ').Select(s => Convert.ToInt32(s)).ToArray(); }
public static long[] LongN() { return Console.ReadLine().Split(' ').Select(s => Convert.ToInt64(s)).ToArray(); }
public static ulong[] ULongN() { return Console.ReadLine().Split(' ').Select(s => Convert.ToUInt64(s)).ToArray(); }
public static string[] StrN() { return Console.ReadLine().Split(' '); }
public static Tuple<int, int>[] TupleInt(int n) { List<Tuple<int, int>> list = new List<Tuple<int, int>>(); for (int i = 0; i < n; ++i) { var ab = Read.IntN(); list.Add(new Tuple<int, int>(ab[0], ab[1])); } return list.ToArray(); }
public static Tuple<long, long>[] TupleLong(int n) { List<Tuple<long, long>> list = new List<Tuple<long, long>>(); for (int i = 0; i < n; ++i) { var ab = Read.LongN(); list.Add(new Tuple<long, long>(ab[0], ab[1])); } return list.ToArray(); }
public static Tuple<string, string>[] TupleStr(int n) { List<Tuple<string, string>> list = new List<Tuple<string, string>>(); for (int i = 0; i < n; ++i) { var ab = Read.StrN(); list.Add(new Tuple<string, string>(ab[0], ab[1])); } return list.ToArray(); }
public static Tuple<double, double>[] TupleDouble(int n) { List<Tuple<double, double>> list = new List<Tuple<double, double>>(); for (int i = 0; i < n; ++i) { var ab = Read.LongN(); list.Add(new Tuple<double, double>(ab[0], ab[1])); } return list.ToArray(); }
public static long[,] LongMatrix(int r, int c) { var mat = new long[r, c]; for (int i = 0; i < r; ++i) { var x = Read.LongN(); for (int j = 0; j < c; ++j) { mat[i, j] = x[j]; } } return mat; }
public static Dictionary<int, HashSet<int>> AdjacencyList(int N, int M, bool isDirectional = false)
{
Dictionary<int, HashSet<int>> dict = new Dictionary<int, HashSet<int>>();
for (int i = 0; i <= N; ++i) { dict.Add(i, new HashSet<int>()); }
for (int i = 0; i < M; ++i) { var ab = Read.IntN(); if (!dict[ab[0]].Contains(ab[1])) { dict[ab[0]].Add(ab[1]); } if (!isDirectional && !dict[ab[1]].Contains(ab[0])) { dict[ab[1]].Add(ab[0]); } }
return dict;
}
public static Dictionary<int, Dictionary<int, long>> AdjacencyListWithWeight(int N, int M, bool isDirectional = false)
{
Dictionary<int, Dictionary<int, long>> dict = new Dictionary<int, Dictionary<int, long>>(); for (int i = 0; i <= N; ++i) { dict.Add(i, new Dictionary<int, long>()); }
for (int i = 0; i < M; ++i) { var ab = Read.IntN(); dict[ab[0]].Add(ab[1], ab[2]); if (!isDirectional) { dict[ab[1]].Add(ab[0], ab[2]); } }
return dict;
}
}
    }
}
