二分答案，可以忽略快读部分，主体在中间

/**
 * @author: Xile
 * @date: 2024-01-23 21:13:17
 **/

#include <bits/stdc++.h>

using namespace std;

namespace Fast_I {
	char *_Buf, *_Start_ptr, *_End_ptr;
	std::streambuf* inbuf;
	unsigned int Size;
	bool _Ok;
	
	struct Fast_Istream {
		operator bool() { return _Ok; }
		Fast_Istream(std::streambuf*, unsigned int);
		Fast_Istream(unsigned int);
		Fast_Istream(const char*, unsigned int);
		Fast_Istream& operator>>(char&);
		Fast_Istream& operator>>(char*);
		Fast_Istream& operator>>(bool&);
		Fast_Istream& operator>>(short&);
		Fast_Istream& operator>>(int&);
		Fast_Istream& operator>>(long&);
		Fast_Istream& operator>>(long long&);
		Fast_Istream& operator>>(unsigned short&);
		Fast_Istream& operator>>(unsigned int&);
		Fast_Istream& operator>>(unsigned long&);
		Fast_Istream& operator>>(unsigned long long&);
		Fast_Istream& operator>>(float&);
		Fast_Istream& operator>>(double&);
		Fast_Istream& operator>>(long double&);
		Fast_Istream& operator>>(std::string&);
		template <typename Typex>
		void operator()(Typex& _Val) { *this >> _Val; }
		template <typename Typex, typename... More>
		void operator()(Typex&, More&...);
		std::streambuf* rdbuf() { return inbuf; }
		void rdbuf(std::streambuf* _inbuf) { inbuf = _inbuf; }
		void rdbuf(const char*);
		void pop();
		char peek();
	};
}  // namespace Fast_I
namespace Fast_O {
	std::string buf;
	std::streambuf* outbuf;
	
	struct Fast_Ostream {
		Fast_Ostream(std::streambuf*, unsigned int);
		Fast_Ostream(std::streambuf* out) { outbuf = out; }
		Fast_Ostream(const char*, unsigned int);
		Fast_Ostream(unsigned int);
		void flush();
		~Fast_Ostream();
		void endl() { buf.push_back('\n'); }
		template <typename Typex>
		void endl(const Typex& _Val);
		template <typename Typex, typename... More>
		void endl(const Typex&, const More&...);
		template <typename Typex>
		void operator()(const Typex& _Val);
		template <typename Typex, typename... More>
		void operator()(const Typex&, const More&...);
		Fast_Ostream& operator<<(char);
		Fast_Ostream& operator<<(const char*);
		Fast_Ostream& operator<<(const std::string&);
		Fast_Ostream& operator<<(bool);
		Fast_Ostream& operator<<(short);
		Fast_Ostream& operator<<(int);
		Fast_Ostream& operator<<(long);
		Fast_Ostream& operator<<(long long);
		Fast_Ostream& operator<<(unsigned short);
		Fast_Ostream& operator<<(unsigned int);
		Fast_Ostream& operator<<(unsigned long);
		Fast_Ostream& operator<<(unsigned long long);
		std::streambuf* rdbuf() { return outbuf; }
		void rdbuf(std::streambuf* _outbuf) { outbuf = _outbuf; }
		void rdbuf(const char*);
	};
}  // namespace Fast_O
namespace Fast_IO {
	Fast_I::Fast_Istream fin(std::cin.rdbuf(), 1048576);  // 1 MB
	Fast_O::Fast_Ostream fout(std::cout.rdbuf());         // 鈭?
}  // namespace Fast_IO

#define read Fast_IO::fin
#define write Fast_IO::fout

#define int long long

const int N = 2e3 + 5, INF = 1e18 + 5;

int n, S, T;
int a[N], b[N], c[N], cnt[N];

struct Edge{int to, next, val, dis;}edge[1000006], e[1000006];
int head[N], tot = 1, tt;
void add_edge(int x, int y, int v, int d) {
	edge[++tot] = {y, head[x], v, d}; head[x] = tot;
	edge[++tot] = {x, head[y], 0, -d}; head[y] = tot;
}

int get_cnt(int x) {
	int res = 0;
	for (int i = 2; i <= x; i++) {
		while (x % i ==0) {
			x /= i;
			res++;
		}
	}
	return res;
}

