#include <bits/stdc++.h>
using namespace std;

#if __cplusplus < 202002L
template <class T> int ssize(const T& a){ return a.size(); }
#endif
template <class T1, class T2> istream& operator>> (istream& in, pair <T1, T2>& a){ in >> a.first >> a.second; return in; }
template <class T> istream& operator>> (istream& in, vector <T>& a){ for (auto &x: a){ in >> x; } return in; }
 
using ll = long long;
using ld = long double;

template<class T, class F>
struct sparse_table{
#ifdef LOCAL
	#define ASSERT(x) assert(x)
#else
	#define ASSERT(x) 42
#endif
	int n;
	vector<vector<T>> data;
	F TT;
	T T_id;
	sparse_table(F TT, T T_id): TT(TT), T_id(T_id){ }
	sparse_table &operator=(const sparse_table &st){
		n = st.n;
		data = st.data;
		return *this;
	}
	friend void swap(sparse_table &stl, sparse_table &str){
		swap(stl.n, str.n);
		swap(stl.data, str.data);
	}
	// O(n * log(n))
	void build(const vector<T> &a){
		n = (int)a.size();
		if (ssize(data) < 1){
			data.resize(1);
		}
		data[0] = a;
		for(auto p = 1, i = 1; p << 1 <= n; p <<= 1, ++ i){
			if (ssize(data) <= i){
				data.resize(i + 1);
			}
			data[i].resize(n - (p << 1) + 1);
			for(auto j = 0; j < (int)data[i].size(); ++ j) data[i][j] = TT(data[i - 1][j], data[i - 1][j + p]);
		}
	}
	// O(1)
	T query(int l, int r) const{
		ASSERT(0 <= l && l <= r && r <= n);
		if(l == r) return T_id;
		int d = __lg(r - l);
		return TT(data[d][l], data[d][r - (1 << d)]);
	}
#undef ASSERT
};
template<class T, class F>
auto make_sparse_table(F TT, T T_id){
	return sparse_table(TT, T_id);
}
template<class T>
auto make_rminq(T inf = numeric_limits<T>::max()){
	return sparse_table([&](const T &x, const T &y){ return min(x, y); }, inf);
}
template<class T>
auto make_rmaxq(T minf = numeric_limits<T>::min()){
	return sparse_table([&](const T &x, const T &y){ return max(x, y); }, minf);
}

vector <ll> build_teams(vector <int> A1, vector <int> B1, vector <int> A2, vector <int> B2, vector <int> L1, vector <int> R1, vector <int> L2, vector <int> R2){
	auto n = ssize(A1), m = ssize(A2), q = ssize(L1);

	vector <ll> ans(q);

	vector <pair <ll, int>> opt(max(n, m));
	auto sptb = make_rmaxq(numeric_limits <pair <ll, int>>::min());
	auto dnc1 = [&](auto&& self, int l1, int r1, int l2, int r2)->void{
		auto m1 = (l1 + r1) >> 1;
		opt[m1] = {numeric_limits <ll>::min(), -1};
		for (auto j = l2; j <= r2; j++){
			opt[m1] = max(opt[m1], pair <ll, int>{ll(A1[m1] + A2[j]) * (B1[m1] + B2[j]), j});
		}
		auto m2 = opt[m1].second;
		if (l1 <= m1 - 1){
			self(self, l1, m1 - 1, m2, r2);
		}
		if (m1 + 1 <= r1){
			self(self, m1 + 1, r1, l2, m2);
		}
	};
	auto dnc2 = [&](auto&& self, int l1, int r1, int l2, int r2)->void{
		auto m2 = (l2 + r2) >> 1;
		opt[m2] = {numeric_limits <ll>::min(), -1};
		for (auto i = l1; i <= r1; i++){
			opt[m2] = max(opt[m2], pair <ll, int>{ll(A1[i] + A2[m2]) * (B1[i] + B2[m2]), i});
		}
		auto m1 = opt[m2].second;
		if (l2 <= m2 - 1){
			self(self, m1, r1, l2, m2 - 1);
		}
		if (m2 + 1 <= r2){
			self(self, l1, m1, m2 + 1, r2);
		}
	};

	vector <pair <int, int>> block_range_1(q, pair{n, -1});
	const auto S1 = int(sqrt(n));
	for (auto l = 0, r = min(S1 - 1, n - 1); l < n; l = r + 1, r = min(r + S1, n - 1)){
		dnc2(dnc2, l, r, 0, m - 1);
		sptb.build(opt);

		for (auto iq = 0; iq < q; iq++){
			if (L1[iq] <= l and r <= R1[iq]){
				block_range_1[iq].first = min(block_range_1[iq].first, l);
				block_range_1[iq].second = max(block_range_1[iq].second, r);

				ans[iq] = max(ans[iq], sptb.query(L2[iq], R2[iq] + 1).first);
			}
		}
	}

	vector <pair <int, int>> block_range_2(q, pair{m, -1});
	const auto S2 = int(sqrt(m));
	for (auto l = 0, r = min(S2 - 1, m - 1); l < m; l = r + 1, r = min(r + S2, m - 1)){
		dnc1(dnc1, 0, n - 1, l, r);
		sptb.build(opt);

		for (auto iq = 0; iq < q; iq++){
			if (L2[iq] <= l and r <= R2[iq]){
				block_range_2[iq].first = min(block_range_2[iq].first, l);
				block_range_2[iq].second = max(block_range_2[iq].second, r);

				ans[iq] = max(ans[iq], sptb.query(L1[iq], R1[iq] + 1).first);
			}
		}
	}

	for (auto iq = 0; iq < q; iq++){
		vector <pair <int, int>> range_1, range_2;
		if (block_range_1[iq].second == -1){
			range_1.emplace_back(L1[iq], R1[iq]);
		}
		else{
			if (L1[iq] < block_range_1[iq].first){
				range_1.emplace_back(L1[iq], block_range_1[iq].first - 1);
			}
			if (block_range_1[iq].second < R1[iq]){
				range_1.emplace_back(block_range_1[iq].second + 1, R1[iq]);
			}
		}
		if (block_range_2[iq].second == -1){
			range_2.emplace_back(L2[iq], R2[iq]);
		}
		else{
			if (L2[iq] < block_range_2[iq].first){
				range_2.emplace_back(L2[iq], block_range_2[iq].first - 1);
			}
			if (block_range_2[iq].second < R2[iq]){
				range_2.emplace_back(block_range_2[iq].second + 1, R2[iq]);
			}
		}

		for (auto &[l1, r1]: range_1){
			for (auto &[l2, r2]: range_2){
				dnc2(dnc2, l1, r1, l2, r2);
				for (auto j = l2; j <= r2; j++){
					ans[iq] = max(ans[iq], opt[j].first);
				}
			}
		}
	}

	return ans;
}

#ifndef ONLINE_JUDGE
signed main(){
	ios_base::sync_with_stdio(false);
	cin.tie(nullptr);

	int n, m, q;
	cin >> n >> m >> q;
	vector <int> A1(n), B1(n), A2(m), B2(m), L1(q), R1(q), L2(q), R2(q);
	cin >> A1 >> B1 >> A2 >> B2;
	for (auto iq = 0; iq < q; iq++){
		cin >> L1[iq] >> R1[iq] >> L2[iq] >> R2[iq];
	}

	vector <ll> ans = build_teams(A1, B1, A2, B2, L1, R1, L2, R2);
	for (auto iq = 0; iq < q; iq++){
		cout << ans[iq] << "\n";
	}
}
#endif