#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int,int> pii;
const int MAXN = 2e5 + 5;

struct BIT
{
	ll tree[MAXN]; int n;
	#define lowbit(x) ((x)&-(x))
	void init(int _n)
	{
		n = _n;
		fill(tree, tree+n+1, 0);
	}
	inline void update(int x,ll k)
	{
		while(x<=n)
			tree[x] += k, x += lowbit(x);
	}
	inline ll query(int x)
	{
		ll res = 0;
		while(x)
			res += tree[x], x ^= lowbit(x);
		return res;
	}
	inline ll query(int l,int r)
	{
		return query(r) - query(l-1);
	}
}tree;

ll dsc[MAXN];
int dcnt = 0;

void build_dsc(void)
{
	sort(dsc+1,dsc+dcnt+1);
	dcnt = unique(dsc+1,dsc+dcnt+1) - dsc - 1;
}
int get_upper(ll k)
{
	return upper_bound(dsc+1,dsc+dcnt+1,k) - dsc;
}
int get_lower(ll k)
{
	return lower_bound(dsc+1,dsc+dcnt+1,k) - dsc;
}

ll a[MAXN], res[MAXN];
pair<int,ll> qs[MAXN];
ll val1[MAXN], val2[MAXN];

int main(void)
{
	int n,Q;
	scanf("%d%d",&n,&Q);
	for(int i=0; i<n; ++i)
		scanf("%lld",&a[i]);
	
	if(n % 2)
	{
		while(Q--) printf("-1\n");
		return 0;
	}
	
	for(int i=0; i<n; i+=2)
		a[i] *= -1;
	ll S = accumulate(a,a+n,0ll);
	bool isodd = 0;
	if(S == 0)
	{
		while(Q--) printf("-1\n");
		return 0;
	}
	if(S < 0)
	{
		isodd = 1;
		for(int i=0; i<n; ++i)
			a[i] *= -1;
		S *= -1;
	}
	
	for(int i=1; i<n; ++i)
		a[i] += a[i-1];
	
	auto getmod = [&] (ll x) -> ll
	{
		return (x % S + S) % S;
	};
	
	set<ll> bak;
	ll hassame = -1;
	for(int i=0; i<n; ++i)
	{
		ll k = getmod(a[i]);
		if(!bak.insert(k).second)
		{
			if(hassame != -1)
			{
				while(Q--) printf("-1\n");
				return 0;
			}
			hassame = k;
		}
	}
	
	static vector<int> qids[MAXN];
	vector< pair<ll,int> > p;
	
	for(int i=0; i<n; ++i)
		p.emplace_back(a[i], i);
	
	for(int rn=1; rn<=Q; ++rn)
	{
		int i; ll k;
		scanf("%d%lld",&i,&k);
		if(i % 2 == isodd) k *= -1;
		
		ll x = a[i], y = a[i] + k;
		qs[rn] = {i, y};
		
		if(hassame != -1)
		{
			if(getmod(x) != hassame || bak.count(getmod(y)))
			{
				res[rn] = -1;
				continue;
			}
		}
		else
		{
			if(getmod(x) != getmod(y) && bak.count(getmod(y)))
			{
				res[rn] = -1;
				continue;
			}
		}
		
		qids[i].emplace_back(rn);
		p.emplace_back(y, n + rn);
	}
	
	// val1
	{
		for(int i=0; i<n; ++i)
			dsc[++dcnt] = a[i];
		build_dsc();
		
		tree.init(dcnt);
		for(int i=0; i<n; ++i)
		{
			val1[i] += tree.query(get_upper(a[i]), dcnt);
			for(int j: qids[i])
				val1[n+j] += tree.query(get_upper(qs[j].second), dcnt);
			tree.update(get_lower(a[i]), 1);
		}
		
		tree.init(dcnt);
		for(int i=n-1; i>=0; --i)
		{
			val1[i] += tree.query(get_lower(a[i])-1);
			for(int j: qids[i])
				val1[n+j] += tree.query(get_lower(qs[j].second)-1);
			tree.update(get_lower(a[i]), 1);
		}
		
//		for(int i=0; i<n; ++i)
//			printf("val1[%d] = %lld\n",i,val1[i]);
	}
	
	// val2
	{
		sort(p.begin(), p.end());
		
		dcnt = 0;
		for(auto t: p)
			dsc[++dcnt] = getmod(t.first);
		build_dsc();
		
		tree.init(dcnt);
		ll sum = 0; int cnt = 0;
		
		for(int l=0,r=0; l<(int)p.size(); l=r)
		{
			while(r<(int)p.size() && p[l].first == p[r].first) ++r;
			
			ll x = p[l].first;
			ll mo = getmod(x), di = (x - mo) / S;
			ll cur = di * cnt + sum - tree.query(get_upper(mo), dcnt);
			
			for(int i=l; i<r; ++i)
			{
				val2[p[i].second] += cur;
				if(p[i].second < n)
				{
					sum -= di; ++cnt;
					tree.update(get_lower(mo), 1);
				}
			}
		}
		
		reverse(p.begin(), p.end());
		tree.init(dcnt);
		sum = cnt = 0;
		
		for(int l=0,r=0; l<(int)p.size(); l=r)
		{
			while(r<(int)p.size() && p[l].first == p[r].first) ++r;
			
			ll x = p[l].first;
			ll mo = getmod(x), di = (x - mo) / S;
			ll cur = sum - di * cnt - tree.query(1, get_lower(mo)-1);
			
			for(int i=l; i<r; ++i)
			{
				val2[p[i].second] += cur;
				if(p[i].second < n)
				{
					sum += di; ++cnt;
					tree.update(get_lower(mo), 1);
				}
			}
		}
		
//		for(int i=0; i<n; ++i)
//			printf("val2[%d] = %lld\n",i,val2[i]);
	}
	
	ll tot = 0;
	for(int i=0; i<n; ++i)
		tot += val1[i] + val2[i];
	tot /= 2;
	
	for(int i=1; i<=Q; ++i)
	{
		if(res[i] == -1)
		{
			printf("-1\n");
		}
		else
		{
			int x = qs[i].first; ll k = qs[i].second;
			ll cur = tot;
			cur -= val1[x] + val2[x];
			cur += val1[n+i] + val2[n+i];
			if(a[x] != k)
				cur -= abs(a[x] - k) / S;
			printf("%lld\n",cur);
		}
	}
	return 0;
}