# Kの数列、N以下
N, K = gets.split.map{ |x| x.to_i }

#系列の数と(N / 末尾の数)ごとにMapを作成
len_x_count = []

def get_sum(map, max)
    result = 0

    (1 ... $keys.size).each{ |i|
        if $keys[i-1] <= max && $keys[i] >= max then
	        result += map[$keys[i - 1]] + (max - $keys[i - 1]) * map[$keys[i]]
            break
        else
            result += map[$keys[i - 1]] + map[$keys[i]] * ($keys[i] - $keys[i-1] - 1)
        end
    }

    result
end


p = Math.sqrt(N).floor

pairs = []
(1..p).each{ |x|
    pairs << [x, N/x]
}

$keys = pairs.flatten.sort.uniq

(1..K).each{ |len|
	puts 's'
    len_x_count[len] = {}

    pairs.each{ |x, y|
        if len == 1 then
            len_x_count[len][x] = 1
            len_x_count[len][y] = 1
        else
            len_x_count[len][x] = get_sum(len_x_count[len - 1], y)
            if x != y then
                len_x_count[len][y] = get_sum(len_x_count[len - 1], x)
            end
        end
    }
}

# 回答出力
old = 0
result = 0
(1..N).to_a.reverse.each{ |i|
    if len_x_count[K][i] then
        result += len_x_count[K][i]
        old = len_x_count[K][i]
    else
        result += old
    end
}

puts result
