import java.util.ArrayList;
import java.util.HashMap;
import java.util.Scanner;

class Index {
	int bucket, location;
	Index(int b, int l) 
	{
		bucket = b; location = l;
	}
}

public class DynamicMiddle_HarryACC {

	static ArrayList<Integer> bounds = new ArrayList<Integer>();	
	static ArrayList<ArrayList<Long>> buckets = new ArrayList<ArrayList<Long>>();	
	static ArrayList<Long> bucket_sums = new ArrayList<Long>();	
	static HashMap<Integer, Index> place = new HashMap<Integer, Index>();
	static long total_sum = 0;
	
	static int query(long c, int index)
	{
		Index i = place.get(index);
		
		long old = buckets.get(i.bucket).get(i.location);		
		buckets.get(i.bucket).set(i.location, c);		
		bucket_sums.set(i.bucket, bucket_sums.get(i.bucket) + c - old);
		
		total_sum += (c - old);
		
		//Find the right bucket.
		long cur_sum = 0;
		long min_val = 1000000000000000L;
		int min_index = -1;
		for(int j = 0; j < buckets.size(); j++)
		{
			long lastvalue =  buckets.get(j).get(buckets.get(j).size() - 1);
			long next_sum = cur_sum + bucket_sums.get(j);
			
			if(next_sum - lastvalue == total_sum - next_sum)
				return bounds.get(j) + buckets.get(j).size() - 1;

			if(next_sum - lastvalue < total_sum - next_sum){
				min_val = Math.abs((next_sum - lastvalue) - (total_sum - next_sum));
				min_index = bounds.get(j) + buckets.get(j).size() - 1;
			}
						
			if(next_sum - lastvalue > total_sum - next_sum)
			{
				//Find the right element in the right bucket.
				long sum = 0;
				for(int k = 0; k < buckets.get(j).size(); k++)
				{
					long maybe_middle = buckets.get(j).get(k);
					
					long left_sum = cur_sum + sum;
					long right_sum = total_sum - cur_sum - sum - maybe_middle;
					
					if(Math.abs(left_sum - right_sum) < min_val)
					{
						min_val = Math.abs(left_sum - right_sum);
						min_index = bounds.get(j) + k;
					}
					
					sum += maybe_middle;
				}
				break;
			}
			cur_sum = next_sum;
				
		}
		return min_index;
	}
	
	public static void main(String[] args)
	{
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt(); int q = sc.nextInt();
				
		int t = 0;
		while(t < n)
		{
			bounds.add(t);
			buckets.add(new ArrayList<Long>());
			bucket_sums.add(0L);
			t += (int) Math.sqrt(n);			
		}
		
		
		int bucket = 0;
		for(int i = 0; i < n; i++)
		{
			if(bucket != bounds.size() - 1)
				if(i >= bounds.get(bucket + 1))
					bucket++;				
			
			place.put(i, new Index(bucket, i - bounds.get(bucket)));
			
			long a = sc.nextInt();
			total_sum += a;
			buckets.get(bucket).add(a);
			bucket_sums.set(bucket, bucket_sums.get(bucket) + a);
		}
		
		for(int j = 0; j < q; j++)
		{
			int i = sc.nextInt(); long x = sc.nextInt();
			System.out.println(query(x, i));			
		}
		
		
	}
}