#include <bits/stdc++.h>

using namespace std;

constexpr int N = 3e5 + 1, exps[]{2, 2, 2, 2, 2, 3, 3, 3, 5, 5, 7, 7};
using E = array<uint64_t, size(exps)>;
constexpr uint64_t mod = -49ull / 2;

uint64_t splitmix(uint64_t x) {
  x *= 0x94d049bb133111eb;
  return x ^ x >> 31;
}

template <typename V>
struct umap {
  struct KNV { uint64_t k; uint32_t n; V v; };
  vector<KNV> knv;
  vector<uint32_t> head;
  int cap{};

  umap() { reserve(); }

  int find(uint64_t k) { for (int i = head[splitmix(k) & cap]; ~i; i = knv[i].n) if (knv[i].k == k) return i; return -1; }

  int insert(uint64_t k) {
    reserve();
    auto& h = head[splitmix(k) & cap];
    for (int i = h; ~i; i = knv[i].n) if (knv[i].k == k) return i;
    knv.push_back({k, h});
    return h = knv.size() - 1;
  }

  void reserve() {
    if (knv.size() * 2 < cap) return;
    cap = max(cap * 2 + 1, 3);
    head.assign(cap + 1, -1);
    for (int i = 0; i < knv.size(); ++i) {
      auto& h = head[splitmix(knv[i].k) & cap];
      knv[i].n = h;
      h = i;
    }
  }
};

template <int i>
struct um: conditional_t<i == size(exps), vector<int>, umap<um<i + 1>>> { };

um<0> m;

vector<int> ls[N];

template <int i = 0>
auto& mget(const E& e, auto& m) {
  if constexpr (i == size(exps)) return m;
  else return mget<i + 1>(e, m.knv[m.insert(e[i])].v);
}

template <int i = 0, int prv_ = 1>
void walk(const E& e, auto& m, uint64_t k, uint64_t pr, int pw, auto f) {
  if constexpr (i == size(exps)) f(m, k, pr);
  else {
    constexpr int prv = i && exps[i] != exps[i - 1]? 1: prv_, nx = prv * exps[i];
    if (prv == 1) pw = 0;
    uint64_t step = pr;
    while (step % nx != prv) step += pr;
    while (k % nx >= prv) k += pr;
    pr *= exps[i];
    k %= pr;
    if (m.knv.size() != 1)
    for (int j = 0; j < exps[i]; ++j) {
      auto it = m.find((e[i] + (1ull << pw + j * prv)) % ((1ull << nx) - 1));
      if (~it) walk<i + 1, nx>(e, m.knv[it].v, k, pr, pw + j * prv, f);
      k = (k + step) % pr;
    }
    else if (auto& [ke, _, v] = m.knv[0]; 1)
    for (int j = 0; j < exps[i]; ++j) {
      if ((e[i] + (1ull << pw + j * prv)) % ((1ull << nx) - 1) == ke) walk<i + 1, nx>(e, v, k, pr, pw + j * prv, f);
      k = (k + step) % pr;
    }
  }
}

int dp[N];

uint64_t pw[(int)1.1e6];
uint64_t pss[N];

int main() {
  cin.tie(0)->sync_with_stdio(0);
  pw[0] = 1;
  for (uint64_t i = 1, p = 2; i < size(pw); ++i) pw[i] = p, p = (p + p) % mod;
  int n; cin >> n;
  E ps{};
  uint64_t psm{};
  for (int i = 0; ; ++i) {
    mget(ps, m).push_back(i);
    walk(ps, m, 0, 1, 0, [&](auto& v, auto k, auto p) { for (auto& j: v) if (pss[j] == (psm + pw[k]) % mod) ls[i].push_back(j); });
    pss[i] = psm;
    if (i == n) break;
    int v; cin >> v;
    for (int j = 0, cm = 1; j < size(exps); ++j) {
      if (j && exps[j] != exps[j - 1]) cm = 1;
      cm *= exps[j];
      ps[j] = (ps[j] + (1ull << cm) - 1 - (1ull << v % cm)) % ((1ull << cm) - 1);
    }
    psm = (psm + mod - pw[v]) % mod;
  }
  dp[0] = 1;
  for (int i = 1; i <= n; ++i)
  for (auto j: ls[i]) dp[i] = (dp[i] + dp[j]) % ((int)1e9 + 7);
  cout << dp[n];
}