/**************************************************************** 
 * Description: 
 * Author: Alex Li
 * Date: 2024-08-15 12:35:34
 * LastEditTime: 2024-08-15 13:20:55
****************************************************************/
#include <iostream>
#include <vector>
#include <algorithm>
#include <climits>
using namespace std;

// 获取区间内最大值
int getMaxInRange(const vector<int>& arr, int l, int r) {
    return *max_element(arr.begin() + l - 1, arr.begin() + r);
}

// 获取区间内最小值
int getMinInRange(const vector<int>& arr, int l, int r) {
    return *min_element(arr.begin() + l - 1, arr.begin() + r);
}

// 获取区间内的正数最小值
int getMinPositiveInRange(const vector<int>& arr, int l, int r) {
    int minPos = INT_MAX;
    for (int i = l - 1; i < r; ++i) {
        if (arr[i] > 0) {
            minPos = min(minPos, arr[i]);
        }
    }
    return minPos == INT_MAX ? -1 : minPos;
}

// 获取区间内的负数最大值
int getMaxNegativeInRange(const vector<int>& arr, int l, int r) {
    int maxNeg = INT_MIN;
    for (int i = l - 1; i < r; ++i) {
        if (arr[i] < 0) {
            maxNeg = max(maxNeg, arr[i]);
        }
    }
    return maxNeg == INT_MIN ? 1 : maxNeg;
}

// 检查区间内是否有零
bool hasZeroInRange(const vector<int>& arr, int l, int r) {
    for (int i = l - 1; i < r; ++i) {
        if (arr[i] == 0) {
            return true;
        }
    }
    return false;
}

int main() {
    int n, m, q;
    cin >> n >> m >> q;
    int p=q;
    vector<int> A(n), B(m),re(q+10);
    for (int i = 0; i < n; ++i) cin >> A[i];
    for (int i = 0; i < m; ++i) cin >> B[i];
    
    while (q--) {
        int l1, r1, l2, r2;
        cin >> l1 >> r1 >> l2 >> r2;
        
        // 判断 B 的情况
        int maxB = getMaxInRange(B, l2, r2);
        int minB = getMinInRange(B, l2, r2);

        bool hasPositiveB = (minB > 0);
        bool hasNegativeB = (maxB < 0);

        int result;
        
        if (hasPositiveB) {
            int maxA = getMaxInRange(A, l1, r1);
            if (maxA > 0) {
                result = maxA * minB;  // A 有正数，取 A 的最大值和 B 的最小值
            } else {
                result = maxA * maxB;  // A 无正数，取 A 的最大值和 B 的最大值
            }
        } else if (hasNegativeB) {
            int minA = getMinInRange(A, l1, r1);
            if (minA < 0) {
                result = minA * maxB;  // A 有负数，取 A 的最小值和 B 的最大值
            } else {
                result = minA * minB;  // A 无负数，取 A 的最小值和 B 的最小值
            }
        } else {  // B 有正有负
            if (hasZeroInRange(A, l1, r1)) {
                result = 0;  // A 有零，得分为 0
            } else {
                int minPosA = getMinPositiveInRange(A, l1, r1);
                int maxNegA = getMaxNegativeInRange(A, l1, r1);
                if (minPosA != -1 && maxNegA != 1) {
                    result = max(minPosA * minB, maxNegA * maxB);
                } else if (minPosA != -1) {
                    result = minPosA * minB;
                } else if (maxNegA != 1) {
                    result = maxNegA * maxB;
                } else {
                    result = 0;  // A 有零
                }
            }
        }
        
        re[q]=result;
        //cout << re[] << endl;
    }
    
    for(int i=p-1;i>=0;i--)cout<<re[i]<<endl;
    return 0;
}