#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using i128 = __int128_t;
 
int main(){
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    int n, m;
    if(!(cin >> n >> m)) return 0;
    vector<ll> aa(n+1), bb(n+1);
    for(int i=1;i<=n;i++) cin >> aa[i];
    for(int i=1;i<=n;i++) cin >> bb[i];
 
    vector<int> vt(n+1);
    for(int i=1;i<=n;i++) vt[i]=i;
    auto cmp = [&](int i, int j){
        return (i128)bb[i]*aa[j] < (i128)bb[j]*aa[i];
    };
    stable_sort(vt.begin()+1, vt.end(), cmp);
 
    vector<ll> A(n+1), B(n+1);
    for(int i=1;i<=n;i++){
        A[i] = aa[vt[i]];
        B[i] = bb[vt[i]];
    }
    vector<int> pos(n+1);
    for(int i=1;i<=n;i++) pos[vt[i]] = i;
 
    vector<ll> prefA(n+1,0), prefB(n+1,0);
    vector<long double> rat(n+1,0.0L);
    vector<i128> prefCost128(n+1,0);
    for(int i=1;i<=n;i++){
        prefA[i] = prefA[i-1] + A[i];
        prefB[i] = prefB[i-1] + B[i];
        rat[i] = (long double)B[i] / (long double)A[i];
        prefCost128[i] = prefCost128[i-1] + (i128)A[i] * (i128)prefB[i];
    }
    i128 total_full_128 = prefCost128[n];
 
    auto print_i128 = [&](i128 x){
        if(x==0){ cout << 0 << '\n'; return;}
        string s;
        while(x>0){
            int d = (int)(x % 10);
            s.push_back(char('0'+d));
            x /= 10;
        }
        reverse(s.begin(), s.end());
        cout << s << '\n';
    };
 
    while(m--){
        int x,y; cin >> x >> y;
        int px = pos[x], py = pos[y];
        if(px < py){
            print_i128(total_full_128);
            continue;
        }
        int L = py, R = px; 
        long double rblock = (long double)(bb[x] + bb[y]) / (long double)(aa[x] + aa[y]);
 
        int lo = L, hi = R-1;
        int idx = L-1;
        if(lo <= hi){
            auto it = upper_bound(rat.begin()+lo, rat.begin()+hi+1, rblock);
            idx = int(it - rat.begin()) - 1;
        } else {
            idx = L-1;
        }
        int k = idx; 
        i128 ans = 0;
 
        if(k == L-1){
            ans += prefCost128[L-1];
        } else {
            ans += prefCost128[L-1];
            ans += (prefCost128[k] - prefCost128[L]);
            ll sumA_mid = prefA[k] - prefA[L];
            ans -= (i128)B[L] * (i128)sumA_mid;
        }
 
        ll TB = prefB[k] - ( (k>=L) ? B[L] : 0 );
 
        ll Au = A[R], Bu = B[R]; 
        ll Av = A[L], Bv = B[L]; 
 
        ans += (i128)(TB + Bu) * (i128)Au;
        ans += (i128)(TB + Bu + Bv) * (i128)Av;
 
        i128 base_after = prefCost128[n] - prefCost128[k];
        if(k == L-1){
            base_after -= (i128)Av * (i128)prefB[L];
        }
        base_after -= (i128)Au * (i128)prefB[R];
 
        ll sumA_segment = 0;
        if(R-1 >= k+1){
            sumA_segment = prefA[R-1] - prefA[k];
            if(k == L-1){
                sumA_segment -= Av;
            }
        } else {
            sumA_segment = 0;
        }
        base_after += (i128)Bu * (i128)sumA_segment;
 
        ans += base_after;
 
        print_i128(ans);
    }
 
    return 0;
}