#include <bits/stdc++.h>
using namespace std;
mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());
template <class T, class V, int MAX_FREE_FACTOR = (1 << 20), int INIT_m = 3>
struct hash_map {
  int size, m, M;
  T* bucket;
  V* values;
  unsigned long long a;
  unsigned long long b;
  T MAX, MIN;
  int min_filled;
  void init() {
    a = uniform_int_distribution<unsigned long long>()(rng);
    if (a % 2 == 0) a++;
    b = uniform_int_distribution<unsigned long long>()(rng);
    m = INIT_m;
    M = 1 << m;
    bucket = new T[M];
    values = new V[M];
    size = 0;
    MAX = numeric_limits<T>::max();
    MIN = numeric_limits<T>::min();
    min_filled = 0;
    fill(bucket, bucket + M, MIN);
    fill(values, values + M, numeric_limits<V>::min());
  }
  hash_map() { init(); }
  int h(T x) { return (((unsigned long long)x) * a + b) >> (64 - m); }
  void rehash(int new_m) {
    int oldM = M;
    T* bucket_copy = new T[M];
    V* values_copy = new V[M];
    copy(bucket, bucket + M, bucket_copy);
    copy(values, values + M, values_copy);
    delete[] bucket;
    delete[] values;
    M = (1 << new_m);
    m = new_m;
    min_filled = M / MAX_FREE_FACTOR;
    bucket = new T[M];
    values = new V[M];
    fill(bucket, bucket + M, MIN);
    fill(values, values + M, numeric_limits<V>::min());
    size = 0;
    for (int i = 0; i < oldM; i++) {
      T v = bucket_copy[i];
      if (v != MIN && v != MAX) (*this)[v] = values_copy[i];
    }
    delete[] bucket_copy;
    delete[] values_copy;
  }
  V& operator[](T x) {
    if (2 * size >= M) {
      rehash(m + 1);
    }
    int pos = h(x);
    while (bucket[pos] != MIN) {
      if (bucket[pos] == x) {
        return values[pos];
      }
      pos = (pos + 1) & (M - 1);
    }
    bucket[pos] = x;
    values[pos] = numeric_limits<V>::min();
    size++;
    return values[pos];
  }
  bool erase(T x) {
    if (size < min_filled && m > INIT_m + 5) {
      rehash(m - 1);
    }
    int pos = h(x);
    while (bucket[pos] != MIN) {
      if (bucket[pos] == x) {
        bucket[pos] = MAX;
        values[pos] = numeric_limits<V>::min();
        size--;
        return true;
      }
      pos = (pos + 1) & (M - 1);
    }
    return false;
  }
  void clear() {
    delete[] bucket;
    delete[] values;
    init();
  }
  ~hash_map() {
    delete[] bucket;
    delete[] values;
  }
};
const long long INF = 1e15 + 21;
const long long MAXN = 1e5 + 5;
long long N, Q;
long long V[MAXN];
long long C[MAXN];
long long dp[MAXN];
int main() {
  ios::sync_with_stdio(0);
  cin.tie(0);
  cin >> N >> Q;
  for (long long i = 0; i < N; i++) {
    cin >> V[i];
  }
  for (long long i = 0; i < N; i++) {
    cin >> C[i];
  }
  hash_map<int, long long> curMax;
  for (long long i = 0; i < Q; i++) {
    for (int i = 0; i < N; i++) {
      curMax[C[i]] = -INF;
    }
    long long a, b;
    cin >> a >> b;
    fill(dp, dp + N, -1);
    pair<long long, long long> mx1 = {0, 1e5 + 5};
    pair<long long, long long> mx2 = {0, 1e5 + 4};
    for (long long j = 0; j < N; j++) {
      if (mx1.second == C[j]) {
        dp[j] = mx2.first + b * V[j];
      } else {
        dp[j] = mx1.first + b * V[j];
      }
      dp[j] = max(dp[j], curMax[C[j]] + a * V[j]);
      if (dp[j] > mx1.first) {
        if (C[j] == mx1.second) {
          mx1 = {dp[j], C[j]};
        } else {
          mx2 = {mx1.first, mx1.second};
          mx1 = {dp[j], C[j]};
        }
      } else if (dp[j] > mx2.first) {
        if (C[j] == mx1.second) {
          continue;
        } else {
          mx2 = {dp[j], C[j]};
        }
      }
      curMax[C[j]] = max(curMax[C[j]], dp[j]);
    }
    cout << mx1.first << endl;
  }
}
