open System

// Util start
// return! を使った再帰ではなく mutable を使っているのは return! で生成されるステートマシンのコストが（数を出して1増やすだけの処理より）普通に高いため
let initInfinite64 f =
    seq {
        let mutable i = 0L
        while true do
            yield f i
            i <- i + 1L
    }

let (|SeqEmpty|SeqCons|) (xs: 'a seq) =
    if Seq.isEmpty xs then SeqEmpty else SeqCons(Seq.head xs, Seq.skip 1 xs)

let rec group xs: seq<seq<'a>> =
    match xs with
    | SeqEmpty -> Seq.empty
    | SeqCons (x, xs) ->
        let ys: 'a seq = Seq.takeWhile ((=) x) xs
        let zs: 'a seq = Seq.skipWhile ((=) x) xs
        Seq.append (seq { Seq.append (seq { x }) ys }) (group zs)
// Util end

let rec go n pps =
    match pps with
    | SeqEmpty -> seq [ n ]
    | SeqCons (p: int64, ps) ->
        let (q, r) = Math.DivRem(n, p)
        if n < p * p then seq [ n ]
        else if r > 0L then go n ps
        else Seq.append (seq { p }) (go q pps)

let primeFactors n =
    if n < 2L then
        Seq.empty
    else
        // 2 以上の自然数
        let int2s: int64 seq = initInfinite64 ((+) 2L)
        go n int2s

primeFactors 9000007L |> Seq.toList
//primeFactors 10000007L |> Seq.toList

// let isPrime n = [ n ] = primeFactors n

let calc n =
    initInfinite64 (fun i -> (i + 1L) * (i + 2L) / 2L)
    |> Seq.takeWhile (fun x -> x <= n)
    |> Seq.length

let solve n =
    if n = 1L then
        0
    else
        primeFactors n
        |> group
        |> Seq.sumBy (Seq.length >> int64 >> calc)

let isDev = false

let fd =
    if isDev then
        solve 24L |> printfn "%d"
        solve 1L |> printfn "%d"
        solve 64L |> printfn "%d"
        //solve 1000000007L |> printfn "%d"
    else
        let n = stdin.ReadLine() |> int64
        solve n |> printfn "%d"

fd