#include <bits/stdc++.h>
#include <cstdio>
using namespace std;
using ll = long long;
const ll lim = (ll)1e18;
const int man = 100000 + 5;

int n, m, q;
ll a[man], b[man];

template <typename T>
struct SegTreeA {
	struct Node {
		int l, r;
		T pmax = -lim;
		T pmin = lim;
		T nmax = -lim;
		T nmin = lim;
		bool zero = false;
	};
	std::vector<Node> t;

	void pushup(int i) {
		auto &L = t[i << 1], &R = t[i << 1 | 1], &O = t[i];
		O.pmax = max(L.pmax, R.pmax);
		O.pmin = min(L.pmin, R.pmin);
		O.nmax = max(L.nmax, R.nmax);
		O.nmin = min(L.nmin, R.nmin);
		O.zero = L.zero || R.zero;
	}

	void build_privatelt(int l, int r, int i) {
		t[i].l = l;
		t[i].r = r;
		if (l == r) {
			T v = a[l];
			if (v > 0) {
				t[i].pmax = t[i].pmin = v;
			} else if (v < 0) {
				t[i].nmax = t[i].nmin = v;
			} else {
				t[i].zero = true;
			}
			return;
		}
		int mid = (l + r) >> 1;
		build_privatelt(l, mid, i << 1);
		build_privatelt(mid + 1, r, i << 1 | 1);
		pushup(i);
	}

	void build(int l, int r, int i, int size) {
		t.resize((size + 1) << 2);
		build_privatelt(l, r, 1);
	}

	Node query(int l, int r, int i) {
		if (l <= t[i].l && t[i].r <= r) return t[i];
		int mid = (t[i].l + t[i].r) >> 1;
		if (r <= mid)
			return query(l, r, i << 1);
		else if (l > mid)
			return query(l, r, i << 1 | 1);
		else {
			Node L = query(l, r, i << 1), R = query(l, r, i << 1 | 1), res;
			res.pmax = max(L.pmax, R.pmax);
			res.pmin = min(L.pmin, R.pmin);
			res.nmax = max(L.nmax, R.nmax);
			res.nmin = min(L.nmin, R.nmin);
			res.zero = L.zero || R.zero;
			return res;
		}
	}
};

template <typename T>
struct SegTreeB {
	struct Node {
		int l, r;
		T mx = -lim, mn = lim;
	};

	std::vector<Node> t;

	void build_privately(int l, int r, int i) {
		t[i].l = l;
		t[i].r = r;
		if (l == r) {
			t[i].mx = t[i].mn = b[l];
			return;
		}
		int mid = (l + r) >> 1;
		build_privately(l, mid, i << 1);
		build_privately(mid + 1, r, i << 1 | 1);
		t[i].mx = max(t[i << 1].mx, t[i << 1 | 1].mx);
		t[i].mn = min(t[i << 1].mn, t[i << 1 | 1].mn);
	}

	void build(int l, int r, int i, int size) {
		t.resize((size + 1) << 2);
		build_privately(l, r, 1);
	}

	Node query(int l, int r, int i) {
		if (l <= t[i].l && t[i].r <= r) return t[i];
		int mid = (t[i].l + t[i].r) >> 1;
		if (r <= mid)
			return query(l, r, i << 1);
		else if (l > mid)
			return query(l, r, i << 1 | 1);
		else {
			Node L = query(l, r, i << 1), R = query(l, r, i << 1 | 1), res;
			res.mx = max(L.mx, R.mx);
			res.mn = min(L.mn, R.mn);
			return res;
		}
	}
};

SegTreeA<ll> treeA;
SegTreeB<ll> treeB;

int main() {
	std::cin.tie(nullptr)->sync_with_stdio(false);
	freopen("csp2022_game.in", "r", stdin);
	freopen("csp2022_game.out", "w", stdout);
	cin >> n >> m >> q;
	for (int i = 1; i <= n; ++i)
		cin >> a[i];
	for (int j = 1; j <= m; ++j)
		cin >> b[j];
	treeA.build(1, n, 1, n);
	treeB.build(1, m, 1, m);

	while (q--) {
		int l1, r1, l2, r2;
		cin >> l1 >> r1 >> l2 >> r2;
		auto A = treeA.query(l1, r1, 1);
		auto B = treeB.query(l2, r2, 1);

		ll ans = -lim;
		if (A.pmax != -lim) {
			if (B.mn >= 0) {
				ans = max(ans, A.pmax * B.mn);
			} else if (A.pmin != lim) {
				ans = max(ans, A.pmin * B.mn);
			}
		}
		
		if (B.mx >= 0) {
			if (A.nmax != -lim) {
				ans = max(ans, A.nmax * B.mx);
			}
		} else {
			if (A.nmin != lim) {
				ans = max(ans, A.nmin * B.mx);
			}
		}
		if (A.zero) {
			ans = max(ans, 0LL);
		}

		cout << ans << "\n";
	}
	return 0;
}