func_code_string: #include <bits/stdc++.h>   using namespace std;   template <int M>   struct static_mint {     static_assert(0 < M,  Module must be positive );     int val;     static_mint() : val() {}     static_mint(long long x) : val(x % M) {       if (val < 0) val += M;     }     static_mint pow(long long n) const {       static_mint ans = 1, x(*this);       while (n) {         if (n & 1) ans *= x;         x *= x;         n /= 2;       }       return ans;     }     static_mint inv() const { return pow(M - 2); }     friend static_mint pow(const static_mint &m, long long n) { return m.pow(n); }     friend static_mint inv(const static_mint &m) { return m.inv(); }     static_mint operator+() const {       static_mint m;       m.val = val;       return m;     }     static_mint operator-() const {       static_mint m;       m.val = M - val;       return m;     }     static_mint &operator+=(const static_mint &m) {       if ((val += m.val) >= M) val -= M;       return *this;     }     static_mint &operator-=(const static_mint &m) {       if ((val -= m.val) < 0) val += M;       return *this;     }     static_mint &operator*=(const static_mint &m) {       val = (long long)val * m.val % M;       return *this;     }     static_mint &operator/=(const static_mint &m) {       val = (long long)val * m.inv().val % M;       return *this;     }     friend static_mint operator+(const static_mint &lhs, const static_mint &rhs) {       return static_mint(lhs) += rhs;     }     friend static_mint operator-(const static_mint &lhs, const static_mint &rhs) {       return static_mint(lhs) -= rhs;     }     friend static_mint operator*(const static_mint &lhs, const static_mint &rhs) {       return static_mint(lhs) *= rhs;     }     friend static_mint operator/(const static_mint &lhs, const static_mint &rhs) {       return static_mint(lhs) /= rhs;     }     friend bool operator==(const static_mint &lhs, const static_mint &rhs) {       return lhs.val == rhs.val;     }     friend bool operator!=(const static_mint &lhs, const static_mint &rhs) {       return lhs.val != rhs.val;     }     static_mint &operator++() { return *this += 1; }     static_mint &operator--() { return *this -= 1; }     static_mint operator++(int) {       static_mint result(*this);       *this += 1;       return result;     }     static_mint operator--(int) {       static_mint result(*this);       *this -= 1;       return result;     }     template <typename T>     explicit operator T() const {       return T(val);     }     friend std::ostream &operator<<(std::ostream &os, const static_mint &m) {       return os << m.val;     }     friend std::istream &operator>>(std::istream &is, static_mint &m) {       long long x;       is >> x;       m = x;       return is;     }   };   template <typename>   struct is_mint : public std::false_type {};   template <int M>   struct is_mint<static_mint<M>> : public std::true_type {};   template <typename T>   struct matrix : std::vector<std::vector<T>> {     int n, m;     matrix() : n(), m() {}     matrix(int n, int m, const T val = T())         : n(n), m(m), std::vector<std::vector<T>>(n, std::vector<T>(m, val)) {}     matrix(std::initializer_list<std::vector<T>> l)         : std::vector<std::vector<T>>(l) {       n = l.size();       if (l.size()) {         m = l.begin()->size();       }     }     matrix &operator+=(const matrix &mat) {       assert(n == mat.n && m == mat.m);       for (int i = 0; i < n; i++) {         for (int j = 0; j < m; j++) {           (*this)[i][j] += mat[i][j];         }       }       return *this;     }     matrix &operator-=(const matrix &mat) {       assert(n == mat.n && m == mat.m);       for (int i = 0; i < n; i++) {         for (int j = 0; j < m; j++) {           (*this)[i][j] -= mat[i][j];         }       }       return *this;     }     matrix &operator*=(const matrix &mat) {       assert(m == mat.n);       matrix res(n, mat.m);       for (int i = 0; i < n; i++) {         for (int j = 0; j < mat.m; j++) {           for (int k = 0; k < m; k++) {             res[i][j] += (*this)[i][k] * mat[k][j];           }         }       }       this->swap(res);       return *this;     }     matrix &operator*=(const T &val) {       for (int i = 0; i < n; i++) {         for (int j = 0; j < m; j++) {           (*this)[i][j] *= val;         }       }       return *this;     }     friend matrix operator+(matrix a, const matrix &b) {       a += b;       return a;     }     friend matrix operator-(matrix a, const matrix &b) {       a -= b;       return a;     }     friend matrix operator*(matrix a, const matrix &b) {       a *= b;       return a;     }     friend matrix operator*(matrix a, const T &val) {       a *= val;       return a;     }     friend matrix operator*(const T &val, matrix a) {       a *= val;       return a;     }   };   int main() {     ios::sync_with_stdio(false);     cin.tie(nullptr);     using mint = static_mint<1000000007>;     int n, x;     cin >> n >> x;     vector<int> cnt(101);     for (int i = 0, d; i < n; i++) {       cin >> d, cnt[d] += 1;     }     matrix<mint> m(101, 101);     m[0][0] = 1 + cnt[1];     for (int i = 1; i < 100; i++) {       m[i][0] = cnt[i + 1] - cnt[i];     }     m[100][0] = -cnt[100];     for (int j = 1; j < 101; j++) {       m[j - 1][j] = 1;     }     matrix<mint> ans(101, 101);     for (int i = 0; i < 101; i++) ans[0][0] = 1;     for (; x; x /= 2) {       if (x & 1) ans *= m;       m *= m;     }     cout << ans[0][0] <<   n ;     return 0;   }   