#![allow(non_snake_case, unused_must_use, unused_imports)]
use std::io::{self, prelude::*};

fn main() {
    let (stdin, stdout) = (io::read_to_string(io::stdin()).unwrap(), io::stdout());
    let (mut stdin, mut buffer) = (stdin.split_whitespace(), io::BufWriter::new(stdout.lock()));

    macro_rules! input {
        ($t: tt, $n: expr) => {
            (0..$n).map(|_| input!($t)).collect::<Vec<_>>()
        };
        (Chars) => {
            input!(String).chars().collect::<Vec<_>>()
        };
        (Usize1) => {
            stdin.next().unwrap().parse::<usize>().unwrap() - 1
        };
        ($t: ty) => {
            stdin.next().unwrap().parse::<$t>().unwrap()
        };
    }

    let N = input!(usize);

    let mut ans = 0;
    const IS_PRIME: [bool; 100001] = is_prime();

    for p in 2.. {
        if p * p > N {
            break;
        }

        if IS_PRIME[p] {
            let mut q = p * p;

            while q <= N {
                ans += q;
                q *= p;
            }
        }
    }

    writeln!(buffer, "{}", ans);
}

const fn is_prime() -> [bool; 100_001] {
    let mut a = [true; 100_001];

    a[0] = false;
    a[1] = false;

    let mut p = 1;

    loop {
        p += 1;

        if p == 100_001 {
            break;
        }

        if !a[p] {
            continue;
        }

        let mut q = p;

        loop {
            q += p;
            if q >= 100_001 {
                break;
            }

            a[q] = false;
        }
    }

    a
}