import Control.Applicative
import Control.Monad
import Control.Monad.ST
import Data.ByteString.Char8 (ByteString)
import qualified Data.ByteString.Char8 as B
import Data.List
import Data.Char (isSpace)
import Data.Vector.Unboxed.Mutable (IOVector, STVector)
import qualified Data.Vector.Unboxed.Mutable as VM
import Data.IntSet (IntSet)
import qualified Data.IntSet as IS

main :: IO ()
main = do
  [n, m] <- f
  solve n <$> (IS.fromList <$> replicateM m g) >>= print
  where
    f = readil B.readInt <$> B.getLine
    g = readi B.readInt <$> B.getLine

solve :: Int -> IntSet -> Int
solve n st = runST $ do
  sv <- VM.replicate (n + 1) 0 :: ST s (STVector s Int)
  VM.write sv 0 1
  if IS.member 1 st
    then VM.write sv 1 0
    else VM.write sv 1 1
  forM_ [2 .. n] $ \i -> do
    if IS.member i st
      then VM.write sv i 0
      else do
        x2 <- VM.read sv (i - 2)
        x1 <- VM.read sv (i - 1)
        VM.write sv i ((x1 + x2) `mod` md)
  VM.read sv n
  where
    md = 1000000007

readi :: Integral a =>  (ByteString -> Maybe (a, ByteString)) -> ByteString -> a
readi f s = let Just (n, _) = f s in n

readil :: Integral a =>  (ByteString -> Maybe (a, ByteString)) -> ByteString -> [a]
readil f = unfoldr $ \s -> do
  (n, s') <- f s
  return (n, B.dropWhile isSpace s')