int dis[N], pre[N], incf[N];
bitset<N> vis;
bool spfa() {
	vis.reset();
	for (int i = 0; i <= n + 3; i++) {
		dis[i] = -INF;
		pre[i] = incf[i] = 0;
	}
	queue<int> q;
	dis[S] = 0, incf[S] = INF;
	q.push(S);
	vis[S] = 1;
	while (q.size()) {
		int x = q.front();
		q.pop();
		vis[x] = 0;
		for (int i = head[x]; i; i = edge[i].next) {
			int y = edge[i].to;
			if (dis[y] < dis[x] + edge[i].dis && edge[i].val) {
				dis[y] = dis[x] + edge[i].dis;
				incf[y] = min(incf[x], edge[i].val);
				pre[y] = i;
				if (!vis[y]) {
					vis[y] = 1;
					q.push(y);
				}
			}
		}
	}
	return pre[T] > 0;
}
int ans2;
void update() {
	int now = T;
	while (now != S) {
		int i = pre[now];
		edge[i].val -= incf[T];
		edge[i ^ 1].val += incf[T];
		now = edge[i ^ 1].to;
	}
	ans2 += incf[T] * dis[T];
}

bool check(int mid) {
	ans2 = 0;
	for (int i = 1; i <= tt; i++) edge[i] = e[i];
	edge[tot].val = edge[tot - 2].val = 0;
	edge[tot - 1].val = edge[tot - 3].val = mid;
	while (spfa()) update();
	return ans2 >= 0;
}

signed main() {
	read(n);
	for (int i = 1; i <= n; i++) read(a[i]);
	for (int i = 1; i <= n; i++) read(b[i]);
	for (int i = 1; i <= n; i++) read(c[i]);
	S = 0, T = n + 1;
	for (int i = 1; i <= n; i++) cnt[i] = get_cnt(a[i]);
	for (int i = 1; i <= n; i++) {
		if (cnt[i] & 1) add_edge(S, i, b[i], 0);
		else add_edge(i, T, b[i], 0);
	}
	for (int i = 1; i <= n; i++) 
		if (cnt[i] % 2 != 0) 
			for (int j = 1; j <= n; j++) 
				if (cnt[j] % 2 == 0) 
					if ((cnt[i] + 1 == cnt[j] && a[j] % a[i] == 0) || (cnt[j] + 1 == cnt[i] && a[i] % a[j] == 0)) 
//						cout << i << "---" << j << '\n',
						add_edge(i, j, INF, c[i] * c[j]);
	for (int i = 1; i <= tot; i++) e[i] = edge[i];
	tt =  tot;
	S = n + 2, T = n + 3;
	add_edge(S, 0, 0, 0);
	add_edge(n + 1, T, 0, 0);
	int l = 0, r = INF, ans = -1;
	while (l <= r) {
		int mid = (l + r) >> 1;
		if (check(mid)) ans = mid, l = mid + 1;
		else r = mid - 1;
	}
	write(ans, '\n');
	
	return 0;
}

#undef int

