import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.Arrays;
import java.io.BufferedInputStream;
import java.util.Random;
import java.io.FilterInputStream;
import java.util.Comparator;
import java.io.InputStream;

/**
 * @author khokharnikunj8
 */

public class Main {
    public static void main(String[] args) {
        new Thread(null, new Runnable() {
            public void run() {
                new Main().solve();
            }
        }, "1", 1 << 26).start();
    }

    void solve() {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        ScanReader in = new ScanReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        E1VotingEasyVersion solver = new E1VotingEasyVersion();
        int testCount = in.scanInt();
        for (int i = 1; i <= testCount; i++)
            solver.solve(i, in, out);
        out.close();
    }

    static class E1VotingEasyVersion {
        public void solve(int testNumber, ScanReader in, PrintWriter out) {
            int n = in.scanInt();
            int[][] ar = new int[n][2];
            long ans = 0;
            for (int i = 0; i < n; i++) {
                ar[i][0] = in.scanInt();
                ar[i][1] = in.scanInt();
                ans += ar[i][1];
            }
            CodeHash.shuffle(ar);
            Arrays.sort(ar, new Comparator<int[]>() {

                public int compare(int[] o1, int[] o2) {
                    if (o1[1] == o2[1]) return -o1[0] + o2[0];
                    return -o1[1] + o2[1];
                }
            });
            int left = 0;
            BSTCustom<Integer> bst = new BSTCustom<Integer>(true);
            for (int i = 0; i < n; i++) {
                if (ar[i][0] <= (n - i - 1 + left + bst.lower_bound((n - i - 1 + 1)))) {
                    ans -= ar[i][1];
                    bst.insert(ar[i][0]);
                } else left++;
            }
            out.println(ans);

        }

    }

    static class CodeHash {
        public static void shuffle(int[][] ar) {
            Random rd = new Random(new Random().nextInt());
            for (int i = 0; i < ar.length; i++) {
                int index = rd.nextInt(ar.length);
                int[] temp = ar[i];
                ar[i] = ar[index];
                ar[index] = temp;
            }
        }

    }

    static class ScanReader {
        private byte[] buf = new byte[4 * 1024];
        private int index;
        private BufferedInputStream in;
        private int total;

        public ScanReader(InputStream inputStream) {
            in = new BufferedInputStream(inputStream);
        }

        private int scan() {
            if (index >= total) {
                index = 0;
                try {
                    total = in.read(buf);
                } catch (Exception e) {
                    e.printStackTrace();
                }
                if (total <= 0) return -1;
            }
            return buf[index++];
        }

        public int scanInt() {
            int integer = 0;
            int n = scan();
            while (isWhiteSpace(n)) n = scan();
            int neg = 1;
            if (n == '-') {
                neg = -1;
                n = scan();
            }
            while (!isWhiteSpace(n)) {
                if (n >= '0' && n <= '9') {
                    integer *= 10;
                    integer += n - '0';
                    n = scan();
                }
            }
            return neg * integer;
        }

        private boolean isWhiteSpace(int n) {
            if (n == ' ' || n == '\n' || n == '\r' || n == '\t' || n == -1) return true;
            else return false;
        }

    }

    static class BSTCustom<T extends Comparable<? super T>> {
        private Node<T> __root;
        private Node<T> __tempnode;
        private Node<T> __tempnode1;
        private long __size;
        private boolean __multi;

        public BSTCustom() {
            __root = null;
            __size = 0;
            __multi = false;

        }

        public BSTCustom(boolean __multi) {
            __root = null;
            __size = 0;
            this.__multi = __multi;
        }

        public long lower_bound(T data) {
            __tempnode = __root;
            long index = 0;
            while (__tempnode != null) {
                int _comparator = data.compareTo(__tempnode.data);
                if (_comparator < 0) {
                    __tempnode = __tempnode._left;
                } else if (_comparator > 0) {
                    index += (__tempnode.count + __tempnode._leftside);
                    __tempnode = __tempnode._right;
                } else {
                    index += (__tempnode._leftside);
                    break;
                }
            }
            return index;
        }

        public void insert(T data, long... count) {
            if (count.length == 0) __root = insert(__root, data, 1);
            else if (count[0] > 0) __root = insert(__root, data, count[0]);

        }

