#include <bits/stdc++.h>

using namespace std;
using lint = long long;
using ulint = unsigned long long;
using uint = unsigned int;
// !vec
//
//
template <typename T, typename T1>
istream &operator>>(istream &in, pair<T, T1> &p) {
  in >> p.first >> p.second;
  return in;
}
template <typename T, typename T1>
ostream &operator<<(ostream &out, pair<T, T1> p) {
  out << "<" << p.first << "," << p.second << ">";
  return out;
}
// 输入vec
template <typename T> istream &operator>>(istream &in, vector<T> &v) {
  for (auto &i : v) {
    in >> i;
  }
  return in;
}

// 输出vec
template <typename T> ostream &operator<<(ostream &out, vector<T> v) {
  out << "[";
  for (auto i : v) {
    out << " " << i << ",";
  }
  out << "]";
  return out;
}
// vec求和
template <typename T> lint getsum(vector<T> &v) {
  lint sum = 0;
  for (auto i : v) {
    sum += i;
  }
  return sum;
}
// 前缀和
template <typename T> vector<int> prefix_sum(vector<int> &v) {
  vector<int> ans(v.size());
  ans[0] = v[0];
  for (int i = 1; i < v.size(); i++) {
    ans[i] = ans[i - 1] + v[i];
  }
  return std::move(ans);
}

// 输出yes||no
void out_yn(bool is) {
  if (is) {
    cout << "Yes" << "\n";
  } else {
    cout << "No" << "\n";
  }
}

// 二分
lint least_true(lint l, lint r, std::function<lint(lint)> check) {
  int mid = (l + r) / 2;
  if (l == r - 1) {
    return r;
  }
  if (check(mid)) {
    return least_true(l, mid, check);
  } else {
    return least_true(mid, r, check);
  }
}
// 图
template <typename NodeWight, typename EdgeWeight> class Graph {
public:
  class ELink {
  public:
    int p;
    EdgeWeight d;
    ELink(int p, EdgeWeight d) : p(p), d(d) {}
  };
  vector<NodeWight> d;
  vector<list<ELink>> e;
  int n;
  Graph(int len) : n(len), d(len), e(len) {}
  void add_edge(int u, int v, EdgeWeight d) { e[u].push_front(ELink(v, d)); }
  // 最短路
  vector<EdgeWeight> dijkstra(int source) {
    set<pair<EdgeWeight, int>> se;
    vector<EdgeWeight> ans(n, -1);
    se.insert({EdgeWeight(), source});
    while (!se.empty()) {
      auto [w, i] = *(se.begin());
      se.erase(se.begin());
      if (ans[i] != -1) {
        continue;
      }
      ans[i] = w;
      for (auto b : e[i]) {
        if (ans[b.p] != -1) {
          continue;
        }
        se.insert({ans[i] + b.d, b.p});
      }
    }
    return std::move(ans);
  }
};
// 单调队列
template <typename T> class MonotonicQueue {
public:
  deque<T> q;
  function<bool(T, T)> cmp;
  MonotonicQueue(function<bool(T, T)> cmp = less<T>()) : cmp(cmp) {}
  void push(T v) {
    while (!q.empty() && !cmp(q.back(), v)) {
      q.pop_back();
    }
    q.push_back(v);
  }
  void pop() { q.pop_front(); }
  T get() { return q.front(); }
};
// 分数
struct Fraction {
  lint num;
  lint den;
  Fraction(lint n, lint d) : num(n), den(d) {}
  void simplipy() {
    lint a = gcd(num, den);
    num /= a;
    den /= a;
  }

  void add(lint a) { num += den * a; }
  void add(Fraction b) {
    lint ys = gcd(den, b.den);
    den = den / ys * b.den;
    num = num * (b.den / ys) + b.num * (den / ys);
    simplipy();
  }
  lint ceil() { return (num - 1) / den + 1; }

  void squ() {
    num *= num;
    den *= den;
  }
  bool can_root() {
    if (lint(sqrt(num)) * lint(sqrt(num)) != num ||
        lint(sqrt(den)) * lint(sqrt(den)) != den) {
      return false;
    }
    return true;
  }
  void root() {
    num = sqrt(num);
    den = sqrt(den);
  }
};
// ms修改的vec;
template <typename T> struct ZmsVector {
  vector<T> v;
  int offset;
  function<int(int x)> hash;
  T &operator[](int x) { return v[hash(x)]; }
  ostream &operator<<(ostream &out) {
    out << v;
    return out;
  }
  istream &operator>>(istream &in) {
    in >> v;
    return in;
  }
};
// 前缀数组
template <typename T> vector<int> get_prefix_array(T &s, int n) {
  vector<int> ans(n + 1);
  ans[0] = -1;
  for (int i = 2; i <= n; i++) {
    int j = ans[i - 1];
    while (j >= 0 && s[i - 1] != s[j]) {
      j = ans[j];
    }
    ans[i] = j + 1;
  }
  return std::move(ans);
}
void kmp(string &str, string &sub) {
  auto pa = get_prefix_array(sub, sub.length());
  // cout<<pa;
  int psub = 0;
  for (int i = 0; i < str.length(); i++) {
    while (psub >= 0 && sub[psub] != str[i]) {
      psub = pa[psub];
    }
    psub++;
    if (psub == sub.length()) {
      psub = pa[psub];
      cout << i - sub.length() + 2 << "\n";
    }
  }
}

