#pragma GCC optimize("Ofast")

#include "bits/stdc++.h"

#define rep(i, n) for (int i = 0; i < (n); ++i)
#define rep1(i, n) for (int i = 1; i < (n); ++i)
#define rep1n(i, n) for (int i = 1; i <= (n); ++i)
#define repr(i, n) for (int i = (n) - 1; i >= 0; --i)
#define pb push_back
#define eb emplace_back
#define all(a) (a).begin(), (a).end()
#define rall(a) (a).rbegin(), (a).rend()
#define each(x, a) for (auto &x : a)
#define ar array
#define vec vector
#define range(i, n) rep(i, n)

using namespace std;


using ll = long long;
using ull = unsigned long long;
using ld = long double;
using str = string;
using pi = pair<int, int>;
using pl = pair<ll, ll>;

using vi = vector<int>;
using vl = vector<ll>;
using vpi = vector<pair<int, int>>;
using vvi = vector<vi>;

int Bit(int mask, int b) { return (mask >> b) & 1; }

template<class T>
bool ckmin(T &a, const T &b) {
    if (b < a) {
        a = b;
        return true;
    }
    return false;
}

template<class T>
bool ckmax(T &a, const T &b) {
    if (b > a) {
        a = b;
        return true;
    }
    return false;
}

// [l, r)
template<typename T, typename F>
T FindFirstTrue(T l, T r, const F &predicat) {
    --l;
    while (r - l > 1) {
        T mid = l + (r - l) / 2;
        if (predicat(mid)) {
            r = mid;
        } else {
            l = mid;
        }
    }
    return r;
}


template<typename T, typename F>
T FindLastFalse(T l, T r, const F &predicat) {
    return FindFirstTrue(l, r, predicat) - 1;
}

template<typename T>
int normalize(T value, int mod) {
    if (value < -mod || value >= 2 * mod) value %= mod;
    if (value < 0) value += mod;
    if (value >= mod) value -= mod;
    return value;
}

template<int mod>
struct static_modular_int {
    using mint = static_modular_int<mod>;

    int value;

    static_modular_int() : value(0) {}

    static_modular_int(const mint &x) : value(x.value) {}

    template<typename T, typename U = std::enable_if_t<std::is_integral<T>::value>>
    static_modular_int(T value) : value(normalize(value, mod)) {}

    template<typename T>
    mint power(T degree) const {
        degree = normalize(degree, mod - 1);
        mint prod = 1, a = *this;
        for (; degree > 0; degree >>= 1, a *= a)
            if (degree & 1)
                prod *= a;

        return prod;
    }

    mint inv() const {
        return power(-1);
    }

    mint &operator=(const mint &x) {
        value = x.value;
        return *this;
    }

    mint &operator+=(const mint &x) {
        value += x.value;
        if (value >= mod) value -= mod;
        return *this;
    }

    mint &operator-=(const mint &x) {
        value -= x.value;
        if (value < 0) value += mod;
        return *this;
    }

    mint &operator*=(const mint &x) {
        value = int64_t(value) * x.value % mod;
        return *this;
    }

    mint &operator/=(const mint &x) {
        return *this *= x.inv();
    }

    friend mint operator+(const mint &x, const mint &y) {
        return mint(x) += y;
    }

    friend mint operator-(const mint &x, const mint &y) {
        return mint(x) -= y;
    }

    friend mint operator*(const mint &x, const mint &y) {
        return mint(x) *= y;
    }

    friend mint operator/(const mint &x, const mint &y) {
        return mint(x) /= y;
    }

    mint &operator++() {
        ++value;
        if (value == mod) value = 0;
        return *this;
    }

    mint &operator--() {
        --value;
        if (value == -1) value = mod - 1;
        return *this;
    }

    mint operator++(int) {
        mint prev = *this;
        value++;
        if (value == mod) value = 0;
        return prev;
    }

    mint operator--(int) {
        mint prev = *this;
        value--;
        if (value == -1) value = mod - 1;
        return prev;
    }

    mint operator-() const {
        return mint(0) - *this;
    }

    bool operator==(const mint &x) const {
        return value == x.value;
    }

    bool operator!=(const mint &x) const {
        return value != x.value;
    }

    bool operator<(const mint &x) const {
        return value < x.value;
    }

    template<typename T>
    explicit operator T() {
        return value;
    }

    friend std::istream &operator>>(std::istream &in, mint &x) {
        std::string s;
        in >> s;
        x = 0;
        for (const auto c: s)
            x = x * 10 + (c - '0');

        return in;
    }

    friend std::ostream &operator<<(std::ostream &out, const mint &x) {
        return out << x.value;
    }

