import java.io.*;
import java.util.*;

class Main {
	public static void main(String[] args) {
		new Main().run();
	}
	
	long MOD;
	
	long[][] pow(long[][] a, long n){
		long[][] ret=new long[2][2];
		ret[0][0]=ret[1][1]=1;
		for(;n>0;n>>=1,a=mul(a,a)){
			if(n%2==1) ret=mul(ret,a);
		}
		return ret;
	}
	
	long[][] mul(long[][] a, long[][] b){
		long[][] ret=new long[a.length][b[0].length];
		for(int i=0;i<a.length;++i){
			for(int j=0;j<b[i].length;++j){
				for(int k=0;k<a[i].length;++k){
					ret[i][j]+=a[i][k]*b[k][j]%MOD;
					ret[i][j]=(ret[i][j]%MOD+MOD)%MOD;
				}
			}
		}
		return ret;
	}
	
	long det(long[][] a){
		return (a[0][0]*a[1][1]%MOD-a[0][1]*a[1][0]%MOD+MOD)%MOD; 
	}
	
	long[][] rndmat(long p){
		long[][] ret=new long[2][2];
		Random rnd=new Random();
		for(int i=0;i<2;++i)for(int j=0;j<2;++j)ret[i][j]=rnd.nextInt((int)p);
		return ret;
	}
	
	void run() {
		/*
		long p=13;
		MOD=p;
		for(int i=0;i<10000;++i){
			long[][] a=rndmat(p);
			long[][] b=rndmat(p);
			long ans0=exact(a,b,p);
			long ans1=solve(a,b,p);
			if(ans0!=-1){
				tr(a);
				tr(b);
				tr(ans0,ans1);
			}
			//if(ans0!=ans1){
			//	tr(ans0,ans1,a,b,p);
			//}
			
		}
		*/
		
		
		Scanner sc=new Scanner(System.in);
		long p=sc.nextLong();
		long[][] a=new long[2][2];
		long[][] b=new long[2][2];
		for(int i=0;i<2;++i)for(int j=0;j<2;++j)a[i][j]=sc.nextLong();
		for(int i=0;i<2;++i)for(int j=0;j<2;++j)b[i][j]=sc.nextLong();
		System.out.println(solve2(a,b,p));
		//System.out.println(exact(a,b,p));
		/**/
	}
	
	long solve2(long[][] a, long[][] b, long p){
		if(p==2)return exact(a,b,p);
	 	Scanner sc = new Scanner(System.in);
		MOD=p;
		long w=(a[0][0]*a[0][0]%MOD-2*a[1][1]*a[0][0]%MOD+a[1][1]*a[1][1]%MOD+4*a[0][1]*a[1][0]%MOD)%MOD;
		w=sqrt((w+MOD)%MOD,p);
		long det0=det(a);
		long det1=det(b);
		if(det0==0||det1==0)return exact(a,b,p);
		long eigen1=inv(2)*(a[0][0]+a[1][1]-w)%MOD;
		long eigen2=inv(2)*(a[0][0]+a[1][1]+w)%MOD;
		long[][] S=new long[2][2];
		long[][] J=new long[2][2];
		if(eigen1!=eigen2)
		{
			long[][] eigenvec1=new long[][]{{MOD-(a[0][0]+a[1][1]+w)%MOD},{2*a[1][0]}};
			long[][] eigenvec2=new long[][]{{a[0][0]-a[1][1]+w},{2*a[1][0]}};
			S=new long[][]{{eigenvec1[0][0],eigenvec2[0][0]},{eigenvec1[1][0],eigenvec2[1][0]}};
			J=new long[][]{{eigen1,0},{0,eigen2}};
		}else{
			long[][] eigenvec2=new long[][]{{MOD-(a[0][0]+a[1][1]+w)%MOD},{2*a[1][0]}};
			long[][] tmp=new long[][]{{a[0][0]-eigen1,a[0][1]},{a[1][0],a[1][1]-eigen1}};
			long[][] eigenvec1=mul(tmp,eigenvec2);
			S=new long[][]{{eigenvec1[0][0],eigenvec2[0][0]},{eigenvec1[1][0],eigenvec2[1][0]}};
			J=new long[][]{{eigen1,1},{0,eigen2}};
		}

		for(int i=0;i<2;++i){
			J[i][i]=(J[i][i]%MOD+MOD)%MOD;
			b[i][i]=(b[i][i]%MOD+MOD)%MOD;
		}
		b=mul(b,S);
		b=mul(invmat(S),b);
		//a^x=u
		//b^x=v
		long sol1=discretelog(J[0][0],b[0][0]);
		long sol2=discretelog(J[1][1],b[1][1]);
		if(sol1==-1||sol2==-1)return -1;
		long ord1=ord(J[0][0],MOD);
		long ord2=ord(J[1][1],MOD);
		//s1+mo1=s2+m'o2
		long ans1=sol1;
		long ans2=sol2;
		while(ans1!=ans2){
			if(ans1<ans2)ans1+=ord1;
			else ans2+=ord2;
		}
		while(!equiv(pow(J,ans1),b)){
			ans1+=gcd(ord1,ord2);
			ans2+=gcd(ord1,ord2);
		}
		return ans1;
	}
	
