import Data.List (foldl', scanl)
import Data.Int (Int)

md :: Int
md = 10^9 + 7

modadd :: Int -> Int -> Int
modadd a b = (a + b) `mod` md 

modmul :: Int -> Int -> Int
modmul a b = a * b `mod` md

modpow :: Int -> Int -> Int
modpow a b
  | b == 0 = 1
  | odd b = a * modpow a (b - 1) `mod` md
  | otherwise = modpow (a * a `mod` md) (b `div` 2)

modinv :: Int -> Int
modinv a = modpow a (md - 2)

--     (x-1)(x-2)...(x-n+1)
-- ------------------------ a[0] + ...
--     (0-1)(0-2)...(0-n+1)

lagrange :: [Int] -> Int -> Int
lagrange a x
  | x < n = a !! x
  | otherwise = let (sm, _, _, _) = foldl' f (0, 0, 1, q) a
                in sm
  where
    n = length a
    p = foldl' modmul 1 [(x - i) | i <- [0..n-1]]
    q = foldl' modmul 1 [-i | i <- [1..n-1]]
    f :: (Int, Int, Int, Int) -> Int -> (Int, Int, Int, Int)
    f (sm, k, l, r) ak = (nextSm, k + 1, nextL, nextR)
      where 
        nextSm = modadd sm $ ak `modmul` p `modmul` modinv (l `modmul` r `modmul` (x - k))
        nextL = l `modmul` (k + 1)
        nextR = r `modmul` negate (modinv (n - 1 - k))

computeSmall :: Int -> [Int]
computeSmall k = scanl f 0 [1..k + 2]
  where
    f s x = s `modadd` (modpow x k)

solve :: Int -> Int -> Int
solve n k = lagrange (computeSmall k) (n `mod` md)

main = do
  [n, k] <- map read . words <$> getLine :: IO [Int]
  print $ solve n k