/*vvv>
        zzzzzI
 .---.  zzuzuI                 .vgggg&,.
+++++=  dAC:|I  .WbbWo       JMM9^```?TMB`  ..&gNNg,.   gggggggJ,   qgggggggg] (&&&&&&&&[   c+OA&J,   (&&&&&&+J,   .cJeAA&-.  (&&&&&&&&x   .&AA&=-.
+++++=  dTqk|I  Xpbpbp      JM#`           (M#^   ?MMp  MM|   +TMN. JMF      ' |yk      ` dVY    7Vk,  Vy     XV  cVf     ?Y!  JM         V$      `
+++++=  dcf:|I  Xppppp      dMN           .MM+     .MM  MM|     MM] JMMMMMM+   |@tqkoh)  ,y0      (V$  yyyyyyyV7  VV           JMWyZWr    TWVVVVW&,
++++++  d7qk|0  Xppppp      ^HMN,    _.db  WMm,   .MMF  MM|   ..MM` JMF      . |yk       .WV&.   .XW'  yy   4yn.  jyn      +.  JM                #S
`++++`  ?ZZZX=  ?WWWW=        -THMMMMH9^    (TMMMMM9!   MMMMMMM""   JMMMMMMMME |UU.        ?TUUUUY=    UU.   (UU-  ^7TUUUV7!   JUUUUUUUU  7TUNKO*/

//Ricty Diminished
#include "bits/stdc++.h"
using namespace std;typedef long long lint;typedef vector<lint> liv;
//#define rep(i,n) for(int i=0;i<n;++i)
#define all(v) v.begin(),v.end()

#define pb push_back
#define _vcppunko4(tuple) _getname4 tuple
#define _getname4(_1,_2,_3,_4,name,...) name
#define _getname3(_1,_2,_3,name,...) name
#define _trep2(tuple) _rep2 tuple
#define _trep3(tuple) _rep3 tuple
#define _trep4(tuple) _rep4 tuple
#define _rep1(n) for(lint i=0;i<n;++i)
#define _rep2(i,n) for(lint i=0;i<n;++i)
#define _rep3(i,a,b) for(lint i=a;i<b;++i)
#define _rep4(i,a,b,c) for(lint i=a;i<b;i+=c)
#define _trrep2(tuple) _rrep2 tuple
#define _trrep3(tuple) _rrep3 tuple
#define _trrep4(tuple) _rrep4 tuple
#define _rrep1(n) for(lint i=n-1;i>=0;--i)
#define _rrep2(i,n) for(lint i=n-1;i>=0;--i)
#define _rrep3(i,a,b) for(lint i=b-1;i>=a;--i)
#define _rrep4(i,a,b,c) for(lint i=a+(b-a-1)/c*c;i>=a;i-=c)
template<class T>
istream& operator>>(istream& is,vector<T>& vec);
template<class T,size_t size>
istream& operator>>(istream& is,array<T,size>& vec);
template<class T,class L>
istream& operator>>(istream& is,pair<T,L>& p);
template<class T>
ostream& operator<<(ostream& os,vector<T>& vec);
template<class T,class L>
ostream& operator<<(ostream& os,pair<T,L>& p);
template<class T>
istream& operator>>(istream& is,vector<T>& vec){ for(T& x: vec) is>>x;return is; }
template<class T,class L>
istream& operator>>(istream& is,pair<T,L>& p){ is>>p.first;is>>p.second;return is; }
//template<class T>
//ostream& operator<<(ostream& os,vector<T>& vec){ os<<vec[0];rep(i,1,vec.size())os<<' '<<vec[i];return os; }
//template<class T>
//ostream& operator<<(ostream& os,deque<T>& deq){ os<<deq[0];rep(i,1,deq.size())os<<' '<<deq[i];return os; }
template<class T,class L>
ostream& operator<<(ostream& os,pair<T,L>& p){ os<<p.first<<" "<<p.second;return os; }

inline void in(){}
template <class Head,class... Tail>
inline void in(Head&& head,Tail&&... tail){ cin>>head;in(move(tail)...); }
template <class T>
inline bool out(T t){ cout<<t<<'\n';return 0; }
inline bool out(){ cout<<'\n';return 0; }
template <class Head,class... Tail>
inline bool out(Head head,Tail... tail){ cout<<head<<' ';out(move(tail)...);return 0; }

