Problem: A mysterious device was discovered in an ancient ruin. The device consists of a disc with integers inscribed on both sides, a bundle of cards with an integer written on each of them and a pedestal within which the cards are placed. The disc rotates when the bundle of cards is put into the pedestal. Only one side of the disc is exposed to view at any one time.

The disc is radially segmented in equal angles into $K$ sections, and an integer, from $1$ to $K$ in increasing order, is inscribed clockwise on each section on the front side. The sections on the back side share the same boundaries with the front side, and a negative counterpart of that in the section on the front side is inscribed, i.e., if $X$ is inscribed in the front side section, $-X$ is inscribed on the counterpart section on the back side. There is a needle on the periphery of the disc, and it always points to the middle point of the arc that belongs to a section. Hereafter, we say "the disc is set to $X$" if the front side section just below the needle contains an integer $X$.

<image>
Fig.1 Disc with 5 sections (i.e., $K = 5$): When the disc is set to $1$ on the front side, it is set to $-1$ on the back side.

Investigation of the behavior of the device revealed the following:

When the bundle of cards is placed in the pedestal, the device sets the disc to 1.
Then, the device reads the cards slice by slice from top downward and performs one of the following actions according to the integer $A$ on the card

* If $A$ is a positive number, it rotates the disc clockwise by $|A|$ sections.
* If $A$ is zero, it turns the disc back around the vertical line defined by the needle and the center of the disc.
* If $A$ is a negative number, it rotates the disc counterclockwise by $|A|$ sections.



It is provided that $|A|$ is the absolute value of $A$. The final state of the device (i.e., to what section the needle is pointing) varies depending on the initial stacking sequence of the cards. To further investigate the behavior of the device, we swapped two arbitrary cards in the stack and placed the bundle in the pedestal to check what number the disc is set to. We performed this procedure over again and again.

Given the information on the device and several commands to swap two cards, make a program to determine the number to which the device is set at the completion of all actions. Note that the stacking sequence of the cards continues to change as a new trial is made.



Input

The input is given in the following format.


$K$ $N$ $Q$
$A_1$ $A_2$ ... $A_N$
$L_1$ $R_1$
$L_2$ $R_2$
$...$
$L_Q$ $R_Q$


The first line provides the number of sections $K$ ($2 \leq K \leq 10^9$), the slices of cards $N$ ($2 \leq N \leq 100,000$), and the number of commands $Q$ ($1 \leq Q \leq 100,000$). The second line provides an array of $N$ integers inscribed on the sections of the disc. $A_i$ ($-10^9 \leq A_i \leq 10^9$) represents the number written on the $i$-th card from the top. Each of the subsequent $Q$ lines defines the $i$-th command $L_i,R_i$ ($1 \leq L_ i < R_i \leq N$) indicating a swapping of $L_i$-th and $R_i$-th cards from the top followed by placing the card bundle in the device.

Output

For each command, output a line containing the number to which the device is set at the completion of all actions.

Examples

Input

5 3 1
1 -2 0
2 3


Output

-3


Input

5 7 5
0 0 3 3 3 3 3
1 2
2 3
3 4
4 5
5 6


Output

1
2
3
4
5

Solution (in CPP):

Solution:
#include<bits/stdc++.h>
typedef long long int ll;
typedef unsigned long long int ull;
#define BIG_NUM 2000000000
#define HUGE_NUM 99999999999999999
#define MOD 1000000007
#define EPS 0.000000001
using namespace std;


#define NUM 100005

enum Type{
	FRONT,
	BACK,
};

struct Info{
	Type face;
	ll diff;
};

int first_N,N;
ll value[NUM];
ll K;
Info table[4*NUM];

void init(){
	while(N < first_N)N *= 2;
}

Type next_face(Type left,Type right){

	if(left == right){

		return FRONT;

	}else{

		return BACK;
	}
}

ll getNUM(ll number){

	return (K-number)%K;
}

void update(int loc,Type face,ll value){

	loc += N-1;

	table[loc].face = face;
	table[loc].diff = value;

	if(N == 1)return;

	int parent = (loc-1)/2;
	int left_child,right_child;

	Type next_type;

	while(true){

		left_child = 2*parent+1;
		right_child = 2*parent+2;

		next_type = next_face(table[left_child].face,table[right_child].face);
		table[parent].face = next_type;

		if(table[left_child].face == FRONT){

			table[parent].diff = table[left_child].diff+table[right_child].diff;

		}else{ //table[left_child].face == BACK

			table[parent].diff = table[left_child].diff-table[right_child].diff;
		}

		table[parent].diff = (table[parent].diff+K)%K;

		if(parent == 0)break;
		else{
			parent = (parent-1)/2;
		}
	}
}

int main(){

	int num_query;
	int root = 0;

	scanf("%lld %d %d",&K,&first_N,&num_query);

	N = 1;
	init();

	for(int i = 0; i <= 2*N-2; i++){
		table[i].face = FRONT;
		table[i].diff = 0;
	}

	ll tmp;
	for(int i = 0; i < first_N; i++){

		scanf("%lld",&tmp);
		value[i] = tmp;

		if(tmp != 0){

			update(i,FRONT,getNUM(tmp));

		}else{

			update(i,BACK,0);
		}
	}

	int L,R;
	ll ans;

	for(int loop = 0; loop < num_query; loop++){

		scanf("%d %d",&L,&R);
		L--;
		R--;

		swap(value[L],value[R]);

		if(value[L] != 0){

			update(L,FRONT,getNUM(value[L]));

		}else{

			update(L,BACK,0);
		}

		if(value[R] != 0){

			update(R,FRONT,getNUM(value[R]));

		}else{

			update(R,BACK,0);
		}

		ans = ((table[root].diff+K)+1)%K;
		if(ans == 0){
			ans = K;
		}

		if(table[root].face == BACK){
			printf("-");
		}
		printf("%lld\n",ans);
	}

	return 0;
}