#include <iostream>
#include <algorithm>
#include <cstdint>
#include <cmath>
#include <vector>
#include <map>
#include <set>
#include <bitset>
#include <string>

using namespace std;

class modint_t {
public:
    modint_t() = default;
    modint_t(int64_t value):value(value % MOD){}

    bool operator<(const modint_t rhs) const { return value < rhs.value; }
    bool operator<=(const modint_t rhs) const { return value <= rhs.value; }
    bool operator>(const modint_t rhs) const { return value > rhs.value; }
    bool operator>=(const modint_t rhs) const { return value >= rhs.value; }

    modint_t operator+(const modint_t rhs) const { return modint_t(value + rhs.value); }
    modint_t operator+=(const modint_t rhs) { return value = (value + rhs.value) % MOD; }
    modint_t operator-(const modint_t rhs) const { return modint_t(MOD + value - rhs.value); }
    modint_t operator-=(const modint_t rhs) { return value = (MOD + value - rhs.value) % MOD; }

    modint_t operator*(const modint_t rhs) const { return modint_t(value * rhs.value); }
    modint_t operator*=(const modint_t rhs) { return value = value * rhs.value % MOD; }
    modint_t operator/(const modint_t rhs) const { return *this * rhs.invert(); }
    modint_t operator/=(const modint_t rhs) { return *this *= rhs.invert(); }

    modint_t square() const { return *this * *this; }
    modint_t power(int64_t y) const
    {
        if(y == 0) return 1;
        else if(y == 1) return *this;
        else if(y % 2 == 0) return this->power(y/2).square();
        else return *this * this->power(y-1);
    }

    modint_t invert() const
    {
        return power(MOD-2);
    }

    operator int64_t() const
    {
        return value;
    }
private:
    static const int MOD = 1000000007;
    int64_t value = 0;
};

modint_t factorial(int64_t n)
{
    if(n <= 1) return 1;
    modint_t f = 1;
    for(int64_t i = 1; i <= n; ++i)
    {
        f *= i;
    }
    return f;
}

modint_t permutation(int64_t n, int64_t r)
{
    modint_t p = 1;
    for(int64_t i = n; i > n-r; --i)
    {
        p *= i;
    }
    return p;
}

modint_t combination(int64_t n, int64_t r)
{
    if(r * 2 > n) r = n - r;
    modint_t x = 1;
    modint_t y = 1;
    for(int64_t i = 1; i <= r; ++i)
    {
        x *= n - i + 1;
        y *= i;
    }
    return x / y;
}

modint_t multichoose(int64_t n, int64_t k)
{
    return combination(n + k - 1, k);
}

modint_t fibo(int n)
{
    if(n <= 1) return 1;
    if(n <= 2) return 2;
    modint_t f1 = 1;
    modint_t f2 = 2;
    for(int i = 2; i < n; ++i)
    {
        modint_t f3 = f1 + f2;
        f1 = f2;
        f2 = f3;
    }
    return f2;
}

int main()
{
    int n, m;
    cin >> n >> m;
    if(m == 0)
    {
        cout << fibo(n) << '\n';
        return 0;
    }

    vector<int> as(m);
    for(auto& a : as) cin >> a;
    
    for(int i = 1; i < m; ++i)
    {
        if(as[i-1]+1 == as[i])
        {
            cout << "0\n";
            return 0;
        }
    }
    
    modint_t ans = 1;
    as.insert(as.begin(), -1);
    as.push_back(n+1);
    for(int i = 1; i < (int)as.size(); ++i)
    {
        //cout << as[i-1]+1 << "->" << as[i]-1 << '\n';
        ans *= fibo(as[i] - as[i-1] - 2);
    }
    
    cout << ans << '\n';
    return 0;
}


Measured memory_bytes: 640