#include <bits/stdc++.h>
using namespace std;
template <typename T, typename U>
struct seg_tree_lazy {
  int S, H;
  T zero;
  std::vector<T> value;
  U noop;
  std::vector<bool> dirty;
  std::vector<U> prop;
  seg_tree_lazy<T, U>(int _S, T _zero = T(), U _noop = U());
  void set_leaves(std::vector<T> &leaves);
  void apply(int i, U &update);
  void rebuild(int i);
  void propagate(int i);
  void upd(int i, int j, U update);
  T query(int i, int j);
};
int v[210000];
set<int> ss[33];
int clz(int x) {
  if (x == 0) return 32;
  return __builtin_clz(x);
}
struct node {
  long long s = 0;
  node(long long int _s = 0) : s(_s) {}
  node operator+(node ot) { return node(s + ot.s); }
};
struct upd {
  int v;
  upd(int _v = 0) : v(_v) {}
  node operator()(node a) {
    a.s += v;
    return a;
  }
  upd operator+(upd ot) { return upd(v + ot.v); }
};
int n, q;
void solve() {
  scanf("%d %d", &n, &q);
  for (int i = 0; i < n; i++) scanf("%d", &v[i]);
  vector<node> leaves(n);
  for (int i = 0; i < n; i++) {
    leaves[i].s = v[i];
    ss[clz(v[i])].insert(i);
  }
  seg_tree_lazy<node, upd> tree(n);
  tree.set_leaves(leaves);
  for (int i = 0; i < q; i++) {
    int p, val;
    scanf("%d %d", &p, &val);
    p--;
    int diff = val - v[p];
    ss[clz(v[p])].erase(p);
    tree.upd(p, p, diff);
    v[p] = val;
    ss[clz(v[p])].insert(p);
    int f = -1;
    for (int i = 0; i < 33 && f == -1; i++) {
      auto it = ss[i].begin();
      for (int j = 0; j < 2; j++) {
        if (it == ss[i].end()) break;
        if (tree.query(0, *it).s == 2 * (v[*it])) f = *it + 1;
        it++;
      }
    }
    printf("%d\n", f != -1 ? f : -1);
  }
}
int main() { solve(); }
template <typename T, typename U>
seg_tree_lazy<T, U>::seg_tree_lazy(int _S, T _zero, U _noop) {
  zero = _zero, noop = _noop;
  for (S = 1, H = 1; S < _S;) S *= 2, H++;
  value.resize(2 * S, zero);
  dirty.resize(2 * S, false);
  prop.resize(2 * S, noop);
}
template <typename T, typename U>
void seg_tree_lazy<T, U>::set_leaves(vector<T> &leaves) {
  copy(leaves.begin(), leaves.end(), value.begin() + S);
  for (int i = S - 1; i > 0; i--) value[i] = value[2 * i] + value[2 * i + 1];
}
template <typename T, typename U>
void seg_tree_lazy<T, U>::apply(int i, U &update) {
  value[i] = update(value[i]);
  if (i < S) {
    prop[i] = prop[i] + update;
    dirty[i] = true;
  }
}
template <typename T, typename U>
void seg_tree_lazy<T, U>::rebuild(int i) {
  for (int l = i / 2; l; l /= 2) {
    T combined = value[2 * l] + value[2 * l + 1];
    value[l] = prop[l](combined);
  }
}
template <typename T, typename U>
void seg_tree_lazy<T, U>::propagate(int i) {
  for (int h = H; h > 0; h--) {
    int l = i >> h;
    if (dirty[l]) {
      apply(2 * l, prop[l]);
      apply(2 * l + 1, prop[l]);
      prop[l] = noop;
      dirty[l] = false;
    }
  }
}
template <typename T, typename U>
void seg_tree_lazy<T, U>::upd(int i, int j, U update) {
  i += S, j += S;
  propagate(i), propagate(j);
  for (int l = i, r = j; l <= r; l /= 2, r /= 2) {
    if ((l & 1) == 1) apply(l++, update);
    if ((r & 1) == 0) apply(r--, update);
  }
  rebuild(i), rebuild(j);
}
template <typename T, typename U>
T seg_tree_lazy<T, U>::query(int i, int j) {
  i += S, j += S;
  propagate(i), propagate(j);
  T res_left = zero, res_right = zero;
  for (; i <= j; i /= 2, j /= 2) {
    if ((i & 1) == 1) res_left = res_left + value[i++];
    if ((j & 1) == 0) res_right = value[j--] + res_right;
  }
  return res_left + res_right;
}
