Problem: Nastya likes reading and even spends whole days in a library sometimes. Today she found a chronicle of Byteland in the library, and it stated that there lived shamans long time ago. It is known that at every moment there was exactly one shaman in Byteland, and there were n shamans in total enumerated with integers from 1 to n in the order they lived. Also, each shaman had a magic power which can now be expressed as an integer.

The chronicle includes a list of powers of the n shamans. Also, some shamans can be king-shamans, if they gathered all the power of their predecessors, i.e. their power is exactly the sum of powers of all previous shamans. Nastya is interested in whether there was at least one king-shaman in Byteland.

Unfortunately many of the powers are unreadable in the list, so Nastya is doing the following:

  * Initially she supposes some power for each shaman. 
  * After that she changes the power of some shaman q times (the shamans can differ) and after that wants to check if there is at least one king-shaman in the list. If yes, she wants to know the index of any king-shaman. 



Unfortunately the list is too large and Nastya wants you to help her.

Input

The first line contains two integers n and q (1 ≤ n, q ≤ 2·105).

The second line contains n integers a1, ..., an (0 ≤ ai ≤ 109), where ai is the magic power of the i-th shaman.

After that q lines follow, the i-th of them contains two integers pi and xi (1 ≤ pi ≤ n, 0 ≤ xi ≤ 109) that mean that the new power of the pi-th shaman is xi.

Output

Print q lines, the i-th of them should contain  - 1, if after the i-th change there are no shaman-kings, and otherwise a single integer j, where j is an index of some king-shaman after the i-th change.

If there are multiple king-shamans after each change, print the index of any of them.

Examples

Input

2 1
1 3
1 2


Output

-1


Input

3 4
2 2 3
1 1
1 2
2 4
3 6


Output

3
2
-1
3


Input

10 7
0 3 1 4 6 2 7 8 10 1
2 5
1 3
9 36
4 10
4 9
1 2
1 0


Output

1
-1
9
-1
4
-1
1

Note

In the first example powers of shamans after the first change are equal to (2, 3). The answer equals  - 1, because the sum of powers of shamans before the first shaman is equal to 0, and before the second is equal to 2.

In the second example after the first change the powers are equal to (1, 2, 3). The answer is equal to 3, because the power of the third shaman is equal to 3, and the sum of powers of the first and the second shaman is also 1 + 2 = 3. After the second change the powers become equal to (2, 2, 3), where the answer equals 2. After the third change the powers become equal to (2, 4, 3), where the answer equals  - 1. After the fourth change the powers become equal to (2, 4, 6), where the answer equals 3.

Solution (in JAVA):