	boolean equiv(long[][] a, long[][] b){
		boolean ret=true;
		for(int i=0;i<2;++i)
			for(int j=0;j<2;++j)
				ret&=a[i][j]==b[i][j];
		return ret;
	}
	
	long exact(long[][] a, long[][] b, long p){
		MOD=p;
		for(int i=1;i<p*p;++i){
			long[][] pw_a=pow(a,i);
			boolean equiv=true;
			for(int j=0;j<2;++j)
				for(int k=0;k<2;++k)
					equiv&=pw_a[j][k]==b[j][k];
			if(equiv)return i;
		}
		return -1;
	}
	
	long solve(long[][] a, long[][] b, long p) {
		if(p==2)return exact(a,b,p);
	 	Scanner sc = new Scanner(System.in);
		MOD=p;
		long det0=det(a);
		long det1=det(b);
		long x=(det0==0&&det1==0?0:discretelog(det0,det1));
		if(x==-1){
			return -1;
		}
		long[][] na=pow(a,x);
		long ans=x;
		long ord=(det0==0?1:ord(det0,MOD));
		long[][] c=pow(a,ord);
		for(int i=0;x+i<MOD*MOD;i+=ord){
			boolean equiv=true;
			for(int j=0;j<2;++j)
				for(int k=0;k<2;++k)
					equiv&=na[j][k]==b[j][k];
			if(equiv){
				return x+i;
			}
			na=mul(na,c);
		}
		return -1;
	}
	
	long inv(long a){
		return pow(a, MOD-2);
	}
	
	long ord(long a, long p) {
		if(a==1)return 1;
		long ret = p - 1;
		for (long div = 2; div * div <= p - 1; ++div) {
			if ((p - 1) % div != 0) continue;
			if (pow(a, div) == 1) ret = Math.min(ret, div);
			else if (pow(a, (p - 1) / div) == 1) ret = Math.min(ret, (p - 1) / div);
		}
		return ret;
	}
	
	long pow(long a, long n){
		long ret=1;
		for(;n>0;n>>=1,a=a*a%MOD){
			if(n%2==1)ret=ret*a%MOD;
		}
		return ret;
	}
	
	// return x s.t. a^x = b && x>0
	long discretelog(long a, long b){
		if(a==1){
			if(b==1)
				return 1;
			else return -1;
		}else if(a==0){
			if(b==0)return 1;
			else return -1;
		}
		// a^(um+v) = b
		// a^v = b a^(-m)^u
		int m=(int)(Math.sqrt(MOD)+1);
		long pw=1;
		HashMap<Long,Integer> map=new HashMap<>();
		for(int v=0;v<=m;++v){
			map.put(pw,v);
			pw=pw*a%MOD;
		}
		long ima=pow(inv(a),m);
		long ipw=1;
		for(int i=0;i<=m;++i){
			if(map.containsKey(b*ipw%MOD)){
				long ret=i*m+map.get(b*ipw%MOD);
				if(ret!=0)return ret;
			}
			ipw=ipw*ima%MOD;
		}
		return -1;
	}
	
	long[][] invmat(long[][] a){
		if(det(a)==0)throw new AssertionError();
		long[][] ret=new long[2][2];
		ret[0][0]=a[1][1];
		ret[1][1]=a[0][0];
		ret[0][1]=(MOD-a[0][1])%MOD;
		ret[1][0]=(MOD-a[1][0])%MOD;
		for(int i=0;i<2;++i)for(int j=0;j<2;++j)ret[i][j]=ret[i][j]*inv(det(a))%MOD;
		return ret;
	}
	
	long gcd(long a,long b){
		if(a>b)return gcd(b,a);
		if(a==0)return b;
		return gcd(a,b%a);
	}
	
	long sqrt(long a, long p) {
		if (a == 0) return 0;
		int b = 0;
		while (pow((b * b % p - a + p) % p, (p - 1) / 2) != p - 1) ++b;
		long[] d = { 1, 0 };
		long[] m = { b, 1 };
		long n = (p + 1) / 2;
		for (; n > 0; n >>= 1, m = poly_mul(m, m, b, a, p)) {
			if (n % 2 == 1) d = poly_mul(d, m, b, a, p);
		}
		return d[0];
	}
	
	long[] poly_mul(long[] u, long[] v, long b, long a, long p) {
		long[] ret = new long[3];
		for (int i = 0; i < 2; ++i) {
			for (int j = 0; j < 2; ++j) {
				ret[i + j] += u[i] * v[j];
				ret[i + j] %= p;
			}
		}
		ret[0] += ret[2] * (b * b - a);
		ret[0] %= p;
		for (int i = 0; i < ret.length; ++i) {
			while (ret[i] < 0) ret[i] += p;
		}
		return Arrays.copyOf(ret, 2);
	}


	
	void tr(Object... objects) {
		System.out.println(Arrays.deepToString(objects));
	}

}