#include <bits/stdc++.h>
using namespace std;
struct SegmentTreeLazy {
  typedef long long T;
  const T inf = (T)1e18;
  const T not_found = -2;
  SegmentTreeLazy(vector<T> &v) {
    n = static_cast<int>(v.size());
    int pow2 = 1;
    while (pow2 < n) pow2 <<= 1;
    mx.resize(2 * pow2, -inf);
    mn.resize(2 * pow2, inf);
    change.resize(2 * pow2);
    mode.resize(2 * pow2);
    build(v, 1, 0, n);
  }
  int query_zero_idx(int L, int R) { return query_zero_idx(1, 0, n, L, R); }
  void set(int L, int R, T x) { update(Mode::assign, 1, 0, n, L, R, x); }
  void inc(int L, int R, T x) { update(Mode::increment, 1, 0, n, L, R, x); }

 private:
  int n;
  enum class Mode { increment, assign };
  vector<T> mx;
  vector<T> mn;
  vector<T> change;
  vector<Mode> mode;
  inline int left(int p) { return p << 1; }
  inline int right(int p) { return (p << 1) + 1; }
  void build(vector<T> &v, int pos, int lo, int hi) {
    if (lo + 1 < hi) {
      int mid = lo + (hi - lo) / 2;
      build(v, left(pos), lo, mid);
      build(v, right(pos), mid, hi);
      mx[pos] = max(mx[left(pos)], mx[right(pos)]);
      mn[pos] = min(mn[left(pos)], mn[right(pos)]);
    } else {
      mx[pos] = mn[pos] = v[lo];
    }
  }
  T query_zero_idx(int pos, int lo, int hi, int L, int R) {
    if (R <= lo or hi <= L) return not_found;
    if (L <= lo and hi <= R) {
      if (mx[pos] < 0 or mn[pos] > 0)
        return not_found;
      else if (mx[pos] == 0 and mn[pos] == 0)
        return lo;
      else if (lo + 1 == hi)
        return -1;
    }
    propagate(pos, lo, hi);
    int mid = lo + (hi - lo) / 2;
    int idx = query_zero_idx(left(pos), lo, mid, L, R);
    if (idx != not_found) return idx;
    return query_zero_idx(right(pos), mid, hi, L, R);
  }
  void update(Mode m, int pos, int lo, int hi, int L, int R, T x) {
    if (R <= lo or hi <= L) {
      return;
    }
    if (L <= lo and hi <= R) {
      if (m == Mode::assign) {
        mx[pos] = x;
        mn[pos] = x;
        change[pos] = x;
        mode[pos] = Mode::assign;
      } else {
        mx[pos] += x;
        mn[pos] += x;
        change[pos] += x;
      }
    } else {
      propagate(pos, lo, hi);
      int mid = lo + (hi - lo) / 2;
      update(m, left(pos), lo, mid, L, R, x);
      update(m, right(pos), mid, hi, L, R, x);
      mx[pos] = max(mx[left(pos)], mx[right(pos)]);
      mn[pos] = min(mn[left(pos)], mn[right(pos)]);
    }
  }
  void propagate(int pos, int lo, int hi) {
    if (mode[pos] == Mode::assign or change[pos]) {
      int mid = lo + (hi - lo) / 2;
      update(mode[pos], left(pos), lo, mid, lo, mid, change[pos]);
      update(mode[pos], right(pos), mid, hi, mid, hi, change[pos]);
      change[pos] = 0;
      mode[pos] = Mode::increment;
    }
  }
};
void solve() {
  int n, q, p;
  long long sum = 0, x;
  cin >> n >> q;
  vector<long long> diff, v;
  diff.reserve(n);
  for (int i = 0; i < n; ++i) {
    cin >> x;
    v.push_back(x);
    diff.push_back(x - sum);
    sum += x;
  }
  SegmentTreeLazy st(diff);
  int king = st.query_zero_idx(0, n);
  for (int i = 0; i < q; ++i) {
    cin >> p >> x;
    p -= 1;
    st.inc(p, p + 1, x - v[p]);
    st.inc(p + 1, n, v[p] - x);
    v[p] = x;
    if (king == st.not_found or king >= p) {
      king = st.query_zero_idx(p, n);
    }
    cout << king + 1 << "\n";
  }
}
int main() {
  ios::sync_with_stdio(false);
  cin.tie(0);
  solve();
  return 0;
}
