#include <bits/stdc++.h>

using namespace std;
const int N = 2e5 + 50;

int n, q, f[N], g[N], qx[N], qy[N];
bool ok[N];

struct tree_t {
	int fa[N], d[N], len[N], pos[N], col[N], ctot, vtot, vis[N];
	int dfn[N], siz[N], tot;
	vector<int> circ[N], G[N], H[N];
	bool in_cycle[N];
	void build(int *f) {
		for (int i = 1; i <= n; ++i) {
			fa[i] = f[i];
			G[fa[i]].push_back(i);
		}
	}
	void dfs(int x) {
		vis[x] = vtot;
		if (vis[fa[x]] == vtot) {
			int y = x, c = 0;
			++ctot;
			do {
				circ[ctot].push_back(y);
				col[y] = ctot;
				pos[y] = c;
				y = fa[y];
				in_cycle[y] = true;
				++c;
			} while (y != x);
			for (int x : circ[ctot])
				len[x] = circ[ctot].size();
		}
		else {
			if (!vis[fa[x]]) dfs(fa[x]);
			col[x] = col[fa[x]];
			len[x] = len[fa[x]];
			pos[x] = (pos[fa[x]] + len[x] - 1) % len[x];
		}
	}
	void dfs2(int x) {
		siz[x] = 1;
		dfn[x] = ++tot;
		for (int y : G[x]) if (!in_cycle[y]) {
			d[y] = d[x] + 1;
			dfs2(y);
			siz[x] += siz[y];
		}
	}
	void go() {
		for (int i = 1; i <= n; ++i) if (!vis[i]) {
			++vtot;
			dfs(i);
		}
		for (int i = 1; i <= ctot; ++i) {
			for (int x : circ[i]) {
				d[x] = 0;
				dfs2(x);
			}
		}
	}
} F, G;

void solve_stage1() {
	set<pair<tuple<int, int, int>, int>> s1;
	for (int i = 1; i <= q; ++i) if (!ok[i]) {
		int x = qx[i], y = qy[i];
		int g = gcd(F.len[x], G.len[y]);
		s1.emplace(make_tuple(F.col[x], G.col[y], ((F.pos[x] - G.pos[y]) % g + g) % g), i);
	}
	for (int v = 1; v <= n; ++v) if (F.in_cycle[v] && G.in_cycle[v]) {
		int g = gcd(F.len[v], G.len[v]);
		auto t = make_tuple(F.col[v], G.col[v], ((F.pos[v] - G.pos[v]) % g + g) % g);
		auto p = make_pair(t, -1);
		for (auto it = s1.lower_bound(p); ; it = s1.lower_bound(p)) {
			if (it == s1.end()) break;
			if (it->first != t) break;
			ok[it->second] = true;
			s1.erase(it);
		}
	}

}

vector<int> qu[N * 2], rect[N * 2];

inline int lowbit(int x) { return x & -x; }

struct fenwick_t {
	int t[N];
	vector<int> bin;
	inline void add(int p, int v) {
		++p;
		bin.push_back(p);
		for (; p < N; p += lowbit(p)) {
			t[p] += v;
		}
	}
	inline int query(int p) {
		++p;
		int val = 0;
		for (; p; p -= lowbit(p)) val += t[p];
		return val;
	}
	void clear() {
		for (int x : bin) {
			for (; x < N; x += lowbit(x)) t[x] = 0;
		}
		bin.clear();
	}
} T;

struct op_t {
	int x, y1, y2, v;
	op_t(int x, int y1, int y2, int v) : x(x), y1(y1), y2(y2), v(v) {
	}
	bool operator<(const op_t &rhs) const {
		return x < rhs.x;
	}
};

struct query_t {
	int x, y, i;
	query_t(int x, int y, int i) : x(x), y(y), i(i) {}
	bool operator<(const query_t &rhs) const {
		return x < rhs.x;
	}
};

