Problem: Heidi got one brain, thumbs up! But the evening isn't over yet and one more challenge awaits our dauntless agent: after dinner, at precisely midnight, the N attendees love to play a very risky game...

Every zombie gets a number ni (1 ≤ ni ≤ N) written on his forehead. Although no zombie can see his own number, he can see the numbers written on the foreheads of all N - 1 fellows. Note that not all numbers have to be unique (they can even all be the same). From this point on, no more communication between zombies is allowed. Observation is the only key to success. When the cuckoo clock strikes midnight, all attendees have to simultaneously guess the number on their own forehead. If at least one of them guesses his number correctly, all zombies survive and go home happily. On the other hand, if not a single attendee manages to guess his number correctly, all of them are doomed to die!

Zombies aren't very bright creatures though, and Heidi has to act fast if she does not want to jeopardize her life. She has one single option: by performing some quick surgery on the brain she managed to get from the chest, she has the ability to remotely reprogram the decision-making strategy of all attendees for their upcoming midnight game! Can you suggest a sound strategy to Heidi which, given the rules of the game, ensures that at least one attendee will guess his own number correctly, for any possible sequence of numbers on the foreheads?

Given a zombie's rank R and the N - 1 numbers ni on the other attendees' foreheads, your program will have to return the number that the zombie of rank R shall guess. Those answers define your strategy, and we will check if it is flawless or not.

Input

The first line of input contains a single integer T (1 ≤ T ≤ 50000): the number of scenarios for which you have to make a guess.

The T scenarios follow, described on two lines each: 

  * The first line holds two integers, N (2 ≤ N ≤ 6), the number of attendees, and R (1 ≤ R ≤ N), the rank of the zombie who has to make the guess. 
  * The second line lists N - 1 integers: the numbers on the foreheads of all other attendees, listed in increasing order of the attendees' rank. (Every zombie knows the rank of every other zombie.) 

Output

For every scenario, output a single integer: the number that the zombie of rank R shall guess, based on the numbers ni on his N - 1 fellows' foreheads.

Examples

Input

4
2 1
1
2 2
1
2 1
2
2 2
2


Output

1
2
2
1


Input

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


Output

5
2

Note

For instance, if there were N = 2 two attendees, a successful strategy could be: 

  * The zombie of rank 1 always guesses the number he sees on the forehead of the zombie of rank 2. 
  * The zombie of rank 2 always guesses the opposite of the number he sees on the forehead of the zombie of rank 1. 

Solution (in CPP):

Solution:
#include <bits/stdc++.h>
using namespace std;
int R[8][8][8];
int A[8][8];
int B[8];
int f(int n) {
  int i, j;
  for (i = (0); i < (n); ++i) {
    int t = 0;
    for (j = (0); j < (n); ++j)
      if (j == i)
        t += A[i][j];
      else
        t += B[j] * A[i][j];
    if (B[i] == t % n) return 1;
  }
  return 0;
}
int generate(int n) {
  int i, j, k;
  int m = 1;
  for (i = (0); i < (n); ++i) m *= n;
  int total = m;
  for (i = (0); i < (total); ++i) {
    int t = i;
    for (j = (0); j < (n); ++j)
      for (k = (0); k < (n); ++k) A[j][k] = n - 1;
    for (j = (0); j < (n); ++j) {
      A[j][j] = t % n;
      t /= n;
    }
    for (j = (0); j < (m); ++j) {
      t = j;
      for (k = (0); k < (n); ++k) {
        B[k] = t % n;
        t /= n;
      }
      if (f(n) == 0) break;
    }
    if (j == m) {
      for (j = (0); j < (n); ++j)
        for (k = (0); k < (n); ++k) R[n][j][k] = A[j][k];
      return 1;
    }
  }
  return 0;
}
int main() {
  int i;
  for (i = (2); i < (7); ++i)
    if (generate(i) == 0) throw 0;
  int T, t;
  scanf("%d", &T);
  for (t = (0); t < (T); ++t) {
    int n, r;
    scanf("%d%d", &n, &r);
    --r;
    for (i = (0); i < (n); ++i)
      if (i != r) {
        scanf("%d", &B[i]);
        --B[i];
      }
    int res = 0;
    for (i = (0); i < (n); ++i)
      if (i == r)
        res += R[n][r][i];
      else
        res += B[i] * R[n][r][i];
    printf("%d\n", res % n + 1);
  }
  return 0;
};