Problem: Alice and Bob decided to play one ultimate game. They have n piles, the i-th pile initially contain v_i chips. Alice selects a positive integer a from interval [1, m], and Bob selects a number b the same way. 

Then the game starts. In her turn, Alice can select any pile containing at least a chips, and remove exactly a chips from it. Similarly, in his turn, Bob can choose any pile with at least b chips, and remove exactly b chips from it. If a player cannot make a move, he or she loses. 

If both players play optimally, the outcome ultimately depends on the choice of a and b, and on the starting player. Consider a fixed pair (a,b). There are four types of games: 

  * Alice wins, regardless of who starts. 
  * Bob wins, regardless of who starts. 
  * If Alice starts, she wins. If Bob starts, he wins. We say that the first player wins. 
  * If Alice starts, Bob wins. If Bob starts, Alice wins. We say that the second player wins. 



Among all choices of a and b (i.e. for each pair (a, b) such that 1≤ a, b≤ m), determine how many games are won by Alice (regardless of who starts), how many are won by Bob (regardless of who starts), how many are won by the first player, and how many are won by the second player. 

Input

The first line contains two integers n and m (1 ≤ n ≤ 100, 1 ≤ m ≤ 10^5) — the number of piles, and the upper bound on the number of chips allowed to be taken in one turn, respectively. 

The second line contains n integers v_1, v_2, ..., v_n (1 ≤ v_i ≤ 10^{18}) — the starting number of chips in each pile.

Output

Print a single line containing four integers w_a, w_b, w_f, w_s — the number of games won by Alice, Bob, the first player, the second player, respectively. 

Examples

Input

2 2
4 5


Output

1 1 1 1


Input

2 20
4 5


Output

82 82 6 230

Note

In the first sample, there are a total of four choices for the tuple (a,b).

  * a = b = 1: It does not matter from which pile the chips are removed — there are 9 turns to be made, and the first player also makes the last, and hence he wins.
  * a = b = 2: The second player may win by always selecting the same pile as the first before there are 0 and 1 chips in the piles. Since it is impossible to remove 2 chips from any of them, the first player loses.
  * a = 1 and b = 2: 
    * Suppose Alice starts. She can win by removing a single chip from the pile with 5 chips and then copying Bob's decision. After the next four turns, the game ends with 1 chip in each pile and Bob unable to make a move. 
    * Suppose Bob starts. If he removes two chips from second pile, Alice counters by removing a chip from the first pile. From then on, she can always copy Bob's decision and win. If Bob removes two chips from the first pile in his first turn, Alice can also remove one. As the first pile only has one chip left, Bob is forced to remove two chips from the second pile, leaving 3. Regardless of what Alice does, she wins. 
Hence, Alice wins no matter who starts.
  * a = 2 and b = 1: This is symmetric with the previous case — hence Bob always wins. 



In the second sample, a lot of games, e.g. a = 7 and b = 6, end without anybody being able to remove single chip — which counts as a win for the second player. The games won for the first player are (1, 1), (1, 4), (2, 3), (3, 2), (4, 1), and (5, 5).

Solution (in CPP):

Solution:
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e2 + 10;
const int MAXM = 1e5 + 1000;
const int INF = 1e9 + 1e6;
int N, M;
int win(int* cur) {
  if (cur[0]) return 0;
  if (cur[2] > 1 or (cur[2] == 1 and (cur[1] & 1) == 0)) return 0;
  return (cur[1] & 1 ? 1 : 2);
}
long long vi[MAXN];
struct OP {
  int l;
  int cv, d;
  OP() { l = cv = d = -1; }
  OP(int a, int b = -1, int c = -1) { l = a, cv = b, d = c; }
  void act(int* cur) {
    if (cv != -1) cur[cv] += d;
  }
  bool operator<(const OP& o) const { return l < o.l; }
} op[MAXN * 4];
int main() {
  scanf("%d%d", &N, &M);
  for (int i = 0; i < N; i++) scanf("%lld", vi + i);
  long long fv[3];
  for (int i = 0; i < 3; i++) fv[i] = 0;
  for (int s = 3; s < M * 2; s++) {
    int a = 0;
    int ops = 0;
    int cur[3];
    for (int i = 0; i < 3; i++) cur[i] = 0;
    cur[0] = N;
    for (int i = 0, t1, t2; i < N; i++) {
      int l = static_cast<int>(vi[i] % s);
      if (l * 2 < s)
        op[ops++] = OP(l + 1, 0, -1);
      else if (l * 2 > s)
        op[ops++] = OP(s - l, 0, -1);
      if (l * 2 > s) op[ops++] = OP(s - l, 1, 1);
      if (l * 2 > s and (t1 = s - l) < (t2 = (l) / 2 + 1))
        op[ops++] = OP(t1, 2, 1), op[ops++] = OP(t2, 2, -1);
    }
    op[ops++] = OP(0, -1, -1);
    sort(op, op + ops);
    op[ops].l = (s + 1) / 2;
    for (int i = 0, j; i < ops; i = j) {
      for (j = i; j < ops and op[j].l == op[i].l; j++) op[j].act(cur);
      int f = win(cur);
      fv[f] += max(0, min(op[j].l, (s + 1) / 2) - max(op[i].l, max(1, s - M)));
    }
  }
  for (int i = 1; i < 3; i++) fv[i] *= 2;
  for (int i = 1; i <= M; i++) {
    long long p = 0;
    for (int j = 0; j < N; j++) p += vi[j] / i;
    if (p & 1)
      fv[1]++;
    else
      fv[2]++;
  }
  printf("%lld %lld %lld %lld\n", fv[0], fv[0], fv[1], fv[2]);
  return 0;
}