#include <iostream>
#include <sstream>
#include <stack>
#include <iomanip>
#include <numeric>
#include <string>
#include <cstring>
#include <algorithm>
#include <functional>
#include <cstdlib>
#include <cassert>
#include <map>
#include <set>
#include <vector>
#include <utility>
#include <queue>
#include <cmath>

#define BEGIN(x) x.begin()
#define END(x) x.end()
#define ALL(x) BEGIN(x), END(x)
#define PAIR make_pair
#define VEC(type) vector<type >
#define endl '\n'
#define FIR first
#define SEC second
#define PB push_back
#define SZ(x) ((int)x.size())

#define FOR(i, A, B) for(auto i = (A);i != (B); i++)
#define FORD(i, A, B) for(auto i = (A);i != (B); i--)

#define READRANGE(begin, end) FOR(it, begin, end) cin >> *it
#define READVEC(V) READRANGE(BEGIN(V), END(V))

using namespace std;

typedef long long lint;
typedef pair<int, int> Pii;
typedef pair<int, lint> Pil;
typedef pair<lint, lint> Pll;
typedef pair<lint, int> Pli;

template<class U, class V>
istream& operator >>(istream& in, pair<U, V>& pr) {
    return in >> pr.first >> pr.second;
}

template<class U, class V>
ostream& operator <<(ostream& out, pair<U, V>& p) {
    return out << p.first << " " << p.second;
}

template<class T>
ostream& operator <<(ostream& out, vector<T> vec) {
    for (T& e : vec)
        out << e << " ";
    return out << endl;
}

// ---- BEGIN LIBRARY CODE ----
class Primes
{
public:
    Primes()
    {
        _factors = vector<int>(1, 1);
    }

    /**
     * Returns a vector of all primes <= m for some m >= n.
     */
    vector<int> getPrimes(int n)
    {
        computeInternal(n);
        vector<int> primes;
        for (int p = 2;p <= n; p++)
            if (_factors[p] == p)
                primes.push_back(p);
        return primes;
    }

    /**
     * Returns a vector consisting of single prime for each integer <= m
     * for some m >= n. Using this array, any integer in this range can be
     * completely factorized.
     */
    const vector<int> factorizeRange(int n)
    {
        computeInternal(n);
        return _factors;
    }

    vector<pair<int, int> > completeFactorize(int n)
    {
        computeInternal(n);
        vector<pair<int, int> > ret;
        while (n > 1) {
            int e = 0, f = _factors[n];
            while (n % f == 0) {
                e++;
                n /= f;
            }
            ret.push_back(make_pair(f, e));
        }

        return ret;
    };

    template<class T>
    static T gcd(T x, T y)
    {
        while (x != 0) {
            T r = y % x;
            y = x;
            x = r;
        }

        return y;
    }

    template<class T>
    static pair<T, T> eeGcd(T x, T y)
    {
        T ax = 1, bx = 0;
        T ay = 0, by = 1;

        while (x != 0) {
            T div = y / x;
            T ar = ay - div * ax;
            T br = by - div * bx;
            T r = y - div * x;

            y = x; ay = ax; by = bx;
            x = r; ax = ar; bx = br;
        }

        return make_pair(ay, by);
    }

private:
    void computeInternal(int n)
    {
        if (_factors.size() > n)
            return;
        _factors.resize(n + 1);
        n = _factors.size() - 1;

        for (int p = 1;p <= n; p++)
            _factors[p] = p;

        for (int p = 2;p <= n; p++)
            if (_factors[p] == p)
                for (int q = 2 * p;q <= n;q += p)
                    _factors[q] = p;

        return;
    }

    vector<int> _factors;
};
// ---- END LIBRARY CODE ----
void io_init()
{
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
};

void solveSingleCase(int caseNo)
{
    lint N;
    cin >> N;

    Primes primes;
    VEC(int) facs = primes.factorizeRange(1000000);

    int ret = 0;
    lint M = N;
    for (lint d = 2;d <= N / d; d++)
        if (facs[d] == d && N % d == 0) {
            int e = 0;
            while(M % d == 0) {
                e++;
                M /= d;
            }

            int t = 0;
            while (t * (t + 1) / 2 <= e)
                t++;
            ret += --t;
        }

    if (M > 1)
        ret++;

    cout << ret << endl;
};

int main(int argc, char **argv)
{
    io_init();

    // Actual program code starts here.
    int T = 1;
    // cin >> T;
    FOR(tcase, 1, T + 1) {
        solveSingleCase(tcase);
    }
    return 0;
};


Measured memory_bytes: 11120