#include <bits/stdc++.h>
using namespace std;
template <class T>
bool ckmin(T& a, const T& b) {
  return b < a ? a = b, 1 : 0;
}
template <class T>
bool ckmax(T& a, const T& b) {
  return a < b ? a = b, 1 : 0;
}
int x, y, z;
vector<vector<vector<vector<long long>>>> dp(
    6, vector<vector<vector<long long>>>(
           6, vector<vector<long long>>(6, vector<long long>(100000, -1))));
int g(long long a, long long b) {
  if (a <= 0) return 0;
  if (dp[x][y][z][(3 * (a) + (b))] != -1) return dp[x][y][z][(3 * (a) + (b))];
  set<long long> grunds;
  if (b == 0) {
    grunds.insert(g(a - x, 0));
    grunds.insert(g(a - y, 1));
    grunds.insert(g(a - z, 2));
  } else if (b == 1) {
    grunds.insert(g(a - x, 0));
    grunds.insert(g(a - z, 2));
  } else {
    grunds.insert(g(a - x, 0));
    grunds.insert(g(a - y, 1));
  }
  if (grunds.find(0) == grunds.end()) return dp[x][y][z][(3 * (a) + (b))] = 0;
  if (grunds.find(1) == grunds.end()) return dp[x][y][z][(3 * (a) + (b))] = 1;
  if (grunds.find(2) == grunds.end()) return dp[x][y][z][(3 * (a) + (b))] = 2;
  if (grunds.find(3) == grunds.end()) return dp[x][y][z][(3 * (a) + (b))] = 3;
  assert(false);
}
bool check(int s, int l) {
  while (s + l < 1000) {
    if (dp[x][y][z][s] != dp[x][y][z][s + l]) return false;
    ++s;
  }
  return true;
}
vector<vector<vector<pair<long long, long long>>>> cycs(
    6, vector<vector<pair<long long, long long>>>(
           6, vector<pair<long long, long long>>(6)));
void find() {
  for (int s = (0); s < (100); ++s)
    for (int l = (1); l < (100); ++l) {
      if (check(s, l)) {
        cycs[x][y][z] = make_pair(s, l);
        return;
      }
    }
}
int G(long long a, long long b) {
  if (a <= 0) return 0;
  long long sr = (3 * (a) + (b));
  if (sr >= cycs[x][y][z].first) {
    sr -= cycs[x][y][z].first;
    sr %= cycs[x][y][z].second;
    return dp[x][y][z][cycs[x][y][z].first + sr];
  } else {
    return dp[x][y][z][sr];
  }
}
int main() {
  cin.sync_with_stdio(0);
  cin.tie(0);
  cin.exceptions(cin.failbit);
  for (x = 1; x <= 5; ++x)
    for (y = 1; y <= 5; ++y)
      for (z = 1; z <= 5; ++z) {
        for (int i = (0); i < (10000); ++i)
          for (int j = (0); j < (3); ++j) g(i, j);
        find();
      }
  int t;
  cin >> t;
  while (t--) {
    int n;
    cin >> n >> x >> y >> z;
    vector<long long> a(n);
    for (int i = (0); i < (n); ++i) cin >> a[i];
    long long s = 0;
    for (int i = (0); i < (n); ++i) {
      s ^= G(a[i], 0);
    }
    long long ans = 0;
    for (int i = (0); i < (n); ++i) {
      if ((G(a[i], 0) ^ s ^ G(a[i] - x, 0)) == 0) ++ans;
      if ((G(a[i], 0) ^ s ^ G(a[i] - y, 1)) == 0) ++ans;
      if ((G(a[i], 0) ^ s ^ G(a[i] - z, 2)) == 0) ++ans;
    }
    cout << ans << endl;
  }
}

### Prompt

In CPP, your task is to solve the following problem:

The Red Kingdom is attacked by the White King and the Black King!

The Kingdom is guarded by n castles, the i-th castle is defended by a_i soldiers. To conquer the Red Kingdom, the Kings have to eliminate all the defenders. 

Each day the White King launches an attack on one of the castles. Then, at night, the forces of the Black King attack a castle (possibly the same one). Then the White King attacks a castle, then the Black King, and so on. The first attack is performed by the White King.

Each attack must target a castle with at least one alive defender in it. There are three types of attacks:

  * a mixed attack decreases the number of defenders in the targeted castle by x (or sets it to 0 if there are already less than x defenders); 
  * an infantry attack decreases the number of defenders in the targeted castle by y (or sets it to 0 if there are already less than y defenders); 
  * a cavalry attack decreases the number of defenders in the targeted castle by z (or sets it to 0 if there are already less than z defenders). 



The mixed attack can be launched at any valid target (at any castle with at least one soldier). However, the infantry attack cannot be launched if the previous attack on the targeted castle had the same type, no matter when and by whom it was launched. The same applies to the cavalry attack. A castle that was not attacked at all can be targeted by any type of attack.

