import java.io.*;
import java.util.*;
import java.math.*;
import java.lang.*;

import static java.lang.Math.*;

public class Main implements Runnable
{
  static class InputReader
  {
    private InputStream stream;
    private byte[] buf = new byte[1024];
    private int curChar;
    private int numChars;
    private SpaceCharFilter filter;
    private BufferedReader br=new BufferedReader(new InputStreamReader(System.in));

    public InputReader(InputStream stream)
    {
      this.stream = stream;
    }

    public int read()
    {
      if (numChars==-1)
        throw new InputMismatchException();

      if (curChar >= numChars)
      {
        curChar = 0;
        try
        {
          numChars = stream.read(buf);
        }
        catch (IOException e)
        {
          throw new InputMismatchException();
        }

        if(numChars <= 0)
          return -1;
      }
      return buf[curChar++];
    }

    public String nextLine()
    {
      String str = "";
            try
            {
                str = br.readLine();
            }
            catch (IOException e)
            {
                e.printStackTrace();
            }
            return str;
    }
    public int nextInt()
    {
      int c = read();

      while(isSpaceChar(c))
        c = read();

      int sgn = 1;

      if (c == '-')
      {
        sgn = -1;
        c = read();
      }

      int res = 0;
      do
      {
        if(c<'0'||c>'9')
          throw new InputMismatchException();
        res *= 10;
        res += c - '0';
        c = read();
      }
      while (!isSpaceChar(c));

      return res * sgn;
    }

    public long nextLong()
    {
      int c = read();
      while (isSpaceChar(c))
        c = read();
      int sgn = 1;
      if (c == '-')
      {
        sgn = -1;
        c = read();
      }
      long res = 0;

      do
      {
        if (c < '0' || c > '9')
          throw new InputMismatchException();
        res *= 10;
        res += c - '0';
        c = read();
      }
      while (!isSpaceChar(c));
        return res * sgn;
    }

    public double nextDouble()
    {
      int c = read();
      while (isSpaceChar(c))
        c = read();
      int sgn = 1;
      if (c == '-')
      {
        sgn = -1;
        c = read();
      }
      double res = 0;
      while (!isSpaceChar(c) && c != '.')
      {
        if (c == 'e' || c == 'E')
          return res * Math.pow(10, nextInt());
        if (c < '0' || c > '9')
          throw new InputMismatchException();
        res *= 10;
        res += c - '0';
        c = read();
      }
      if (c == '.')
      {
        c = read();
        double m = 1;
        while (!isSpaceChar(c))
        {
          if (c == 'e' || c == 'E')
            return res * Math.pow(10, nextInt());
          if (c < '0' || c > '9')
            throw new InputMismatchException();
          m /= 10;
          res += (c - '0') * m;
          c = read();
        }
      }
      return res * sgn;
    }

    public String readString()
    {
      int c = read();
      while (isSpaceChar(c))
        c = read();
      StringBuilder res = new StringBuilder();
      do
      {
        res.appendCodePoint(c);
        c = read();
      }
      while (!isSpaceChar(c));

      return res.toString();
    }

    public boolean isSpaceChar(int c)
    {
      if (filter != null)
        return filter.isSpaceChar(c);
      return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
    }

    public String next()
    {
      return readString();
    }

    public interface SpaceCharFilter
    {
      public boolean isSpaceChar(int ch);
    }
  }

  public static void main(String args[]) throws Exception
    	{
    		new Thread(null, new Main(),"Main",1<<26).start();
    	}
    //User-defined functions goes here...

  public void run()
  {
    InputReader sc= new InputReader(System.in);
    PrintWriter w= new PrintWriter(System.out);

      //Your code goes here...
      int maxxx=0;
      int count=0;
      int n=sc.nextInt();
      for (int q0=0; q0<n; q0++) {
        int m=sc.nextInt();
        int c[]=new int[m];
        int d[]=new int[m];

        for (int i=0; i<m; i++) {
          c[i]=sc.nextInt();
          d[i]=sc.nextInt();
        }
        int dp[][]=new int[m+1][4];
        for (int i=1; i<m+1; i++) {
          for (int j=1; j<4; j++) {
            if(c[i-1]>j)
              dp[i][j]=dp[i-1][j];
            else
              dp[i][j]=Math.max(dp[i-1][j], dp[i-1][j-c[i-1]]+d[i-1]);
          }
        }
        int nn=3;
        int start=dp[m][3];

        for (int i=m; i>0; i--) {
          if(i==1){
            count++;
            break;
          }
          if(start==dp[i-1][nn]){
            continue;
          }
          count++;
          nn--;
          start=dp[i-1][nn];
        }

        int mxd=dp[m][3];
        int temp=count/10;
        Arrays.sort(d);
        int rev=0;
        for (int i=m-1; i>=0; i--) {
          if(rev==temp)
            break;
          mxd+=d[i];
          rev++;
        }
        if(count>10){
          count-=temp*10;
        }

        maxxx+=mxd;
      }
      w.println(maxxx);
  w.close();

}
}