//template<typename T>
//vector<T> make_v(size_t a){ return vector<T>(a); }
//
//template<typename T,typename... Ts>
//auto make_v(size_t a,Ts... ts){
//	return vector<decltype(make_v<T>(ts...))>(a,make_v<T>(ts...));
//}
//template<typename T,typename V>
//typename enable_if<is_class<T>::value==0>::type
//fill_v(T &t,const V &v){ t=v; }
//
//template<typename T,typename V>
//typename enable_if<is_class<T>::value!=0>::type
//fill_v(T &t,const V &v){
//	for(auto &e:t) fill_v(e,v);
//}//http://beet-aizu.hatenablog.com/entry/2018/04/08/145516

#define rep(...) _vcppunko4((__VA_ARGS__,_trep4,_trep3,_trep2,_rep1))((__VA_ARGS__))
#define rrep(...) _vcppunko4((__VA_ARGS__,_trrep4,_trrep3,_trrep2,_rrep1))((__VA_ARGS__))
#define each(v) for(auto &i:v)
#define lin(...) lint __VA_ARGS__;in(__VA_ARGS__)
#define stin(...) string __VA_ARGS__;in(__VA_ARGS__)
#define vin(type,name,size) vector<type> name(size);in(name)
#define fi e.first
#define se e.second
#define YES(c) cout<<((c)?"YES\n":"NO\n"),0
#define Yes(c) cout<<((c)?"Yes\n":"No\n"),0
#define o(p) cout<<p<<endl,0
#define sp(p) cout<<p<<" "
#define no(p) cout<<p
#define deb(p) cerr<<p<<endl,0
#define dd(n) cout<<fixed<<setprecision(n)

#define linf 1152921504606846976
#define MAXN 200100
#define md_1e9_7 1000000007
#define md_998244353 998244353
//#define mod md_1e9_7
#define inf linf//INT_MAX

const int d4[5]={0,1,0,-1,0};

//mint
#define md_tmp template<uint_fast64_t md=1000000007>
md_tmp class mint{
	using u64=uint_fast64_t;

public:
	u64 a;

	constexpr mint(const u64 x=0) noexcept: a(x%md){}
	constexpr u64 &value() noexcept{ return a; }
	constexpr const u64 &value() const noexcept{ return a; }
	constexpr mint operator+(const mint rhs) const noexcept{
		return mint(*this)+=rhs;
	}
	constexpr mint operator-(const mint rhs) const noexcept{
		return mint(*this)-=rhs;
	}
	constexpr mint operator*(const mint rhs) const noexcept{
		return mint(*this)*=rhs;
	}
	constexpr mint operator^(const lint rhs) const noexcept{
		return mint(*this)^=rhs;
	}
	constexpr mint operator/(const mint rhs) const noexcept{
		return mint(*this)/=rhs;
	}
	constexpr mint &operator+=(const mint rhs) noexcept{
		a+=rhs.a;
		if(a>=md)a-=md;
		return *this;
	}
	constexpr mint &operator-=(const mint rhs) noexcept{
		if(a<rhs.a)a+=md;
		a-=rhs.a;
		return *this;
	}
	constexpr mint &operator*=(const mint rhs) noexcept{
		a=a*rhs.a%md;
		return *this;
	}
	constexpr mint &operator^=(const lint rhs) noexcept{
		if(!rhs)return *this=1;
		u64 exp=rhs-1;
		mint base=this->a;
		while(exp){
			if(exp&1)*this*=base;
			base*=base;
			exp>>=1;
		}
		return *this;
	}
	constexpr mint &operator/=(const mint rhs) noexcept{
		a=(*this*(rhs^(md-2))).a;
		return *this;
	}
};
md_tmp istream& operator>>(istream& os,mint<md>& m){
	os>>m.a,m.a%=md;
	return os;
}
md_tmp ostream& operator<<(ostream& os,const mint<md>& m){
	return os<<m.a;
}
md_tmp mint<md> ncr(lint n,lint r){
	if(n<r||n<0||r<0)return mint<md>(0);
	mint<md>ncr_res=1,ncr_div=1;
	rep(r)ncr_res*=(n-i),ncr_div*=(r-i);
	return ncr_res/ncr_div;
}
mint<> operator""m(unsigned long long n){ return mint<>(n); }
mint<998244353> operator""m9(unsigned long long n){ return mint<998244353>(n); }
mint<1000003> operator""m3(unsigned long long n){ return mint<1000003>(n); }
using mi=mint<>;
//
////P
//class P{ public:lint f,s; constexpr P(lint a,lint b):f(a),s(b){}; };
//istream& operator>>(istream& is,P& p){ is>>p.f>>p.s;return is; }
//ostream& operator<<(ostream& os,const P& p){ return os<<p.f<<" "<<p.s<<endl; }
//bool operator<(const P& l,const P& r){ return(l.f-r.f?l.f<r.f:l.s<r.s); }
//bool operator>(const P& l,const P& r){ return(l.f-r.f?l.f>r.f:l.s>r.s); }
//struct C{ lint f,s,t; };
//bool operator<(const C& l,const C& r){ return l.t<r.t; }
//bool operator>(const C& l,const C& r){ return l.t>r.t; }

