#ifdef LOCAL
#include "stdafx.h"
#else
#include <bits/stdc++.h>
#define IL inline
#define LL long long
#define eb emplace_back
#define sz(v) ((int) (v).size())
#define me(f, x) memset(f, x, sizeof(f))
#define mc(f, g) memcpy(f, g, sizeof(g))
#define L(i, j, k) for (int i = (j); i <= (k); ++i)
#define R(i, j, k) for (int i = (j); i >= (k); --i)
#define FIO(FILE) freopen(FILE".in", "r", stdin), freopen(FILE".out", "w", stdout)
using namespace std;

using vi = vector<int>;
#endif

constexpr int N = 205;
constexpr int P = 1e9 + 7;
int n, m, a[N];

int f[2][N][N][N];
int fp[N][N][N];
int fq[N][N][N];

int g[N][N][N];
int gp[N][N];

int h[N];

int main () {
  ios::sync_with_stdio(0), cin.tie(0);
  cin >> n >> m;
  L (i, 1, m) {
    int x;
    cin >> x, ++a[x];
  }
  a[0] = max(a[0], 1);
  g[n + 1][0][0] = 1;
  L (i, 0, n) {
    gp[0][i] = 1;
  }
  R (i, n, 0) {
    L (j, 0, n) {
      L (k, j, n) {
        if (a[i] == 0) {
          (g[i][j][k] += g[i + 1][j][k]) %= P;
        }
        int up = max(1, a[i]);
        if (j > 0 && k >= up) {
          (g[i][j][k] += gp[j - 1][k - up]) %= P;
        }
      }
    }
    L (j, 0, n) {
      L (k, j, n) {
        gp[j][k] = ((k > 0 ? gp[j][k - 1] : 0) + g[i][j][k]) % P;
      }
    }
  }
  L (i, a[0], n) {
    L (x, 0, n - i) {
      L (y, 0, i + x) {
        f[0][i][x][y] = 1;
      }
    }
  }
  L (i, 1, n) {
    int o = i & 1;
    if (a[i] == 0) {
      L (j, 0, n) {
        L (k, 0, min(n - i, n - j)) {
          h[i + k] = (h[i + k] + (LL)f[o ^ 1][j][n - j - k][1] * g[i + 1][k][n - j]) % P; 
        }
      }
    }
    int up = i > 1 ? n / (i - 1) : n;
    L (j, 0, n) {
      L (x, 0, n - j) {
        L (y, 0, up) {
          int &v = f[o ^ 1][j][x][y];
          fp[j][x][y] = ((j > 0 && y > 0 ? fp[j - 1][x][y - 1] : 0) + v) % P;
          fq[j][x][y] = ((j > 0 ? fq[j - 1][x + 1][y] : 0) + v) % P;
          v = 0;
        }
      }
    }
    L (j, a[i], n) {
      L (x, 0, n - j) {
        L (y, 0, (j + x) / i) {
          LL w = 0;
          if (y < a[i]) {
            w = fq[j - a[i]][x + a[i] - y][y];
          } else {
            int t = max(2 * y - up, a[i]);
            w = fp[j - t][x][2 * y - t];
            if (j >= y) {
              w += P - fp[j - y][x][y] + fq[j - y][x][y];
            }
          }
          f[o][j][x][y] = w % P;
        }
      }
    }
  }
  L (t, 0, n) {
    L (i, 0, t - 1) {
      h[i] = (h[i] + g[0][t][n]) % P;
    }
  }
  L (i, 1, n - 1) {
    (h[i] += P - h[i + 1]) %= P;
  }
  L (i, 1, n) {
    cout << h[i] << " \n"[i == n]; 
  }
}
// I love WHQ!