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

#define BOUND	1000000000000LL // 1e12

using namespace std;

typedef long long ll;

bool mult_overflow( ll a, ll b ) {
	return BOUND/a < b;
}

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 gcd( ll a, ll b ) {
	ll u, v;
	return egcd( a, b, u, v );
}

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

class permutation {
	vector<int> map;
	vector<vector<int>> orbits;
	vector<pair<int,int>> orbit_map;
public:
	int pow_at( ll n, int b ) {
		int x = orbit_map[b].first, y = orbit_map[b].second, z = orbits[x].size();
		return orbits[x][mod(y+n,z)];
	}
	ll order() const {
		ll x = 1, y;
		for( const auto& O : orbits ) {
			y = O.size() / gcd( x, O.size() );
			if( mult_overflow(x,y) )
				return 0;
			x *= y;
		}
		return x;
	}
	ll dist( ll n, ll a, ll b ) {
		int x1 = orbit_map[a].first, x2 = orbit_map[b].first;
		if( x1 != x2 )
			return -1;
		ll z = orbits[x1].size();
		ll ninv, temp, d = egcd( n, z, ninv, temp );
		ll z2 = z / d;
		ll y1 = orbit_map[a].second, y2 = orbit_map[b].second;
		ll w = y2-y1+z;
		if( w % d != 0 )
			return -1;
		return mod( ninv*( w / d ), z2 );
	}
	ll local_order( ll n, int a ) {
		ll m = orbits[orbit_map[a].first].size();
		return m / gcd( n, m );
	}
	permutation( vector<int>&& v ) {
		map = v;
		int n = map.size();
		orbit_map.resize( n );
		vector<bool> visited( n, false );
		for( int i = 0; i < n; ++i ) {
			if( not visited[i] ) {
				vector<int> orbit;
				do {
					visited[i] = true;
					orbit_map[i].first = orbits.size();
					orbit_map[i].second = orbit.size();
					orbit.push_back( i );
					i = map[i];
				} while( not visited[i] );
				orbits.push_back( move( orbit ) );
			}
		}
	}
};

int main() {
	// read input
	int n;
	cin >> n;
	vector<int> Aseq(n), Bseq(n);
	for( int i = 0; i < n; ++i ) {
		cin >> Aseq[i];
		Aseq[i]--; 
	}
	for( int i = 0; i < n; ++i ) {
		cin >> Bseq[i];
		Bseq[i]--; 
	}

	// translate problem
	vector<int> BAseq(n), Ainvseq(n);
	for( int i = 0; i < n; ++i )
		BAseq[i] = Bseq[Aseq[i]];
	for( int i = 0; i < n; ++i )
		Ainvseq[Aseq[i]] = i;
	permutation BA( move(BAseq) );

	// === trivial case
	// solve (BA)^p = 1 for n 
	ll sol = 2*BA.order(), sol2;

	// === hard case
	// solve A (BA)^p = 1
	ll lp = 0, rp = 1;
	bool correct = true;
	for( int i = 0; i < n; ++i ) {
		ll d = BA.dist( rp, i, BA.pow_at( -lp, Ainvseq[i] ) );
		if( d == -1 )
			goto no_hard_sol;
		lp += rp*d;
		ll o = BA.local_order( rp, i );
		if( mult_overflow( rp, o ) )
			break;
		rp *= o;
	}
	sol2 = 2*lp+1; 
	// verify answer in case of overflows
	for( int i = 0; i < n; ++i ) {
		if( BA.pow_at(lp,i) != Ainvseq[i] ) {
			correct = false;
			break;
		}
	}
	if( correct )
		sol = sol2;
	
no_hard_sol:
	if( sol > BOUND )
		sol = 0;
	if( sol == 0 )
		cout << "huge" << endl;
	else
		cout << sol << endl;
}