        private Node<T> insert(Node<T> temp, T data, long count) {
            if (temp == null) {
                if (__multi) {
                    __size += count;
                    return new Node<>(data, count);
                } else {
                    __size++;
                    return new Node<>(data);
                }
            }
            int _comparator = data.compareTo(temp.data);
            if (_comparator < 0) temp._left = insert(temp._left, data, count);
            else if (_comparator > 0) temp._right = insert(temp._right, data, count);
            else if (__multi) {
                __size += count;
                temp.count += count;
            }


            // for __leftside and _rightside count
            if (temp._left != null)
                temp._leftside = temp._left._leftside + temp._left._rightside + temp._left.count;
            else temp._leftside = 0;
            if (temp._right != null)
                temp._rightside = temp._right._leftside + temp._right._rightside + temp._right.count;
            else temp._rightside = 0;

            temp._height = Math.max(getheight(temp._left), getheight(temp._right)) + 1;
            //Balancing

            long diff = getDiff(temp);
            if (diff > 1) {
                if (data.compareTo(temp._left.data) < 0) {
                    temp = rightRotate(temp);
                } else if (data.compareTo(temp._left.data) > 0) {
                    temp._left = leftRotate(temp._left);
                    temp = rightRotate(temp);
                }
            } else if (diff < -1) {
                if (data.compareTo(temp._right.data) > 0) {

                    temp = leftRotate(temp);
                } else if (data.compareTo(temp._right.data) < 0) {
                    temp._right = rightRotate(temp._right);
                    temp = leftRotate(temp);
                }
            }
            return temp;

        }

        private Node<T> rightRotate(Node<T> temp) {
            __tempnode = temp._left;
            __tempnode1 = __tempnode._right;

            __tempnode._right = temp;
            temp._left = __tempnode1;

            //height updation
            temp._height = Math.max(getheight(temp._left), getheight(temp._right)) + 1;
            __tempnode._height = Math.max(getheight(__tempnode._left), getheight(__tempnode._right)) + 1;
            //count updation

            if (temp._left != null)
                temp._leftside = temp._left._leftside + temp._left._rightside + temp._left.count;
            else temp._leftside = 0;
            if (temp._right != null)
                temp._rightside = temp._right._leftside + temp._right._rightside + temp._right.count;
            else temp._rightside = 0;

            if (__tempnode._left != null)
                __tempnode._leftside = __tempnode._left._leftside + __tempnode._left._rightside + __tempnode._left.count;
            else __tempnode._leftside = 0;
            if (__tempnode._right != null)
                __tempnode._rightside = __tempnode._right._leftside + __tempnode._right._rightside + __tempnode._right.count;
            else __tempnode._rightside = 0;


            return __tempnode;
        }

        private Node<T> leftRotate(Node<T> temp) {
            __tempnode = temp._right;
            __tempnode1 = __tempnode._left;

            __tempnode._left = temp;
            temp._right = __tempnode1;

            //height updation
            temp._height = Math.max(getheight(temp._left), getheight(temp._right)) + 1;
            __tempnode._height = Math.max(getheight(__tempnode._left), getheight(__tempnode._right)) + 1;
            //count updation

            if (temp._left != null)
                temp._leftside = temp._left._leftside + temp._left._rightside + temp._left.count;
            else temp._leftside = 0;
            if (temp._right != null)
                temp._rightside = temp._right._leftside + temp._right._rightside + temp._right.count;
            else temp._rightside = 0;


            if (__tempnode._left != null)
                __tempnode._leftside = __tempnode._left._leftside + __tempnode._left._rightside + __tempnode._left.count;
            else __tempnode._leftside = 0;
            if (__tempnode._right != null)
                __tempnode._rightside = __tempnode._right._leftside + __tempnode._right._rightside + __tempnode._right.count;
            else __tempnode._rightside = 0;

            return __tempnode;
        }

        private long getDiff(Node<T> temp) {
            if (temp == null) return 0;
            return getheight(temp._left) - getheight(temp._right);
        }

        public long getheight(Node<T> temp) {
            if (temp == null) return 0;
            return temp._height;
        }

        private class Node<T> {
            T data;
            Node<T> _left;
            Node<T> _right;
            long _leftside;
            long _rightside;
            long _height;
            long count;

            public Node(T data) {
                this.data = data;
                this._left = null;
                this._right = null;
                this._leftside = 0;
                this._rightside = 0;
                this._height = 1;
                this.count = 1;
            }

            public Node(T data, long count) {
                this.data = data;
                this._left = null;
                this._right = null;
                this._leftside = 0;
                this._rightside = 0;
                this._height = 1;
                this.count = count;
            }

        }

    }
}