The King who launches the last attack will be glorified as the conqueror of the Red Kingdom, so both Kings want to launch the last attack (and they are wise enough to find a strategy that allows them to do it no matter what are the actions of their opponent, if such strategy exists). The White King is leading his first attack, and you are responsible for planning it. Can you calculate the number of possible options for the first attack that allow the White King to launch the last attack? Each option for the first attack is represented by the targeted castle and the type of attack, and two options are different if the targeted castles or the types of attack are different.

Input

The first line contains one integer t (1 ≤ t ≤ 1000) — the number of test cases.

Then, the test cases follow. Each test case is represented by two lines. 

The first line contains four integers n, x, y and z (1 ≤ n ≤ 3 ⋅ 10^5, 1 ≤ x, y, z ≤ 5). 

The second line contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^{18}).

It is guaranteed that the sum of values of n over all test cases in the input does not exceed 3 ⋅ 10^5.

Output

For each test case, print the answer to it: the number of possible options for the first attack of the White King (or 0, if the Black King can launch the last attack no matter how the White King acts).

Examples

Input


3
2 1 3 4
7 6
1 1 2 3
1
1 1 2 2
3


Output


2
3
0


Input


10
6 5 4 5
2 3 2 3 1 3
1 5 2 3
10
4 4 2 3
8 10 8 5
2 2 1 4
8 5
3 5 3 5
9 2 10
4 5 5 5
2 10 4 2
2 3 1 4
1 10
3 1 5 3
9 8 7
2 5 4 5
8 8
3 5 1 4
5 5 10


Output


0
2
1
2
5
12
5
0
0
2

### Response

```cpp
#include <bits/stdc++.h>
using namespace std;
template <class T>
bool ckmin(T& a, const T& b) {
  return b < a ? a = b, 1 : 0;
}
template <class T>
bool ckmax(T& a, const T& b) {
  return a < b ? a = b, 1 : 0;
}
int x, y, z;
vector<vector<vector<vector<long long>>>> dp(
    6, vector<vector<vector<long long>>>(
           6, vector<vector<long long>>(6, vector<long long>(100000, -1))));
int g(long long a, long long b) {
  if (a <= 0) return 0;
  if (dp[x][y][z][(3 * (a) + (b))] != -1) return dp[x][y][z][(3 * (a) + (b))];
  set<long long> grunds;
  if (b == 0) {
    grunds.insert(g(a - x, 0));
    grunds.insert(g(a - y, 1));
    grunds.insert(g(a - z, 2));
  } else if (b == 1) {
    grunds.insert(g(a - x, 0));
    grunds.insert(g(a - z, 2));
  } else {
    grunds.insert(g(a - x, 0));
    grunds.insert(g(a - y, 1));
  }
  if (grunds.find(0) == grunds.end()) return dp[x][y][z][(3 * (a) + (b))] = 0;
  if (grunds.find(1) == grunds.end()) return dp[x][y][z][(3 * (a) + (b))] = 1;
  if (grunds.find(2) == grunds.end()) return dp[x][y][z][(3 * (a) + (b))] = 2;
  if (grunds.find(3) == grunds.end()) return dp[x][y][z][(3 * (a) + (b))] = 3;
  assert(false);
}
bool check(int s, int l) {
  while (s + l < 1000) {
    if (dp[x][y][z][s] != dp[x][y][z][s + l]) return false;
    ++s;
  }
  return true;
}
vector<vector<vector<pair<long long, long long>>>> cycs(
    6, vector<vector<pair<long long, long long>>>(
           6, vector<pair<long long, long long>>(6)));
void find() {
  for (int s = (0); s < (100); ++s)
    for (int l = (1); l < (100); ++l) {
      if (check(s, l)) {
        cycs[x][y][z] = make_pair(s, l);
        return;
      }
    }
}
int G(long long a, long long b) {
  if (a <= 0) return 0;
  long long sr = (3 * (a) + (b));
  if (sr >= cycs[x][y][z].first) {
    sr -= cycs[x][y][z].first;
    sr %= cycs[x][y][z].second;
    return dp[x][y][z][cycs[x][y][z].first + sr];
  } else {
    return dp[x][y][z][sr];
  }
}
int main() {
  cin.sync_with_stdio(0);
  cin.tie(0);
  cin.exceptions(cin.failbit);
  for (x = 1; x <= 5; ++x)
    for (y = 1; y <= 5; ++y)
      for (z = 1; z <= 5; ++z) {
        for (int i = (0); i < (10000); ++i)
          for (int j = (0); j < (3); ++j) g(i, j);
        find();
      }
  int t;
  cin >> t;
  while (t--) {
    int n;
    cin >> n >> x >> y >> z;
    vector<long long> a(n);
    for (int i = (0); i < (n); ++i) cin >> a[i];
    long long s = 0;
    for (int i = (0); i < (n); ++i) {
      s ^= G(a[i], 0);
    }
    long long ans = 0;
    for (int i = (0); i < (n); ++i) {
      if ((G(a[i], 0) ^ s ^ G(a[i] - x, 0)) == 0) ++ans;
      if ((G(a[i], 0) ^ s ^ G(a[i] - y, 1)) == 0) ++ans;
      if ((G(a[i], 0) ^ s ^ G(a[i] - z, 2)) == 0) ++ans;
    }
    cout << ans << endl;
  }
}

```