import java.util.*;
import java.io.*;
public class EdB {
	static long[] mods = {1000000007, 998244353, 1000000009};
	static long mod = mods[0];
	public static MyScanner sc;
    public static PrintWriter out;
	public static void main(String[] omkar) throws Exception{
		// TODO Auto-generated method stub
 		sc = new MyScanner();
 		out = new PrintWriter(System.out);
 		int n = sc.nextInt();
 		long[][][] info = new long[n][4][2]; //[i][j][k] i means for the ith turn, j means taking j cards from there, k =0 means single damage k=1 means double damage      -1 means u can't take j cards from there
 		for(int i = 0;i<n;i++){
//	 		String input1 = bf.readLine().trim();
//	 		String input2 = bf.readLine().trim();
//			COMPARING INTEGER OBJECTS U DO DOT EQUALS NOT ==
 			int k = sc.nextInt();
 			ArrayList<Long> one = new ArrayList<Long>();
 			int numone = 0;
 			long two = -1;
 			long three = -1;
 			for(int j = 0;j<k;j++){
 				long v1 = sc.nextLong();
 				long v2 = sc.nextLong();
 				if (v1 == 1){
 					one.add(v2);
 					numone++;
 				}
 				else if (v1 == 2)
 					two = Math.max(two,  v2);
 				else
 					three = Math.max(three,  v2);
 			}
 			Collections.sort(one);
 			if (one.size() >=3){
 				info[i][3][0] = one.get(numone-1) + one.get(numone-2) + one.get(numone-3);
 				info[i][3][1] = 2L*one.get(numone-1) + one.get(numone-2) + one.get(numone-3);
 			}
 			else
 				Arrays.fill(info[i][3], -1);
 			info[i][2][0] = -1;
 			info[i][2][1] = -1;
 			if (one.size() >=2){
 				info[i][2][0] = Math.max(info[i][2][0],  one.get(numone-1)+one.get(numone-2));
 				info[i][2][1] = Math.max(info[i][2][1], 2L*one.get(numone-1) + one.get(numone-2));
 			}
 			if (two != -1 && one.size() >=1){
 				info[i][2][0] = Math.max(info[i][2][0],  two+one.get(numone-1));
 				info[i][2][1] = Math.max(info[i][2][1],  2L*Math.max(one.get(numone-1), two)+Math.min(one.get(numone-1), two));
 			}
 			info[i][1][0] = -1;
 			info[i][1][1] = -1;
 			if (one.size() >=1){
 				info[i][1][0] = Math.max(info[i][1][0],  one.get(numone-1));
 				info[i][1][1] = Math.max(info[i][1][1],  2L*one.get(numone-1));
 			}
 			if (two != -1){
 				info[i][1][0] = Math.max(info[i][1][0],  two);
 				info[i][1][1] = Math.max(info[i][1][1],  2L*two);
 			}
 			if (three != -1){
 				info[i][1][0] = Math.max(info[i][1][0],  three);
 				info[i][1][1] = Math.max(info[i][1][1],  2L*three);
 			}
	 		
	 		
//	 		for(int j = 0;j<array.length;j++){
//	 			out.print(array[j] + " ");
//	 		}
//	 		out.println();
 		}
 		
 		long[][] dp = new long[n][10];
 		for(int j = 0;j<n;j++){
 			Arrays.fill(dp[j],  -1);
 		}
 		dp[0][1] = info[0][1][0];
 		dp[0][2] = info[0][2][0];
 		dp[0][3] = info[0][3][0];
 		for(int j = 1;j<n;j++){
 			for(int st = 0;st<10;st++){
 				dp[j][st] = dp[j-1][st];
 			}
 			for(int k = j-1;k>=Math.max(0, j-10);k--){
 				for(int l = 0;l<10;l++){
 					if (dp[k][l] != -1){
	 					for(int t = 1;t<=3;t++){
	 						if (t+l >= 10){
	 							dp[j][(t+l)%10] = Math.max(dp[j][(t+l)%10], info[j][t][1]+dp[k][l]);
	 						}
	 						else{
	 							dp[j][t+l] = Math.max(dp[j][t+l], info[j][t][0]+dp[k][l]);
	 						}
	 					}
 					}
 				}
 			}
 		}
 		long ans = 0;
 		for(int j = 0;j<10;j++){
 			ans = Math.max(ans,  dp[n-1][j]);
 		}
 		out.println(ans);
 		
	 		
 		out.close();	
 	}
	public static void sort(int[] array){
		ArrayList<Integer> copy = new ArrayList<Integer>();
		for (int i : array)
			copy.add(i);
		Collections.sort(copy);
		for(int i = 0;i<array.length;i++)
			array[i] = copy.get(i);
	}
	static String[] readArrayString(int n){
		String[] array = new String[n];
		for(int j =0 ;j<n;j++)
			array[j] = sc.next();
		return array;
	}
	static int[] readArrayInt(int n){
    	int[] array = new int[n];
    	for(int j = 0;j<n;j++)
    		array[j] = sc.nextInt();
    	return array;
    }
	static int[] readArrayInt1(int n){
		int[] array = new int[n+1];
		for(int j = 1;j<=n;j++){
			array[j] = sc.nextInt();
		}
		return array;
	}
	static long[] readArrayLong(int n){
		long[] array = new long[n];
		for(int j =0 ;j<n;j++)
			array[j] = sc.nextLong();
		return array;
	}
	static double[] readArrayDouble(int n){
		double[] array = new double[n];
		for(int j =0 ;j<n;j++)
			array[j] = sc.nextDouble();
		return array;
	}
	static int minIndex(int[] array){
		int minValue = Integer.MAX_VALUE;
		int minIndex = -1;
		for(int j = 0;j<array.length;j++){
			if (array[j] < minValue){
				minValue = array[j];
				minIndex = j;
			}
		}
		return minIndex;
	}
	static int minIndex(long[] array){
		long minValue = Long.MAX_VALUE;
		int minIndex = -1;
		for(int j = 0;j<array.length;j++){
			if (array[j] < minValue){
				minValue = array[j];
				minIndex = j;
			}
		}
		return minIndex;
	}
	static int minIndex(double[] array){
		double minValue = Double.MAX_VALUE;
		int minIndex = -1;
		for(int j = 0;j<array.length;j++){
			if (array[j] < minValue){
				minValue = array[j];
				minIndex = j;
			}
		}
		return minIndex;
	}
	static long power(long x, long y){
		if (y == 0)
			return 1;
		if (y%2 == 1)
			return (x*power(x, y-1))%mod;
		return power((x*x)%mod, y/2)%mod;
	}
	static void verdict(boolean a){
        out.println(a ? "YES" : "NO");
    }
    public static class MyScanner {
        BufferedReader br;
        StringTokenizer st;
        public MyScanner() {
            br = new BufferedReader(new InputStreamReader(System.in));
        }
        String next() {
            while (st == null || !st.hasMoreElements()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } 
                catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }
        int nextInt() {
            return Integer.parseInt(next());
        }
        long nextLong() {
            return Long.parseLong(next());
        }
        double nextDouble() {
            return Double.parseDouble(next());
        }
        String nextLine() {
            String str = "";
            try{
                str = br.readLine();
            } 
            catch (IOException e) {
                e.printStackTrace();
            }
            return str;
        }
        
    }	
}

//StringJoiner sj = new StringJoiner(" "); 
//sj.add(strings)
//sj.toString() gives string of those stuff w spaces or whatever that sequence is