#include <bits/stdc++.h>

#pragma GCC optimize ("Ofast")
#pragma GCC target("avx2")

using namespace std;

int n,k;

float eps = 1e-9;

int solveLinear(vector<vector<float>>& A, vector<float>& b, vector<float>&x){
		int n= A.size();
		int m = x.size();
		int rank = 0;
		int br, bc;
		if(n) assert(A[0].size() == m);
		vector<int> col(m); iota(col.begin(), col.end(), 0);
		
		for(int i=0; i<n; i++){
				float v, bv = 0;

				for(int r= i; r<n; r++) for(int c = i; c<m; c++)
						if((v=fabs(A[r][c]))>bv)
								br=r, bc=c, bv=v;
				if(bv<=eps){
						for(int j=i; j<n; j++) if(fabs(b[j]) > eps) return -1;
						break;
				}
				
				swap(A[i], A[br]);
				swap(b[i], b[br]);
				swap(col[i], col[bc]);
				for(int j=0; j<n; j++) swap(A[j][i], A[j][bc]);
				bv = 1/A[i][i];
				for(int j = i+1; j<n; j++){
						float fac = A[j][i] * bv;
						b[j]-=fac * b[i];
						for(int k = i+1; k<m; k++) A[j][k] -= fac * A[i][k];
				}
				rank++;
		}


		return rank;
}

void gauss(vector<vector<float>>& A, int start = 0) {
		int r = -1;
		for (int i = start; i < k; i++) {
				float bv = 0, br = -1;
				for (int j = r+1; j < n; j++) {
						if (A[j][i] > bv) {
								bv = A[j][i];
								br = j;
						}
				}
				if (br == -1) continue;
				swap(A[r+1], A[br]);
				r++;
				for (int j = r+1; j < n;j++) {
						float factor = A[j][i] / A[r][i];
						for (int ni = i; ni < k; ni++) {
								A[j][ni] -= A[r][ni]*factor;
						}
				}
		}
}

bool check(vector<vector<float>>& mat, int l, int r){
		int piv = -1;
		int pivots = 0;
		for (int i = l; i <= r; i++) {
				for (int j = n-1; j> piv; j--) {
						if (fabs(mat[j][i]) > eps) {
								piv = j;
								pivots++;
								break;
						}
				}
		}

		return (r - l + 1) > pivots;
}

int main(){
		cin>>n>>k;


		// [vertex][type]
		vector<vector<float>> mat(n, vector<float>(k, 0));

		for(int i=0; i<k; i++){
				int n;
				cin >>n;
				for(int j=0; j<n; j++){
						int u,v;
						cin>>u>>v;
						u--;v--;

						mat[u][i]--;
						mat[v][i]++;
				}
		}

		int INF = 100000000;

		int res = INF;
		
		int r = 0;

		vector<float> rhs(n, 0), out(k, 0);


		vector<int> min_nonzero(k, -1);
		for (int i = 0; i < k; i ++) {
				for (int j = n-1; j >= 0; j--) {
						if (fabs(mat[j][i]) > eps) {
								min_nonzero[i] = j;
								break;
						}
				}
				if (min_nonzero[i] == -1) {
						cout << 1 << '\n';
						return 0;
				}
		}


		for(int l = 0; l<k; l++){
				gauss(mat, l);
				while(!check(mat,l,r)){
						r++;
						if(r>=k) goto end;
				}
				res = min(res, r-l+1);
		}
end :
		cout << (res == INF?-1 : res) << endl;
}