#include <iostream>
#include <vector>
using namespace std;

using T = long long;

long long mod(long long a, long long m) { return (a % m + m) % m; }
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
long long lcm(long long a, long long b) { return a / gcd(a, b) * b; }
constexpr long long M = 1e12;

pair<T, T> crt(T a1, T m1, T a2, T m2) {
	// Make sure m1 is the larger of the two.
	if (m1 < m2) swap(m1, m2), swap(a1, a2);
	if(m1 > M){
		if(a1 % m2 == a2) return {a1, m1};
		return {-1,-1};
	}
	while (a1 % m2 != a2) a1 += m1;
	// WA is here.
	auto g = gcd(m1, m2);
	//if(m1/g > M/m2) return {a1>M? M+1 : a1, M+1};
	return {a1, m1/g*m2};
}

using P = vector<int>;
P operator*(const P& l, const P& r) {
	P p(l.size());
	for (int i = 0; i < l.size(); ++i) p[i] = r[l[i]];
	return p;
}

long long order(const P& p) {
	long long o = 1;
	vector<bool> done(p.size(), false);
	for (int i = 0; i < p.size(); ++i) {
		if (done[i]) continue;
		int l = 0;
		while (!done[i]) done[i] = true, i = p[i], ++l;
		auto oldo = o;
		o = lcm(o, l);
		cerr << oldo << " " << o << " " << o%oldo << endl;
		// WA is here.
		if(o > M /*or o%oldo != 0*/) return M+1;
	}
	return o;
}

void print(long long n){
	if(n > M) cout << "huge\n";
	else cout << n << endl;
}

int main() {
	int n;
	cin >> n;
	P a(n), b(n);
	for (auto& x : a) cin >> x, --x;
	for (auto& x : b) cin >> x, --x;
	auto ab = a * b;

	// Solve for even number of turns.
	auto even = 2 * order(ab);

	cerr << "even: " << even << endl;

	// Solve for odd number of turns:
	// The cycle structure of A*B must become equal to that of A^-1
	pair<T, T> odd{0, 1};
	P ai(n);
	for (int i = 0; i < n; ++i) ai[a[i]] = i;
	vector<bool> done(n, false);
	for (int i = 0; i < n; ++i) {
		if (done[i]) continue;
		int target = ai[i];
		int period = 0, offset = -1;
		do {
			if (i == target) offset = period;
			done[i] = true;
			i = ab[i], ++period;
		} while (!done[i]);
		// Make sure that the rest of the cycle also maps correctly after
		// rotating.
		for (int k = 0; offset >= 0 and k < period; ++k) {
			if (ai[i] != target) offset = -1;
			i = ab[i];
			target = ab[target];
		}
		if (offset == -1) {
			print(even);
			return 0;
		}
		odd = crt(odd.first, odd.second, offset, period);
		cerr << odd.first << ' ' << odd.second << endl;
		if (odd.second == -1) {
			print(even);
			return 0;
		}
	}
	print(min(even, 2 * (long long)odd.first + 1));
}