void work(const vector<int> &queries, const vector<int> &rectangles, auto gen_query, auto gen_rect) {
	vector<op_t> op;
	vector<query_t> qu;
	for (int i : queries) {
		gen_query(i, qu);
	}
	for (int i : rectangles) {
		gen_rect(i, op);
	}
	sort(qu.begin(), qu.end()); sort(op.begin(), op.end());
	int p = 0;
	auto go = [&](const query_t &o) {
		assert(T.query(o.y) >= 0);
		if (T.query(o.y) > 0) {
			ok[o.i] = true;
		}
	};
	for (auto [x, y1, y2, v] : op) {
		while (p < (int)qu.size() && qu[p].x < x) go(qu[p++]);
		T.add(y1, v);
		T.add(y2 + 1, -v);
	}
	while (p < (int)qu.size()) go(qu[p++]);
	T.clear();
}

void solve_stage2() {
	for (int i = 0; i < 2 * N; ++i) qu[i].clear(), rect[i].clear();
	for (int i = 1; i <= q; ++i) if (!ok[i]) {
		int x = qx[i], y = qy[i];
		qu[F.d[x] - G.d[y] + N].push_back(i);
	}
	for (int v = 1; v <= n; ++v) if (!F.in_cycle[v] && !G.in_cycle[v]) {
		rect[F.d[v] - G.d[v] + N].push_back(v);
	}
	for (int i = 0; i < 2 * N; ++i)
		if (!qu[i].empty() && !rect[i].empty()) {
			work(qu[i], rect[i], [&](int i, auto &qu) {
				qu.emplace_back(F.dfn[qx[i]], G.dfn[qy[i]], i);	
			}, [&](int i, auto &op) {
				int x1 = F.dfn[i], x2 = F.dfn[i] + F.siz[i] - 1;
				int y1 = G.dfn[i], y2 = G.dfn[i] + G.siz[i] - 1;
				op.emplace_back(x1, y1, y2, 1);
				op.emplace_back(x2 + 1, y1, y2, -1);
				
			});
		}
}

void solve_stage3(tree_t &F, tree_t &G) {
	map<pair<int, int>, vector<int>> qu_map, rect_map;
	for (int i = 1; i <= q; ++i) if (!ok[i]) {
		int x = qx[i], y = qy[i];
		int L = F.len[x];
		auto p = make_pair(F.col[x], (F.pos[x] + G.d[y] + L) % L);
		qu_map[p].push_back(i);
	}
	for (int v = 1; v <= n; ++v) if (F.in_cycle[v] && !G.in_cycle[v]) {
		int L = F.len[v];
		auto p = make_pair(F.col[v], (F.pos[v] + G.d[v] + L) % L);
		rect_map[p].push_back(v);
	}
	for (auto p : qu_map) if (!qu_map[p.first].empty() && !rect_map[p.first].empty()) {
		work(qu_map[p.first], rect_map[p.first], [&](int i, auto &qu) {
			int x = qx[i], y = qy[i];
			qu.emplace_back(G.d[y] - F.d[x], G.dfn[y], i);
		}, [&](int i, auto &op) {
			int x = G.d[i];
			int y1 = G.dfn[i], y2 = G.dfn[i] + G.siz[i] - 1;
			op.emplace_back(x, y1, y2, 1);
		});	
	}
}

void gogo() {
	F.build(f), G.build(g);
	F.go(), G.go();
	solve_stage1();
	solve_stage2();
	solve_stage3(F, G);
	swap(qx, qy);
	solve_stage3(G, F);
}

int main() {
	ios::sync_with_stdio(false);
	cin.tie(nullptr);
	cout.tie(nullptr);
	cin >> n >> q;
	for (int i = 1; i <= n; ++i) cin >> f[i];
	for (int i = 1; i <= n; ++i) cin >> g[i];
	for (int i = 1; i <= q; ++i) {
		cin >> qx[i] >> qy[i];
	}
	gogo();
	for (int i = 1; i <= q; ++i) {
		cout << (ok[i] ? "YES" : "NO") << '\n';
	}
	return 0;
}