    static int primitive_root() {
        if constexpr (mod == 1'000'000'007) return 5;
        if constexpr (mod == 998'244'353) return 3;
        if constexpr (mod == 786433) return 10;

        static int root = -1;
        if (root != -1)
            return root;

        std::vector<int> primes;
        int value = mod - 1;
        for (int i = 2; i * i <= value; i++)
            if (value % i == 0) {
                primes.push_back(i);
                while (value % i == 0)
                    value /= i;
            }

        if (value != 1) primes.push_back(value);
        for (int r = 2;; r++) {
            bool ok = true;
            for (auto p: primes) {
                if ((mint(r).power((mod - 1) / p)).value == 1) {
                    ok = false;
                    break;
                }
            }
            if (ok) return root = r;
        }
    }
};

constexpr int MOD = 1'000'000'007;
// constexpr int MOD = 998'244'353;
using mint = static_modular_int<MOD>;


const int INFi = 2e9;
const ll INF = 2e18;
const int LG = 31;
const int N = 1e4;

int n;
vi t;

int jump[N][2];
int tmp[N];

int pos;
const int SZ = 76;

struct State {
    ar<int, SZ> dp;

    int MakeGood() {
        if (pos != -1) {
            ckmin(dp[jump[pos][0] - 1], 1);
            ckmin(dp[jump[pos][1] - 1], 3);
        }
//        dp[1] = min(dp[1], 1);
        for(int i = 0; i + 1 < SZ; ++i) dp[i + 1] = min(dp[i + 1], dp[i] + 1);
        for (int i = SZ - 1; i >= 1; --i) dp[i - 1] = min(dp[i - 1], dp[i]);

        int x = dp[0];
        for (int i = 1; i < SZ; ++i) dp[i - 1] = dp[i] - x;
        dp[SZ - 1] = INFi;
        return x;
    }
};

bool operator<(const State &a, const State &b) {
    return a.dp < b.dp;
}

bool operator==(const State &a, const State &b) {
    return a.dp == b.dp;
}

const int M = 1e7;
pair<mint, mint> dp[2][M];
int t_upd[M];

void solve() {
    cin >> n;
//    n = 1000;
    t.resize(n);
    rep(i, n) cin >> t[i]; //t[i] = rand() % (2 * n); //cin >> t[i]; //t[i] = i; //cin >> t[i]; //t[i] = i; //cin >> t[i]; //t[i] = i;
//    sort(all(t));
//    t.resize(unique(all(t)) - t.begin());

    n = t.size();


    jump[n][0] = jump[n][1] = n;
    for (int i = n - 1; i >= 0; --i) {
        rep(j, 2) jump[i][j] = jump[i + 1][j];
        while (t[jump[i][0] - 1] >= t[i] + 20) jump[i][0]--;
        while (t[jump[i][1] - 1] >= t[i] + 75) jump[i][1]--;
    }
    for (int i = n; i >= 0; --i) {
        rep(j, 2) jump[i][j] -= i;
    }
    int sz = 0;
    vector<map<pair<int, int>, ar<pair<int, int>, 2>>> g;
    map<State, int> index;
    vector<State> states;

    auto Add = [&](State s) {
        int value = s.MakeGood();
        int i = -1;
        if (index.contains(s)) {
            i = index[s];
        } else {
            states.push_back(s);
            i = index.size();
            index[s] = i;
            sz++;
            assert(sz < M);
            g.emplace_back();
        }
        return make_pair(i, value);
    };
    pos = 0;
    vi nxt;
    {
        State s;
        rep(i, SZ) s.dp[i] = INFi;
        s.dp[0] = 0;
        pos = -1;
        auto [v, _] = Add(s);
        dp[0][v].first++;
        nxt.push_back(v);
    }
    int tq = 0;
    int who = 0;
    for (int i = 0; i < n; ++i) {
        who ^= 1;
        pos = i;
        tq++;
        pair<int, int> cur = {jump[i][0], jump[i][1]};

        sort(all(nxt));
        nxt.resize(unique(all(nxt)) - nxt.begin());

        vi nxt2;
        nxt2.reserve(nxt.size());
        for(auto v : nxt) {
            auto val = dp[who^1][v];
            if (!val.first && !val.second) continue;
            if (!g[v].contains(cur)) {
                g[v][cur][0] = Add(states[v]);
                {
                    auto s2 = states[v];
                    ckmin(s2.dp[0], 0);
                    g[v][cur][1] = Add(s2);
                }
            }
            ar<pair<int, int>, 2> to = g[v][cur];

            rep(q, 2) {
                int j = to[q].first;
                int value = to[q].second;

                if (t_upd[j] < tq) {
                    t_upd[j] = tq;
                    dp[who][j] = {0, 0};
                }
                dp[who][j].first += val.first;
                dp[who][j].second += val.second + val.first * value;
                nxt2.push_back(j);
            }
        }
        swap(nxt, nxt2);
    }


    sort(all(nxt));
    nxt.resize(unique(all(nxt)) - nxt.begin());

    mint ans = 0;
    for(auto &i : nxt) ans += dp[who][i].second;
    cout << ans * 2 << '\n';
}

signed main() {
    ios_base::sync_with_stdio(false);
    cin.tie(0);
    cout << setprecision(12) << fixed;
    int t = 1;
//    cin >> t;
    rep(i, t) {
        solve();
    }
    return 0;
}