struct edge{
	lint from,to,cost;
};
vector<vector<edge>>g(2000100);
vector<edge>edges;
int n,m;
lint d[2000100];
//define pfs,bellmanford,etc.
bool bellman_ford(int start,int goal){//ゴールまでの経路に負の閉路があるか
	fill(d,d+n,inf);
	d[start] = 0;
	rep(2*n){
		rep(j,m){
			edge now = edges[j];
			if(d[now.from]!=inf && d[now.to]>d[now.from]+now.cost){
				d[now.to]=d[now.from]+now.cost;
				if(i>=n-1 && now.to==goal){//全体で負の閉路があるかどうかだったら、==を消す
					return 1;
				}
				if(i>=n-1){
					d[now.to]=-inf;
				}
			}
		}
	}
	return 0;
}

bool vis[2000100],come[2000100];
lint val[2000100],v2[2000100];
#define Graph vector<vector<edge>>
#define dst to

bool visit(Graph &g,int v,vector<int> &order,vector<int> &color){
	color[v] = 1;
	for(auto e:g[v]){
		if(color[e.dst] == 2) continue;
		if(color[e.dst] == 1) return false;
		if(!visit(g,e.dst,order,color)) return false;
	}
	order.push_back(v); color[v] = 2;
	return true;
}
bool topologicalSort(Graph &g,vector<int> &order){
	int n = g.size();
	vector<int> color(n);
	rep(u,n) if(!color[u] && !visit(g,u,order,color))
		return false;
	reverse(all(order));
	return true;
}

int main(){
	in(n);
	lint a,b,c;

	/*ofstream ff("aasdf.txt");
	rep(1000){ rep(j,1000)if(i!=j)ff<<j+1<<" ";ff<<endl; }
	ff.close();*/
	rep(n){
		vector<lint>A(n-1);in(A);rep(n-1)--A[i];
		rep(j,n-2){
			come[i*1000+A[j+1]]=come[i+A[j+1]*1000]=1;
			g[i*1000+A[j]].pb({i*1000+A[j],i*1000+A[j+1],1});
			g[i+A[j]*1000].pb({i+A[j]*1000,i+A[j+1]*1000,1});
		}
	}
	//stack<pair<int,int>/*,vector<pair<int,int>>,greater<pair<int,int>>*/>q;
	//rep(1000000){
	//	if(!come[i])q.push({i,i}),val[i]=1,v2[i]=i;
	//}
	bool can=1;
	lint ans=1;
	//while(q.size()){
	//	pair<int,int> c=q.top();q.pop();
	//	if(vis[c.first])continue;
	//	vis[c.first]=1;
	//	v2[c.first]=c.second;
	//	for(auto e:g[c.first]){
	//		//if(v2[e.to]==c.second&&val[e.to]<=val[c.first])can=0;
	//		val[e.to]=max(val[e.to],val[c.first]+1);
	//		q.push({e.to,c.second});
	//		ans=max(ans,val[e.to]);
	//	}
	//}
	//rep(n)rep(j,n-1){
	//	if(!vis[1000*i+j])can=0;
	//}
	vector<int>order;
	if(!topologicalSort(g,order))can=0;
	vector<lint>f(2001000);

	
	rep(i,order.size()){
		if(f[order[i]]==0)f[order[i]]=1;
		for(auto e:g[order[i]]){
			f[e.to]=max(f[e.to],f[order[i]]+1);
		}
	}
	rep(order.size())ans=max(ans,f[order[i]]);

	if(!can)return o(-1);
	else o(ans);
}


//sub-EOF


Measured memory_bytes: 135264