{-# LANGUAGE BangPatterns #-}



import qualified Data.Vector.Unboxed as U
import qualified Data.Vector as V
import qualified Data.ByteString.Char8 as C
import Debug.Trace
import Data.List
import Control.Monad
import Control.Arrow
import Data.Ord
import Data.Maybe
import Numeric
import Data.Char
import Text.Printf
import qualified Data.IntMap.Strict as IM

r :: Int -> IO (U.Vector Int)
r n = U.unfoldrN n (C.readInt . C.dropWhile (==' ')) <$> C.getLine


r' :: IO [Int]
r'  =   unfoldr    (C.readInt . C.dropWhile (==' ')) <$> C.getLine


main :: IO ()
main = do
    [n,k] <- r'
    let preW = prep k
    print $ solve preW n k

solve preW n k = sum $ map (solve2 preW (n-1) k) [1..k]

solve2 preW 0 k cur = cur
solve2 preW n k cur = sum $ map (\(factor,occ) -> occ *% (solve2 preW (n-1) k factor)) (preW V.! (cur-1))






widths :: Int -> Int -> [(Int, Int)]
widths k cur = IM.toList $ IM.fromListWith (+%) $ zip (map (gcd cur) [1..k]) (repeat 1)

prep k = V.fromList $ map (widths k) [1..k]

fact n = filter ((==0).(n`rem`)) [1..n]

-- pfac = fAux primes where
--     fAux q@(p:ps) 1 = []
--     fAux q@(p:ps) n = if n`rem`p==0 then p:(fAux q (n`quot`p)) else fAux ps n

-- primes = f [2..] where f (p:ps) = p:(filter ((/=0).(`rem`p)) ps)





mdl = 1000000007

(^%) :: Int -> Int -> Int
b ^% e = powAux (b `rem` mdl) e 1 `mod` mdl
    where 
        powAux _ 0 !ac = ac
        powAux b e !ac = powAux (b*b `rem` mdl) (e `quot` 2)
            (if odd e then b*ac `rem` mdl else ac)

(+%), (-%), (*%), (/%) :: Int -> Int -> Int
a +% b = (a + b) `rem` mdl
a -% b = (a - b) `mod` mdl
a *% b = (a * b) `rem` mdl
a /% b = (a * invMod b) `mod` mdl
    where   invMod :: Int -> Int
            invMod = (^% (mdl-2))