struct BitTrie {
  vector<vector<int>> v;
  vector<lint> sum;
  vector<int> num;
  int end = 2;
  BitTrie(int a, int w) {
    sum.resize(a, 0);
    num.resize(a, 0);
    v.resize(a, vector(w, 0));
  }
  vector<int> get(int x) {
    lint p = 31;
    vector<int> v;
    for (int i = 1; i <= 32; i++)
      v.push_back(0);
    string s1;
    while (x > 0) {
      v[p] = x % 2;
      p--;
      x /= 2;
    }

    return std::move(v);
  }
  void insert(int value) {
    int t = 1;
    vector<int> s = get(value);
    // cout<<value<<" "<<s<<endl;
    sum[t] += value;
    num[t]++;
    for (int i = 0; i < s.size(); i++) {
      if (v[t][s[i]] == 0) {
        v[t][s[i]] = end;
        end++;
      }
      t = v[t][s[i]];
      sum[t] += value;
      num[t]++;
    }
  }
  void del(int value) {
    int t = 1;

    vector<int> s = get(value);
    // cout<<value<<" "<<s<<endl;
    sum[t] -= value;
    num[t]--;
    for (int i = 0; i < s.size(); i++) {
      t = v[t][s[i]];
      sum[t] -= value;
      num[t]--;
    }
  }
  int get_ans(lint x) {
    // cout<<num[0]<<" "<<sum[0]<<endl;
    int t = 1;
    int ans = 0;
    while (t != 0) {
      int ls = v[t][0];
      int rs = v[t][1];
      if (x >= sum[ls]) {
        ans += num[ls];
        x -= sum[ls];
        t = rs;
      } else {
        t = ls;
      }
    }
    return ans;
  }
};
// 二进制大整数
struct BigInt {
  const static ulint MASK = 0x00000000ffffffff;
  vector<ulint> v;
  BigInt(ulint i = 0) {
    v.push_back(i & MASK);
    if (i > MASK) {
      v.push_back(i >> 32);
    }
  }
  BigInt &self_mutil(ulint num) {
    ulint b = num;
    ulint carry = 0;
    for (auto &i : v) {
      i *= num;
      i += carry;
      carry = (i >> 32);
      i &= MASK;
    }
    if (carry) {
      v.push_back(carry);
    }
    return *this;
  }
  inline BigInt operator*(ulint num) {
    return std::move(BigInt(*this).self_mutil(num));
  }
};
// n进制大整数
template <ulint MOD> struct ModBigInt {
  vector<ulint> v;
  ModBigInt(ulint i = 0) {
    while (i) {
      v.push_back(i % MOD);
      i /= MOD;
    }
  }
  ModBigInt &self_mutil(uint num) {
    ulint carry = 0;
    for (auto &i : v) {
      i *= num;
      i += carry;
      carry = (i / MOD);
      i %= MOD;
    }
    while (carry) {
      v.push_back(carry % MOD);
      carry /= MOD;
    }
    return *this;
  }
  inline ModBigInt operator*(uint num) {
    return std::move(ModBigInt(*this).self_mutil(num));
  }
};
template <ulint MOD> ostream &operator<<(ostream &out, ModBigInt<MOD> &m) {
  auto i = int(m.v.size()) - 1;
  while (i >= 0) {
    cout << m.v[i];
    i--;
  }
  return out;
}
// 向上取整
struct Solve {
  void solve() {
    int n,m;
    cin>>n>>m;
    vector<lint> v(n);
    cin>>v;
    //cout<<v;
    vector<pair<lint,lint>> cd(m);
    lint allpower=getsum(v);
    lint nowpower=allpower;
    cin>>cd;
    for(int i=0;i<m;i++){
        cd[i].second--;
    }
    //cout<<cd<<endl;
    lint ans=0;
    int it=0;
    //cerr<<1<<endl;
    while (nowpower) {
        lint increment=0;
        if(it!=m &&ans==cd[it].first){
            nowpower=min(nowpower+v[cd[it].second],allpower);
            it++;
        }
        if(it!=m){
          increment=min(nowpower,cd[it].first-ans);
        }else {
          increment=nowpower;
        }
        //cout<<nowpower<<endl;
        ans+=increment;
        nowpower-=increment;
    }
    cout<<ans<<endl;
  }
};
int main() {

  int t = 1;
  cin >> t;
  Solve s;
  // std::ios::sync_with_stdio(false);
  // std::cin.tie(nullptr);
  while (t--) {

    s.solve();
  }
}