#include <iostream>
#include <vector>
#include <utility>

using namespace std;

typedef long long ll;

vector<vector<int>> orbits( vector<int> s ) {
	int n = s.size();
	vector<bool> visited( n, false );
	vector<vector<int>> orbits;
	for( int i = 0; i < n; ++i ) {
		if( not visited[i] ) {
			vector<int> orbit;
			do {
				visited[i] = true;
				orbit.push_back( i );
				i = s[i];
			} while( not visited[i] );
			orbits.push_back( move( orbit ) );
		}
	}
	return orbits;
}

vector<int> mult( vector<int> s, vector<int> t ) {
	int n = s.size();
	vector<int> u( n );
	for( int i = 0; i < n; ++i )
		u[i] = s[t[i]];
	return u;
}

vector<int> pow( vector<int> s, int k ) {
	int n = s.size();
	vector<int> t(n);
	for( int i = 0; i < n; ++i ) t[i] = i;
	while( k > 0 ) {
		if( k & 1 )
			t = mult( t, s );
		s = mult(s,s);
		k >>= 1;
	}
	return t;
}

vector<int> inverse( vector<int> s ) {
	int n = s.size();
	vector<int> t( n );
	for( int i = 0; i < n; ++i )
		t[s[i]] = i;
	return t;
}

ll egcd( ll a, ll b, ll &x, ll &y ) {
	ll xx = y = 0, yy = x = 1;
	while( b ) {
		x -= a / b * xx; swap( x, xx );
		y -= a / b * yy; swap( y, yy );
		a %= b; swap( a, b );
	}
	return a;
}

ll lcm( ll a, ll b ) {
	ll x, y;
	return a*b/egcd( a, b, x, y );
}

ll mod( ll a, ll b ) { 
	return (a %= b) < 0 ? a+b : a;
}

pair<ll,ll> crt( ll a, ll n, ll b, ll m ) { //n,m<=1e9
	ll s, t, d = egcd( n, m, s, t );
	if( mod( a-b, d ) ) // no solution exists 
		return { 0, -1 };
	return { mod(s*b%m*n + t*a%n*m, n*m)/d, n*m/d };
}

int main() {
	int n;
	cin >> n;
	vector<int> A(n), B(n), AB, Ainv;
	for( int i = 0; i < n; ++ i ) {
		cin >> A[i]; A[i]--;
	}
	for( int i = 0; i < n; ++ i ) {
		cin >> B[i]; B[i]--;
	}
	AB = mult( B, A );
	Ainv = inverse( A );
	auto O = orbits( AB );
	auto P = orbits( Ainv );
	ll k1 = 1, k2, lambda;
	pair<ll,ll> sol{ 0, 1 };

	// solution for even number of turns
	for( auto& o : O )
		k1 = lcm( k1, o.size() );
	k1 *= 2;

	// solution for odd number of turns
	if( O[0].size() % P[0].size() != 0 ) goto no_odd_sol;
	lambda = O[0].size() / P[0].size();
	// cerr << "(" << lambda << ")" << endl;
	AB = pow( AB, lambda );
	O = orbits( AB );
	if( O.size() != P.size() ) goto no_odd_sol;
	// cerr << "(" << O.size() << ")" << endl;
	for( int i = 0; i < O.size(); ++i ) {
		if( O[i][0] != P[i][0] or O[i].size() != P[i].size() ) 
			goto no_odd_sol;
		// cerr << "[" << i << "]" << endl;
		if( O[i].size() == 1 )
			continue;
		ll index;
		for( index = 1; index < O.size(); ++index )
			if( O[i][index] == P[i][1] ) break;
		if( O[i][index] != P[i][1] ) goto no_odd_sol;
		// cerr << index << endl;
		sol = crt( sol.first, sol.second, index, O[i].size() );
	}
	// cerr << sol.first << endl;
	k2 = 2*lambda*sol.first + 1;
	// cerr << k2 << endl;
	if( k2 < k1 and pow( AB, lambda*sol.first ) == Ainv )
		cout << k2 << endl;
	else {
no_odd_sol:
		cout << k1 << endl;
	}
}