import java.util.Arrays;
import java.util.Scanner;

public class Main {

    private static final int MOD = 1_000_000_007;

    private static int N;
    private static int M;
    private static boolean[] a;

    private static int[] dp;

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        N = sc.nextInt() + 1;
        M = sc.nextInt();

        a = new boolean[N];
        Arrays.fill(a, true);

        for (int i = 0; i < M; i++) {
            a[sc.nextInt()] = false;
        }

        dp = new int[N];
        dp[0] = 1;

        for (int i = 0; i < N; i++) {
            if (!a[i]) continue;

            if (i + 1 < N) {
                dp[i + 1] = (dp[i + 1] + dp[i]) % MOD;
            }
            if (i + 2 < N) {
                dp[i + 2] = (dp[i + 2] + dp[i]) % MOD;
            }
        }

        System.out.println(dp[N - 1]);
    }

} import java.util.Arrays; Arrays java.util import java.util.Scanner; Scanner java.util public class Main {

    private static final int MOD = 1_000_000_007;

    private static int N;
    private static int M;
    private static boolean[] a;

    private static int[] dp;

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        N = sc.nextInt() + 1;
        M = sc.nextInt();

        a = new boolean[N];
        Arrays.fill(a, true);

        for (int i = 0; i < M; i++) {
            a[sc.nextInt()] = false;
        }

        dp = new int[N];
        dp[0] = 1;

        for (int i = 0; i < N; i++) {
            if (!a[i]) continue;

            if (i + 1 < N) {
                dp[i + 1] = (dp[i + 1] + dp[i]) % MOD;
            }
            if (i + 2 < N) {
                dp[i + 2] = (dp[i + 2] + dp[i]) % MOD;
            }
        }

        System.out.println(dp[N - 1]);
    }

} Main private static final int MOD = 1_000_000_007; MOD 1_000_000_007 private static int N; N private static int M; M private static boolean[] a; a private static int[] dp; dp public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        N = sc.nextInt() + 1;
        M = sc.nextInt();

        a = new boolean[N];
        Arrays.fill(a, true);

        for (int i = 0; i < M; i++) {
            a[sc.nextInt()] = false;
        }

        dp = new int[N];
        dp[0] = 1;

        for (int i = 0; i < N; i++) {
            if (!a[i]) continue;

            if (i + 1 < N) {
                dp[i + 1] = (dp[i + 1] + dp[i]) % MOD;
            }
            if (i + 2 < N) {
                dp[i + 2] = (dp[i + 2] + dp[i]) % MOD;
            }
        }

        System.out.println(dp[N - 1]);
    } main {
        Scanner sc = new Scanner(System.in);

        N = sc.nextInt() + 1;
        M = sc.nextInt();

        a = new boolean[N];
        Arrays.fill(a, true);

        for (int i = 0; i < M; i++) {
            a[sc.nextInt()] = false;
        }

        dp = new int[N];
        dp[0] = 1;

        for (int i = 0; i < N; i++) {
            if (!a[i]) continue;

            if (i + 1 < N) {
                dp[i + 1] = (dp[i + 1] + dp[i]) % MOD;
            }
            if (i + 2 < N) {
                dp[i + 2] = (dp[i + 2] + dp[i]) % MOD;
            }
        }

        System.out.println(dp[N - 1]);
    } Scanner sc = new Scanner(System.in); sc new Scanner(System.in) N = sc.nextInt() + 1 N sc.nextInt() + 1 sc.nextInt() sc.nextInt sc 1 M = sc.nextInt() M sc.nextInt() sc.nextInt sc a = new boolean[N] a new boolean[N] N Arrays.fill(a, true) Arrays.fill Arrays a true for (int i = 0; i < M; i++) {
            a[sc.nextInt()] = false;
        } int i = 0; int i = 0; i 0 i < M i M i++ i++ i {
            a[sc.nextInt()] = false;
        } {
            a[sc.nextInt()] = false;
        } a[sc.nextInt()] = false a[sc.nextInt()] a sc.nextInt() sc.nextInt sc false dp = new int[N] dp new int[N] N dp[0] = 1 dp[0] dp 0 1 for (int i = 0; i < N; i++) {
            if (!a[i]) continue;

            if (i + 1 < N) {
                dp[i + 1] = (dp[i + 1] + dp[i]) % MOD;
            }
            if (i + 2 < N) {
                dp[i + 2] = (dp[i + 2] + dp[i]) % MOD;
            }
        } int i = 0; int i = 0; i 0 i < N i N i++ i++ i {
            if (!a[i]) continue;

            if (i + 1 < N) {
                dp[i + 1] = (dp[i + 1] + dp[i]) % MOD;
            }
            if (i + 2 < N) {
                dp[i + 2] = (dp[i + 2] + dp[i]) % MOD;
            }
        } {
            if (!a[i]) continue;

            if (i + 1 < N) {
                dp[i + 1] = (dp[i + 1] + dp[i]) % MOD;
            }
            if (i + 2 < N) {
                dp[i + 2] = (dp[i + 2] + dp[i]) % MOD;
            }
        } if (!a[i]) continue; !a[i] a[i] a i continue; if (i + 1 < N) {
                dp[i + 1] = (dp[i + 1] + dp[i]) % MOD;
            } i + 1 < N i + 1 i 1 N {
                dp[i + 1] = (dp[i + 1] + dp[i]) % MOD;
            } dp[i + 1] = (dp[i + 1] + dp[i]) % MOD dp[i + 1] dp i + 1 i 1 (dp[i + 1] + dp[i]) % MOD (dp[i + 1] + dp[i]) dp[i + 1] dp i + 1 i 1 dp[i] dp i MOD if (i + 2 < N) {
                dp[i + 2] = (dp[i + 2] + dp[i]) % MOD;
            } i + 2 < N i + 2 i 2 N {
                dp[i + 2] = (dp[i + 2] + dp[i]) % MOD;
            } dp[i + 2] = (dp[i + 2] + dp[i]) % MOD dp[i + 2] dp i + 2 i 2 (dp[i + 2] + dp[i]) % MOD (dp[i + 2] + dp[i]) dp[i + 2] dp i + 2 i 2 dp[i] dp i MOD System.out.println(dp[N - 1]) System.out.println System.out System System.out dp[N - 1] dp N - 1 N 1 String[] args args public class Main {

    private static final int MOD = 1_000_000_007;

    private static int N;
    private static int M;
    private static boolean[] a;

    private static int[] dp;

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        N = sc.nextInt() + 1;
        M = sc.nextInt();

        a = new boolean[N];
        Arrays.fill(a, true);

        for (int i = 0; i < M; i++) {
            a[sc.nextInt()] = false;
        }

        dp = new int[N];
        dp[0] = 1;

        for (int i = 0; i < N; i++) {
            if (!a[i]) continue;

            if (i + 1 < N) {
                dp[i + 1] = (dp[i + 1] + dp[i]) % MOD;
            }
            if (i + 2 < N) {
                dp[i + 2] = (dp[i + 2] + dp[i]) % MOD;
            }
        }

        System.out.println(dp[N - 1]);
    }

} public class Main {

    private static final int MOD = 1_000_000_007;

    private static int N;
    private static int M;
    private static boolean[] a;

    private static int[] dp;

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        N = sc.nextInt() + 1;
        M = sc.nextInt();

        a = new boolean[N];
        Arrays.fill(a, true);

        for (int i = 0; i < M; i++) {
            a[sc.nextInt()] = false;
        }

        dp = new int[N];
        dp[0] = 1;

        for (int i = 0; i < N; i++) {
            if (!a[i]) continue;

            if (i + 1 < N) {
                dp[i + 1] = (dp[i + 1] + dp[i]) % MOD;
            }
            if (i + 2 < N) {
                dp[i + 2] = (dp[i + 2] + dp[i]) % MOD;
            }
        }

        System.out.println(dp[N - 1]);
    }

} Main
import java.util.Arrays;
import java.util.Scanner;

public class Main {

    private static final int MOD = 1_000_000_007;

    private static int N;
    private static int M;
    private static boolean[] a;

    private static int[] dp;

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        N = sc.nextInt() + 1;
        M = sc.nextInt();

        a = new boolean[N];
        Arrays.fill(a, true);

        for (int i = 0; i < M; i++) {
            a[sc.nextInt()] = false;
        }

        dp = new int[N];
        dp[0] = 1;

        for (int i = 0; i < N; i++) {
            if (!a[i]) continue;

            if (i + 1 < N) {
                dp[i + 1] = (dp[i + 1] + dp[i]) % MOD;
            }
            if (i + 2 < N) {
                dp[i + 2] = (dp[i + 2] + dp[i]) % MOD;
            }
        }

        System.out.println(dp[N - 1]);
    }

}