namespace Fast_I {
	Fast_Istream::Fast_Istream(std::streambuf* in, unsigned int Sz) {
		_Ok = 1;
		Fast_I::Size = Sz;
		inbuf = in;
		_Start_ptr = _End_ptr = _Buf = new char[Sz];
	}
	Fast_Istream::Fast_Istream(const char* in, unsigned int Sz) {
		_Ok = 1;
		Fast_I::Size = Sz;
		rdbuf(in);
		_Start_ptr = _End_ptr = _Buf = new char[Sz];
	}
	Fast_Istream::Fast_Istream(unsigned int Sz) {
		_Ok = 1;
		Fast_I::Size = Sz;
		_Start_ptr = _End_ptr = _Buf = new char[Sz];
	}
	void Fast_Istream::rdbuf(const char* File) {
		static std::ifstream __In__(File);
		rdbuf(__In__.rdbuf());
	}
	void Get_Char(char& _Val) {
		if (_Start_ptr == _End_ptr) {
			_Start_ptr = _Buf;
			_End_ptr = _Buf + inbuf->sgetn(_Buf, Size);
		}
		if (_Start_ptr == _End_ptr) {
			_Val = -1;
			_Ok = 0;
		} else {
			_Val = *_Start_ptr++;
		}
	}
	Fast_Istream& Fast_Istream::operator>>(char& _Val) {
		if (_Ok) {
			Get_Char(_Val);
			while (_Val == 32 || _Val == 10 || _Val == 13 || _Val == 8 || _Val == 9 ||
				_Val == 7 || _Val == 12 || _Val == 11) {
				Get_Char(_Val);
			}
		}
		return *this;
	}
	Fast_Istream& Fast_Istream::operator>>(char* _Val) {
		if (_Ok) {
			Get_Char(*_Val);
			while (*_Val == 32 || *_Val == 10 || *_Val == 13 || *_Val == 8 ||
				*_Val == 9 || *_Val == 7 || *_Val == 12 || *_Val == 11) {
				Get_Char(*_Val);
			}
			while (*_Val != 32 && *_Val != 10 && *_Val && *_Val != -1 && *_Val != 9 &&
				*_Val != 11 && *_Val != 12) {
				Get_Char(*++_Val);
			}
			*_Val = 0;
			--_Start_ptr;
		}
		return *this;
	}
	Fast_Istream& Fast_Istream::operator>>(std::string& _Val) {
		if (_Ok) {
			char c;
			Get_Char(c);
			while (c == 32 || c == 10 || c == 13 || c == 8 || c == 9 || c == 7 ||
				c == 12 || c == 11) {
				Get_Char(c);
			}
			for (_Val.clear();
				c != 32 && c != 10 && c && c != -1 && c != 9 && c != 11 && c != 12;
				Get_Char(c)) {
				_Val.push_back(c);
			}
			--_Start_ptr;
		}
		return *this;
	}
	template <typename Typex>
	void Get_Int(Typex& _Val) {
		if (_Ok) {
			char ch;
			bool _F = 0;
			for (Get_Char(ch); (ch < 48 || ch > 57) && ch != -1; Get_Char(ch)) {
				_F = ch == 45;
			}
			for (_Val = 0; ch > 47 && ch < 58 && ch != -1; Get_Char(ch)) {
				_Val = _Val * 10 + (ch ^ 48);
			}
			if (_F) {
				_Val = ~_Val + 1;
			}
			--_Start_ptr;
		}
	}
	template <typename Typex>
	void Get_Unsigned(Typex& _Val) {
		if (_Ok) {
			char ch;
			Get_Char(ch);
			while ((ch < 48 || ch > 57) && ch != -1) {
				Get_Char(ch);
			}
			for (_Val = 0; ch > 47 && ch < 58 && ch != -1; Get_Char(ch)) {
				_Val = _Val * 10 + (ch ^ 48);
			}
			--_Start_ptr;
		}
	}
	template <typename Typex>
	void Get_Double(Typex& _Val) {
		if (_Ok) {
			char ch;
			bool _F = 0;
			for (Get_Char(ch); (ch < 48 || ch > 57) && ch != -1; Get_Char(ch)) {
				_F = ch == 45;
			}
			for (_Val = 0; ch > 47 && ch < 58 && ch != -1; Get_Char(ch)) {
				_Val = _Val * 10 + (ch ^ 48);
			}
			if (ch == 46) {
				unsigned long long _Pow = 1;
				for (Get_Char(ch); ch > 47 && ch < 58 && ch != -1; Get_Char(ch)) {
					_Val += Typex((ch ^ 48) * 1.0 / (_Pow *= 10));
				}
			}
			if (_F) {
				_Val = -_Val;
			}
			--_Start_ptr;
		}
	}
	Fast_Istream& Fast_Istream::operator>>(bool& _Val) {
		if (_Ok) {
			char ch;
			Get_Char(ch);
			while (ch == 32 || ch == 10 || ch == 13 || ch == 8 || ch == 9 || ch == 7 ||
				ch == 12 || ch == 11) {
				Get_Char(ch);
			}
			while (ch != 32 && ch != 10 && ch && ch != -1 && ch != 9 && ch != 11 &&
				ch != 12) {
				_Val |= ch != 48;
				Get_Char(ch);
			}
			--_Start_ptr;
		}
		return *this;
	}
	Fast_Istream& Fast_Istream::operator>>(short& _Val) {
		Get_Int(_Val);
		return *this;
	}
	Fast_Istream& Fast_Istream::operator>>(int& _Val) {
		Get_Int(_Val);
		return *this;
	}
	Fast_Istream& Fast_Istream::operator>>(long& _Val) {
		Get_Int(_Val);
		return *this;
	}
	Fast_Istream& Fast_Istream::operator>>(long long& _Val) {
		Get_Int(_Val);
		return *this;
	}
	Fast_Istream& Fast_Istream::operator>>(unsigned short& _Val) {
		Get_Unsigned(_Val);
		return *this;
	}
	Fast_Istream& Fast_Istream::operator>>(unsigned int& _Val) {
		Get_Unsigned(_Val);
		return *this;
	}
	Fast_Istream& Fast_Istream::operator>>(unsigned long& _Val) {
		Get_Unsigned(_Val);
		return *this;
	}
	Fast_Istream& Fast_Istream::operator>>(unsigned long long& _Val) {
		Get_Unsigned(_Val);
		return *this;
	}
	Fast_Istream& Fast_Istream::operator>>(float& _Val) {
		Get_Double(_Val);
		return *this;
	}
	Fast_Istream& Fast_Istream::operator>>(double& _Val) {
		Get_Double(_Val);
		return *this;
	}
	Fast_Istream& Fast_Istream::operator>>(long double& _Val) {
		Get_Double(_Val);
		return *this;
	}
	template <typename Typex, typename... More>
	void Fast_Istream::operator()(Typex& _Val, More&... _More) {
		*this >> _Val;
		operator()(_More...);
	}
	void Fast_Istream::pop() {
		char ch;
		Get_Char(ch);
	}
	char Fast_Istream::peek() {
		if (_Start_ptr == _End_ptr) {
			_Start_ptr = _Buf;
			_End_ptr = _Buf + inbuf->sgetn(_Buf, Size);
		}
		if (_Start_ptr == _End_ptr) {
			_Ok = 0;
			return -1;
		} else {
			return *_Start_ptr;
		}
	}
}  // namespace Fast_I
namespace Fast_O {
	Fast_Ostream::Fast_Ostream(std::streambuf* out, unsigned int Size) {
		buf.reserve(Size);
		outbuf = out;
	}
	Fast_Ostream::Fast_Ostream(const char* File, unsigned int Size) {
		buf.reserve(Size);
		rdbuf(File);
	}
	void Fast_Ostream::rdbuf(const char* File) {
		static std::ofstream __Out__(File);
		rdbuf(__Out__.rdbuf());
	}
	Fast_Ostream::Fast_Ostream(unsigned int Size) {
		buf.reserve(Size);
	}
	void Fast_Ostream::flush() {
		outbuf->sputn(buf.data(), buf.size());
		buf.clear();
	}
	Fast_Ostream::~Fast_Ostream() {
		flush();
	}
	Fast_Ostream& Fast_Ostream::operator<<(char _Val) {
		buf.push_back(_Val);
		return *this;
	}
	Fast_Ostream& Fast_Ostream::operator<<(const char* _Val) {
		while (*_Val) {
			buf.push_back(*_Val++);
		}
		return *this;
	}
	Fast_Ostream& Fast_Ostream::operator<<(const std::string& _Val) {
		for (auto&& i : _Val) {
			buf.push_back(i);
		}
		return *this;
	}
	template <typename Typex>
	void Put_Unsigned(Typex _Val) {
		char* _Stack = (char*)malloc(sizeof(Typex) * 3);
		unsigned S_top = 0;
		while (_Val) {
			_Stack[++S_top] = (_Val % 10) ^ 48;
			_Val /= 10;
		}
		if (!S_top) {
			buf.push_back('0');
		}
		while (S_top) {
			buf.push_back(_Stack[S_top--]);
		}
		free(_Stack);
	}
	void Put_Int(long long _Val) {
		if (_Val < 0) {
			buf.push_back('-');
			Put_Unsigned(~_Val + 1);
		} else {
			Put_Unsigned(_Val);
		}
	}
	Fast_Ostream& Fast_Ostream::operator<<(bool _Val) {
		buf.push_back(_Val ? '1' : '0');
		return *this;
	}
	Fast_Ostream& Fast_Ostream::operator<<(short _Val) {
		Put_Int(_Val);
		return *this;
	}
	Fast_Ostream& Fast_Ostream::operator<<(int _Val) {
		Put_Int(_Val);
		return *this;
	}
	Fast_Ostream& Fast_Ostream::operator<<(long _Val) {
		Put_Int(_Val);
		return *this;
	}
	Fast_Ostream& Fast_Ostream::operator<<(long long _Val) {
		Put_Int(_Val);
		return *this;
	}
	Fast_Ostream& Fast_Ostream::operator<<(unsigned short _Val) {
		Put_Unsigned(_Val);
		return *this;
	}
	Fast_Ostream& Fast_Ostream::operator<<(unsigned int _Val) {
		Put_Unsigned(_Val);
		return *this;
	}
	Fast_Ostream& Fast_Ostream::operator<<(unsigned long _Val) {
		Put_Unsigned(_Val);
		return *this;
	}
	Fast_Ostream& Fast_Ostream::operator<<(unsigned long long _Val) {
		Put_Unsigned(_Val);
		return *this;
	}
	template <typename Typex>
	void Fast_Ostream::endl(const Typex& _Val) {
		*this << _Val << '\n';
	}
	template <typename Typex, typename... More>
	void Fast_Ostream::endl(const Typex& _Val, const More&... _More) {
		*this << _Val;
		endl(_More...);
	}
	template <typename Typex>
	void Fast_Ostream::operator()(const Typex& _Val) {
		*this << _Val;
	}
	template <typename Typex, typename... More>
	void Fast_Ostream::operator()(const Typex& _Val, const More&... _More) {
		*this << _Val;
		operator()(_More...);
	}
}  // namespace Fast_O