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>

using namespace std;

using i64 = int64_t;

const i64 MOD = 1e9 + 7;


struct BIT{
    vector<i64> elm;
    BIT(i64 n) : elm(n + 1, 0){}
    i64 sum(i64 x){
        i64 val = 0;
        for(; x > 0; x -= x & -x)
            val += elm[x];
        return val;
    }
    void add(i64 x, i64 val){
        for(++x; x < elm.size(); x += x & -x)
            elm[x] += val;
    }
};

struct Segtree{
    i64 n, m;
    vector<i64> elm, lazy;
    Segtree(i64 n, i64 m) : n(n), m(m), elm(2 * n, 0), lazy(2 * n, 1){}
    vector<i64> get_list(i64 x, i64 y){
        vector<i64> ret_list;
        for(x += n, y += n - 1; x; x >>= 1, y >>= 1){
            ret_list.emplace_back(x);
            if(x != y)
                ret_list.emplace_back(y);
        }
        return ret_list;
    }
    void eval(i64 x){
        elm[x] *= lazy[x];
        if(x < n){
            lazy[2 * x] *= lazy[x];
            lazy[2 * x + 1] *= lazy[x];
        }
        lazy[x] = 1;
    }
    void update(i64 x){
        i64 y = n;
        vector<i64> index_list = get_list(x, y);
        for(i64 i = index_list.size() - 1; i >= 0; --i)
            eval(index_list[i]);
        for(x += n, y += n - 1; x <= y; x >>= 1, y >>= 1){
            if(x & 1){
                lazy[x] *= -1;
                eval(x++);
            }
            if(!(y & 1)){
                lazy[y] *= -1;
                eval(y--);
            }
        }
        for(auto& index : index_list){
            if(index < n){
                eval(2 * index);
                eval(2 * index + 1);
                elm[index] = elm[2 * index] + elm[2 * index + 1];
            }
        }
    }
    i64 get(){
        i64 x = 0, y = n;
        vector<i64> index_list = get_list(x, y);
        for(i64 i = index_list.size() - 1; i >= 0; --i)
            eval(index_list[i]);
        i64 l = 0, r = 0;
        for(x += n, y += n - 1; x <= y; x >>= 1, y >>= 1){
            if(x & 1){
                eval(x);
                i64 val = elm[x++];
                val = val >= 0 ? val % m : m - (abs(val) % m);
                l += val;
                l %= m;
            }
            if(!(y & 1)){
                eval(y);
                i64 val = elm[y--];
                val = val >= 0 ? val % m : m - (abs(val) % m);
                r += val;
                r %= m;
            }
        }
        return (l + r) % m;
    }
    void set(i64 pos, i64 val){
        vector<i64> index_list = get_list(pos, pos + 1);
        for(i64 i = index_list.size() - 1; i >= 0; --i)
            eval(index_list[i]);
        elm[pos + n] = val;
        lazy[pos + n] = 1;
        for(auto& index : index_list){
            if(index < n){
                eval(2 * index);
                eval(2 * index + 1);
                elm[index] = elm[2 * index] + elm[2 * index + 1];
            }
        }
    }
};

signed main(){
    i64 k, n, q;
    cin >> k >> n >> q;
    vector<i64> v(n);
    for(auto& x : v){
        cin >> x;
        x *= -1;
    }
    vector<pair<i64,i64>> query;
    for(i64 i = 0; i < q; ++i){
        i64 a, b;
        cin >> a >> b;
        --a, --b;
        query.emplace_back(a, b);
    }

    BIT zero_cnt(n);
    Segtree seg(n, k);
    for(i64 i = 0; i < n; ++i){
        if(v[i] == 0){
            zero_cnt.add(i, 1);
            seg.update(i);
        }else{
            seg.set(i, v[i] * ((zero_cnt.sum(i)) % 2 == 0 ? 1 : -1));
        }
    }


    auto replace = [&](i64 pos, i64 val){
        if(v[pos] == 0){
            zero_cnt.add(pos, 1);
            seg.update(pos);
        }
        if(val == 0){
            zero_cnt.add(pos, 1);
            seg.update(pos);
        }
        seg.set(pos, val * ((zero_cnt.sum(pos)) % 2 == 0 ? 1 : -1));
        v[pos] = val;
    };

    /*
    i64 ret = seg.get();
    cout << "real : " << ret << endl << "answer : ";
    cout << (zero_cnt.sum(n) % 2 == 0 ? 1 : -1) * ((ret % n) + 1) << endl;
    */

    for(auto& q : query){
        i64 a, b;
        tie(a, b) = q;
        i64 a_val = v[a], b_val = v[b];

        // v[a] to v[b]
        replace(a, b_val);
        // v[b] to v[a]
        replace(b, a_val);

        i64 ret = seg.get();
        // cout << "real : " << ret << endl << "answer : ";
        cout << (zero_cnt.sum(n) % 2 == 0 ? 1 : -1) * ((ret % k) + 1) << endl;
    }
}