Code: The 67th Iteration of Counting is Fun

#include <bits/stdc++.h>
using namespace std;

//入力が必ず-mod<=a<modの時.
template <const int mod> // mod<2^30.
struct modint {          // mod変更が不可能.
  public:
    long long v;
    static void setmod(int m) {} //飾り.
    static constexpr long long getmod() { return mod; }
    modint() : v(0) {}
    template <typename T> modint(T a) : v(a) {
        if (v < 0)
            v += mod;
    }
    long long val() const { return v; }

    modint &operator=(const modint &b) = default;
    modint &operator+() const { return (*this); }
    modint operator-() const { return modint(0) - (*this); }
    modint operator+(const modint b) const { return modint(v) += b; }
    modint operator-(const modint b) const { return modint(v) -= b; }
    modint operator*(const modint b) const { return modint(v) *= b; }
    modint operator/(const modint b) const { return modint(v) /= b; }
    modint &operator+=(const modint b) {
        v += b.v;
        if (v >= mod)
            v -= mod;
        return *this;
    }
    modint &operator-=(const modint b) {
        v -= b.v;
        if (v < 0)
            v += mod;
        return *this;
    }
    modint &operator*=(const modint b) {
        v = v * b.v % mod;
        return *this;
    }
    modint &operator/=(modint b) { // b!=0 mod素数が必須.
        assert(b.v != 0);
        (*this) *= b.pow(mod - 2);
        return *this;
    }
    modint pow(long long n) const {
        modint ret = 1, p = v;
        if (n < 0)
            p = p.inv(), n = -n;
        while (n) {
            if (n & 1)
                ret *= p;
            p *= p;
            n >>= 1;
        }
        return ret;
    }
    modint inv() const { return pow(mod - 2); } //素数mod必須.

    modint &operator++() {
        *this += 1;
        return *this;
    }
    modint &operator--() {
        *this -= 1;
        return *this;
    }
    modint operator++(int) {
        modint ret = *this;
        *this += 1;
        return ret;
    }
    modint operator--(int) {
        modint ret = *this;
        *this -= 1;
        return ret;
    }
    friend bool operator==(const modint a, const modint b) {
        return a.v == b.v;
    }
    friend bool operator!=(const modint a, const modint b) {
        return a.v != b.v;
    }
    friend bool operator<(const modint a, const modint b) { return a.v < b.v; }
    friend bool operator<=(const modint a, const modint b) {
        return a.v <= b.v;
    }
    friend bool operator>=(const modint a, const modint b) {
        return a.v >= b.v;
    }
    friend bool operator>(const modint a, const modint b) { return a.v > b.v; }
    friend ostream &operator<<(ostream &os, const modint a) {
        return os << a.v;
    }
    friend istream &operator>>(istream &is,
                               modint &a) { //入力はmodをとってくれる.
        long long x;
        is >> x;
        x %= mod;
        a = modint(x);
        return is;
    }
};
using mint = modint<676767677>;
const long long mod = 676767677;

int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr);

    long long test = 1;
    cin >> test;
    bool submit = true;
    if (test >= 10010010)
        submit = false;
    if (test == 1)
        submit = true;

    while (test--) {
        int N, M;
        cin >> N >> M;
        vector<int> A(N), B(M);
        for (auto &a : A)
            cin >> a, B.at(a)++;

        vector<vector<int>> sepa(M);
        for (int i = 0; i < N; i++)
            sepa.at(A.at(i)).push_back(i);

        mint answer = 1;
        int sumb = B.at(0);
        for (int b = 1; b < M; b++) {
            for (auto pos : sepa.at(b)) {
                bool next = false, wait = false;
                if (pos && A.at(pos - 1) + 1 == A.at(pos))
                    next = true;
                if (pos && A.at(pos - 1) + 1 < A.at(pos))
                    wait = true;
                if (pos < N - 1 && A.at(pos + 1) + 1 == A.at(pos))
                    next = true;
                if (pos < N - 1 && A.at(pos + 1) + 1 < A.at(pos))
                    wait = true;

                if (!next && !wait) {
                    answer = 0;
                    break;
                }
                if (wait) {
                    answer *= B.at(b - 1);
                } else {
                    answer *= sumb;
                }
            }
            if (answer == 0)
                break;
            sumb += B.at(b);
        }

        cout << answer << "\n";
    }
}