Solution:
import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.StringTokenizer;
import java.io.IOException;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 *
 * @author kessido
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        TaskE solver = new TaskE();
        solver.solve(1, in, out);
        out.close();
    }

    static class TaskE {
        public void solve(int testNumber, InputReader in, PrintWriter out) {
            int n = in.NextInt();
            int q = in.NextInt();
            ArrayWithSegmentChanges array = new ArrayWithSegmentChanges(in.NextLongArray(n));
            int kingShamenIndex = -3;
            while (q-- != 0) {
                int index = in.NextInt() - 1;
                int value = in.NextInt();
                array.change(index, value);
                if (kingShamenIndex >= 0 && kingShamenIndex < index) out.println(kingShamenIndex + 1);
                else {
                    if (kingShamenIndex == -3) kingShamenIndex = 0;
                    else kingShamenIndex = Math.max(0, index - 1);
                    kingShamenIndex = getNewKingShamen(array, kingShamenIndex);
                    out.println(kingShamenIndex + 1);
                }
            }

        }

        private int getNewKingShamen(ArrayWithSegmentChanges array, int kingShamenIndex) {
            long currentIndexValue = array.get(kingShamenIndex);
            if (currentIndexValue == 0) return kingShamenIndex;
            while (true) {
                int nextKingIndex = array.getIndexOfElementBiggerOrEqualTo(2 * currentIndexValue);
                if (nextKingIndex == -1) return -2;
                if (nextKingIndex == kingShamenIndex) {
                    if (nextKingIndex + 1 == array.length) return -2;
                    nextKingIndex++;
                }
                if (kingShamenIndex + 1 != nextKingIndex) {
                    kingShamenIndex = nextKingIndex - 1;
                    currentIndexValue = array.get(kingShamenIndex);
                }
                long nextKingValue = array.get(nextKingIndex);
                if (nextKingValue == currentIndexValue * 2) return nextKingIndex;
                kingShamenIndex = nextKingIndex;
                currentIndexValue = nextKingValue;
            }
        }

        class ArrayWithSegmentChanges {
            public final int length;
            private long[] original;
            private long[] originalSum;
            private SegmentsTreeSumWithArrays segmentsTreeSum;

            public ArrayWithSegmentChanges(long[] original) {
                this.original = original;
                this.length = original.length;
                originalSum = new long[length];
                originalSum[0] = original[0];
                for (int i = 1; i < length; i++) {
                    originalSum[i] = original[i] + originalSum[i - 1];
                }
                this.segmentsTreeSum = new SegmentsTreeSumWithArrays(0, length - 1);
            }

            long get(int index) {
                assert index < length;
                return originalSum[index] + segmentsTreeSum.get(index);
            }

            void change(int index, long value) {
                value -= original[index];
                original[index] += value;
                segmentsTreeSum.add(index, length - 1, value);
            }

            int getIndexOfElementBiggerOrEqualTo(long x) {
                int l = 0;
                int r = length - 1;
                if (get(length - 1) < x) return -1;
                while (l != r) {
                    int m = (l + r) / 2;
                    long res = get(m);
                    if (res >= x) {
                        r = m;
                    } else {
                        l = m + 1;
                    }
                }
                return l;
            }

        }

    }

    static class SegmentsTreeSumWithArrays {
        private final long[] v;
        private final long l;
        private final long r;
        private final int n;

        public SegmentsTreeSumWithArrays(long l, long r) {
            this.l = l;
            this.r = r;
            n = (int) (r - l + 1);
            v = new long[2 * n];
        }

        public long get(final long index) {

            int i = n + (int) (index - l);
            long res0 = v[i >> 0];
            long res1 = v[i >> 1];
            long res2 = v[i >> 2];
            long res3 = v[i >> 3];
            long res4 = v[i >> 4];
            long res5 = v[i >> 5];
            long res6 = v[i >> 6];
            long res7 = v[i >> 7];
            long res8 = v[i >> 8];
            long res9 = v[i >> 9];
            long res10 = v[i >> 10];
            long res11 = v[i >> 11];
            long res12 = v[i >> 12];
            long res13 = v[i >> 13];
            long res14 = v[i >> 14];
            long res15 = v[i >> 15];
            long res16 = v[i >> 16];
            long res17 = v[i >> 17];
            long res18 = v[i >> 18];
            long res19 = v[i >> 19];
            long res20 = v[i >> 20];
            long res21 = v[i >> 21];
            long res22 = v[i >> 22];
            long res23 = v[i >> 23];
            long res24 = v[i >> 24];
            long res25 = v[i >> 25];
            long res26 = v[i >> 26];
            long res27 = v[i >> 27];
            long res28 = v[i >> 28];
            long res29 = v[i >> 29];
            long res30 = v[i >> 30];
            long res31 = v[i >> 31];
            return res0 +
                    res1 +
                    res2 +
                    res3 +
                    res4 +
                    res5 +
                    res6 +
                    res7 +
                    res8 +
                    res9 +
                    res10 +
                    res11 +
                    res12 +
                    res13 +
                    res14 +
                    res15 +
                    res16 +
                    res17 +
                    res18 +
                    res19 +
                    res20 +
                    res21 +
                    res22 +
                    res23 +
                    res24 +
                    res25 +
                    res26 +
                    res27 +
                    res28 +
                    res29 +
                    res30 +
                    res31;
        }

        public void add(final long s_l, final long s_r, final long s_v) {
            int sl = (int) (s_l - l) + n, sr = (int) (s_r - l) + n;
            while (sl < sr) {
                if ((sl & 1) == 1) {
                    v[sl++] += s_v;
                }
                if ((sr & 1) == 0) {
                    v[sr--] += s_v;
                }
                sl >>= 1;
                sr >>= 1;
            }
            if (sl == sr)
                v[sl] += s_v;
        }

    }

    static class InputReader {
        BufferedReader reader;
        StringTokenizer tokenizer;

        public InputReader(InputStream stream) {
            reader = new BufferedReader(new InputStreamReader(stream), 32768);
            tokenizer = null;
        }

        public String next() {
            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
                try {
                    tokenizer = new StringTokenizer(reader.readLine(), " \t\n\r\f,");
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            return tokenizer.nextToken();
        }

        public int NextInt() {
            return Integer.parseInt(next());
        }

        public long NextLong() {
            return Long.parseLong(next());
        }

        public long[] NextLongArray(int n) {
            return NextLongArray(n, 0);
        }

        public long[] NextLongArray(int n, int offset) {
            long[] a = new long[n];
            for (int i = 0; i < n; i++) {
                a[i] = NextLong() + offset;
            }
            return a;
        }

    }
}