Problem:
D： 素因数分解の多様性 (The Diversity of Prime Factorization)

Problem

Ebi-chan has the FACTORIZATION MACHINE, which can factorize natural numbers M (greater than 1) in O($\log$ M) time! But unfortunately, the machine could display only digits and whitespaces.

In general, we consider the factorization of M as p_1^{e_1} \times p_2^{e_2} \times ... \times p_K^{e_K} where (1) i < j implies p_i < p_j and (2) p_i is prime. Now, she gives M to the machine, and the machine displays according to the following rules in ascending order with respect to i:

If e_i = 1, then displays p_i,

otherwise, displays p_i e_i.

For example, if she gives either 22 or 2048, then 2 11 is displayed. If either 24 or 54, then 2 3 3.

Okay, Ebi-chan has written down the output of the machine, but she notices that she has forgotten to write down the input! Now, your task is to count how many natural numbers result in a noted output. Note that Ebi-chan has mistaken writing and no input could result in the output.

The answer could be too large, so, you must output it modulo 10^9+7 (prime number).

Input

N
q_1 q_2 $\cdots$ q_N

In the first line, the number of the output of the machine is given. In the second line, the output of the machine is given.

Constraints

1 \leq N \leq 10^5

2 \leq q_i \leq 10^6 (1 \leq i \leq N)

Output

Print the number of the natural numbers that result in the given output of the machine.

Sample Input 1

3
2 3 3

Sample Output for Input 1

2

24 = 2^3 \times 3 and 54 = 2 \times 3^3 satisfy the condition.

Sample Input 2

3
2 3 4

Sample Output 2 for Input 2

1

Only 162 = 2 \times 3^4 satisfies the condition. Note that 4 is not prime.

Sample Input 3

3
3 5 2

Sample Output for Input 3

1

Since 2 < 3 < 5, only 75 = 3 \times 5^2 satisfies the condition.

Sample Input 4

1
4

Sample Output for Input 4

0

Ebi-chan should have written down it more carefully.

Solution in Rust (judge verdict: Accepted)

use std::io::*;
use std::str::FromStr;

pub fn read<T: FromStr>() -> T {
    let stdin = stdin();
    let stdin = stdin.lock();
    let token: String = stdin
        .bytes()
        .map(|c| c.expect("failed to read char") as char) 
        .skip_while(|c| c.is_whitespace())
        .take_while(|c| !c.is_whitespace())
        .collect();
    token.parse().ok().expect("failed to parse token")
}

const MOD: u64 = 1_000_000_007;

fn rec(k: usize, p: usize, prev: u32, q: &Vec<u32>, dp: &mut Vec<Vec<Option<u64>>>, is_prime: &Vec<bool>) -> u64 {
    if let Some(res) = dp[k][p] {
        return res;
    }

    let res = if k == q.len() {
        1
    } else {
        if is_prime[q[k] as usize] && prev < q[k] {
            let mut res = 0;
            res += rec(k + 1, 0, q[k], q, dp, is_prime);
            if k + 2 <= q.len() {
                res += rec(k + 2, 1, q[k], q, dp, is_prime);
            }
            res % MOD
        } else {
            0
        }
    };

    // println!("{} {} {} -> {}", k, p, prev, res);
    dp[k][p] = Some(res);
    res
}

fn main() {
    let n = read();
    let q: Vec<u32> = (0..n).map(|_| read()).collect();
    let max = *q.iter().max().unwrap() as usize;
    let mut is_prime = vec![true; max + 1];
    is_prime[0] = false;
    is_prime[1] = false;
    for i in 2..max {
        if i as u64 * i as u64 > max as u64 {
            break;
        }
        if !is_prime[i] {
            continue;
        }
        let mut j = i * i;
        while j <= max {
            is_prime[j] = false;
            j += i;
        }
    }

    let mut dp = vec![vec![None; 2]; n + 1];
    println!("{}", rec(0, 0, 0, &q, &mut dp, &is_prime));
}