#include <bits/stdc++.h>

using namespace std;

#ifdef CKISEKI
#define safe cerr<<__PRETTY_FUNCTION__<<" line "<<__LINE__<<" safe\n"
#define debug(a...) debug_(#a, a)
#define orange(a...) orange_(#a, a)
template <typename ...T>
void debug_(const char *s, T ...a) {
    cerr << "\e[1;32m(" << s << ") = (";
    int cnt = sizeof...(T);
    (..., (cerr << a << (--cnt ? ", " : ")\e[0m\n")));
}
template <typename I>
void orange_(const char *s, I L, I R) {
    cerr << "\e[1;32m[ " << s << " ] = [ ";
    for (int f = 0; L != R; ++L)
        cerr << (f++ ? ", " : "") << *L;
    cerr << " ]\e[0m\n";
}
#else
#define safe ((void)0)
#define debug(...) safe
#define orange(...) safe
#endif

const int mod = 1000000007;

int Eval(int x, vector<int> a) {
  int s = 0;
  for (int y: a)
    s = (1LL * s * x + y) % mod;
  return s;
}

/*
int take_any(int a) {
  int s = 1;
  for (int i = 0; i < a; i++)
    s = (s * 2) % mod;
  return s;
}

int take_atleast_one(int a) {
  int s = 0;
  for (int i = 0; i < a; i++)
    s = (s * 2 + 1) % mod;
  return s;
}
*/

int modpow(int64_t e, int p) {
  int64_t r = 1;
  while (p) {
    if (p & 1) r = r * e % mod;
    e = e * e % mod;
    p >>= 1;
  }
  return r;
}

int modinv(int z) {
  return modpow(z, mod - 2);
}

int main() {
  int n, m;
  cin >> n >> m;
  vector<int> a(n);
  for (int &x: a) cin >> x, --x;

  vector<int> g(n + 1);
  for (int i = 0; i <= n; i++) {
    g[i] = Eval(i, {2, 3, 3, 3});
  }

  g[0] = 0;

  auto tg = g;
  // for (int i = 0; i <= n; i++) {
  //   for (int j = 0; j < i; j++) {
  //     g[i] = (g[i] - 1LL * g[j] * (i - j + 1) % mod + mod) % mod;
  //   }
  // }
  orange(g.begin(), g.end());

  // return 0;

  for (int i = n; i >= 0; i--) {
    tg[i] = g[i];
    if (i >= 2) tg[i] = (tg[i] + 1 * g[i - 2] % mod + mod) % mod;
    if (i >= 1) tg[i] = (tg[i] - 2 * g[i - 1] % mod + mod) % mod;
  }
  g = tg;

  /*
  int real_ans = 0;
  for (int s = 0; s < 1<<n; s++) {
    vector<int> ok(m);
    for (int i = 0; i < n; i++)
      if (s >> i & 1) ok[a[i]] = true;
    bool flag = false;
    for (int j = 0; j < m; j++) {
      if (!ok[j]) flag = true;
    }
    if (flag) continue;
    int coef = 0;
    for (int l = 0; l < n; l++) {
      int m = 0;
      for (int r = l; r < n; r++) {
        m |= 1 << r;
        if ((s & m) == m)
          (coef += g[r - l + 1]) %= mod;
      }
    }
    (real_ans += coef) %= mod;
  }
  debug(real_ans);
  */

  vector<int> cnt(m);
  for (int &x: a) ++cnt[x];
  for (int j = 0; j < m; j++) if (cnt[j] == 0) {
    cout << 0 << '\n';
    return 0;
  }

  vector<int> p1(n + 1), p2(n + 1), ip1(n + 1), ip2(n + 1);
  p1[0] = 0;
  for (int i = 1; i <= n; i++) {
    p1[i] = (p1[i - 1] + p1[i - 1] + 1) % mod;
  }
  p2[0] = 1;
  for (int i = 1; i <= n; i++) {
    p2[i] = (p2[i - 1] + p2[i - 1]) % mod;
  }
  for (int i = 0; i <= n; i++) {
    ip1[i] = modpow(p1[i], mod - 2);
    ip2[i] = modpow(p2[i], mod - 2);
  }

  const auto take_atleast_one = [&](int z) { return p1[z]; };
  const auto take_any = [&](int z) { return p2[z]; };
  const auto inv_take_atleast_one = [&](int z) { return ip1[z]; };
  // const auto inv_take_any = [&](int z) { return ip2[z]; };

  vector<int> pre(n + 2);
  for (int i = 1; i <= n; i++) {
    pre[i + 1] = (pre[i] + 1LL * g[i] * modinv(take_any(i))) % mod;
  }

  const auto gao = [&](int i, int l, int r) {
    l -= i;
    r -= i;
    ++l, ++r;
    return (pre[r] - pre[l] + mod) % mod;
    // int res = 0;
    // for (int j = l; j < r; j++) {
    //   res = (res + 1LL * g[j - i + 1] * modinv(take_any(j - i + 1))) % mod;
    // }
    // return res;
  };

  int64_t tot = 1;
  for (int j = 0; j < m; j++) {
    tot = tot * take_atleast_one(cnt[j]) % mod;
  }

  int ans = 0;

  vector<int> pos(m, -1);
  for (int i = n - 1; i >= 0; i--) {
    pos[a[i]] = i;

    int64_t prod = tot;
    vector<int> evt;
    for (int j = 0; j < m; j++) {
      if (pos[j] != -1) {
        evt.emplace_back(pos[j]);
      }
    }
    sort(evt.begin(), evt.end());

    int f = i;
    for (int p: evt) {
      int v = a[p];
      ans = (ans + prod * gao(i, f, p)) % mod;
      f = p;

      prod = prod * inv_take_atleast_one(cnt[v]) % mod;
      // prod = prod * modinv(take_atleast_one(cnt[v])) % mod;
      prod = prod * take_any(cnt[v]) % mod;
    }
    ans = (ans + prod * gao(i, f, n)) % mod;
  }


  cout << ans << '\n';
}