Codeforces Round #345 (Div. 1) D. Zip-line

Vasya has decided to build a zip-line on trees of a nearby forest. He wants the line to be as long as possible but he doesn't remember exactly the heights of all trees in the forest. He is sure that he remembers correct heights of all trees except, possibly, one of them.

It is known that the forest consists of n trees staying in a row numbered from left to right with integers from 1 to n. According to Vasya, the height of the i-th tree is equal to h_i. The zip-line of length k should hang over k (1 ≤ k ≤ n) trees i₁, i₂, ..., i_k (i₁ < i₂ < ... < i_k) such that their heights form an increasing sequence, that is h_i1 < h_i2 < ... < h_ik.

Petya had been in this forest together with Vasya, and he now has q assumptions about the mistake in Vasya's sequence h. His i-th assumption consists of two integers a_i and b_i indicating that, according to Petya, the height of the tree numbered a_i is actually equal to b_i. Note that Petya's assumptions are independent from each other.

Your task is to find the maximum length of a zip-line that can be built over the trees under each of the q assumptions.

In this problem the length of a zip line is considered equal to the number of trees that form this zip-line.

Input

The first line of the input contains two integers n and m (1 ≤ n, m ≤ 400 000) — the number of the trees in the forest and the number of Petya's assumptions, respectively.

The following line contains n integers h_i (1 ≤ h_i ≤ 10⁹) — the heights of trees according to Vasya.

Each of the following m lines contains two integers a_i and b_i (1 ≤ a_i ≤ n, 1 ≤ b_i ≤ 10⁹).

Output

For each of the Petya's assumptions output one integer, indicating the maximum length of a zip-line that can be built under this assumption.

Examples

Input

4 4
1 2 3 4
1 1
1 4
4 3
4 5

Output

4
3
3
4

Input

4 2
1 3 2 6
3 5
2 4

Output

4
3

Note

Consider the first sample. The first assumption actually coincides with the height remembered by Vasya. In the second assumption the heights of the trees are (4, 2, 3, 4), in the third one they are (1, 2, 3, 3) and in the fourth one they are (1, 2, 3, 5).

自己没想出来做法，还是太弱了，可以离线做，因为每次只改变一个数字，把修改操作排序后扫两边就可以计算出修改后经过i个位置的最长路径。然后想办法判断是否所有的最长路径都要经过这点，可以发现若是存在另一点满足经过其的长度为最长路径，且从头到这一点的最长路径的长度和第i个点相同，那就说明并不是所有最长路径都要经过第i个点。顺便强行练了一发MAP。

#include <cstdio>
#include <iostream>
#include <cstring>
#include <map> 
#include <algorithm>
using namespace std;
struct ASK
{
	int a,b,pre,suc,num;
} ask[800010];
int tot,Tot,n,m,maxlen,ans[800010],s[800020],jud[800010],pre[800010],suc[800010],f[800010],h[800010];
map <int,int> hash;
bool camp(ASK a,ASK b)
{
	 return a.a<b.a;
}
int lowbit(int x)
{
	return x & (-x); 
}
int find(int x)
{
	int k=x;
	int ans=0;
	while(k)
	{
		ans=max(f[k],ans);
		k-=lowbit(k);
	}
	return ans;
} 
int Find(int x)
{
	int k=x;
	int ans=0;
	while(k <= Tot)
	{
		ans=max(f[k],ans);
		k+=lowbit(k);
	}
	return ans;
} 
void insert(int x,int v)
{
	int k=x;
	while(k <= Tot)
	{
		f[k]=max(f[k],v);
		k+=lowbit(k);
	}
}
void Insert(int x,int v)
{
	int k=x;
	while(k)
	{
		f[k]=max(f[k],v);
		k-=lowbit(k);
	}
}
void read()
{
	cin.sync_with_stdio(false);
	cin>>n>>m;
	for(int i=1;i <= n;i++)
	{
		cin>>h[i];
		s[++tot]=h[i];
	}
	for(int i=1;i <= m;i++)
	{
		cin>>ask[i].a>>ask[i].b;
		ask[i].num=i;
		s[++tot]=ask[i].b; 
	}
	sort(s+1,s+1+tot);
	for(int i=1;i <= tot;i++)
	 if(s[i] != s[i-1])
	  hash[s[i]]=++Tot;
	for(int i=1;i <= n;i++)
	 h[i]=hash[h[i]];
	for(int i=1;i <= m;i++)
	 ask[i].b=hash[ask[i].b];
}
void deal()
{
	sort(ask+1,ask+m+1,camp);
	int now=0;
	for(int i=1;i <= n;i++)
	{
		pre[i]=find(h[i]-1)+1;
		while(ask[now+1].a == i)
		{
			now++;
			ask[now].pre=find(ask[now].b-1)+1;
		}
		insert(h[i],pre[i]);
	}
	memset(f,0,sizeof(f));
	now=m+1;
	for(int i=n;i >= 1;i--)
	{
		suc[i]=Find(h[i]+1)+1;
		maxlen=max(maxlen,suc[i]);
		while(ask[now-1].a == i)
		{
			now--;
			ask[now].suc=Find(ask[now].b+1)+1;
		} 
		Insert(h[i],suc[i]);
	}
	for(int i=1;i <= n;i++)
	 if(suc[i]+pre[i] == maxlen+1) jud[suc[i]]++;
	for(int i=1;i <= m;i++)
	{
		int ans1=ask[i].suc+ask[i].pre-1;
		int ans2=(suc[ask[i].a]+pre[ask[i].a] != maxlen+1) || (ans2=jud[suc[ask[i].a]] != 1) ? maxlen:maxlen-1;
		ans[ask[i].num]=max(ans1,ans2);
	}
} 
void write()
{
	for(int i=1;i <= m;i++)
	 cout<<ans[i]<<endl;
}
int main()
{
    read();
	deal();
	write();
 }