//#pragma GCC optimize("O3", "unroll-loops")
//#pragma GCC target("avx2", "bmi", "bmi2", "lzcnt", "popcnt")
 
#include <bits/stdc++.h>
#define ldb long double
//#define double ldb
#define db double
#define unomap unordered_map
#define unoset unordered_set
#define endl '\n'
#define str string
#define strstr stringstream
#define sz(a) (int)a.size()
//#define ll long long
typedef long long ll;
//#define int ll
#define pii pair <int, int>
#define pll pair <ll, ll>
#define Unique(a) a.resize(unique(all(a)) - a.begin())
#define ull unsigned ll
#define fir first
#define sec second
#define idc cin.ignore()
#define lb lower_bound
#define ub upper_bound
#define all(s) s.begin(), s.end()
#define rev reverse
#define gcd __gcd
#define pushb push_back
#define popb pop_back
#define pushf push_front
#define popf pop_front
#define mul2x(a, x) a << x
#define div2x(a, x) a >> x
#define lcm(a, b) (a / __gcd(a, b) * b)
#define log_base(x, base) log(x) / log(base)
#define debug cerr << "No errors!"; exit(0);
#define forw(i, a, b) for (int i = a; i <= b; ++i)
#define forw2(i, a, b) for (ll i = a; i <= b; ++i)
#define fors(i, a, b) for (int i = a; i >= b; --i)
#define fors2(i, a, b) for (ll i = a; i >= b; --i)
#define pqueue priority_queue
#define sqrt sqrtl
#define i128 __int128
#define popcount __builtin_popcountll
#define BIT(x, i) (((x) >> (i)) & 1)
#define MASK(x) ((1LL) << (x))
#define want_digit(x) cout << fixed << setprecision(x);
#define excuting_time 1000.0 * clock() / CLOCKS_PER_SEC
#define mapa make_pair
using namespace std;
const int MOD = 1e9 + 7; // 998244353
const int inf = 1e9;
const ll INF = 1e18;
const int N = 2e5;
 
mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());
ll random(const ll &L, const ll &R) {
    return uniform_int_distribution<ll> (L, R) (rng);
}
 
namespace BigNum {
//    typedef long long ll;
    typedef long double ld;
    typedef complex<ld> pt;
    const int32_t MOD = 1e9 + 7;
    const ld PI = acos(-1.L);
 
    template<class T> struct cplx {
        T x, y;
        cplx() {
            x = 0.0;
            y = 0.0;
        }
        cplx(T nx, T ny = 0) {
            x = nx;
            y = ny;
        }
        cplx operator+(const cplx &c) const {
            return {x + c.x, y + c.y};
        }
        cplx operator-(const cplx &c) const {
            return {x - c.x, y - c.y};
        }
        cplx operator*(const cplx &c) const {
            return {x*c.x - y * c.y, x*c.y + y * c.x};
        }
        cplx& operator*=(const cplx &c) {
            return *this = {x*c.x - y * c.y, x*c.y + y * c.x};
        }
        inline T real() const {
            return x;
        }
        inline T imag() const {
            return y;
        }
        // Only supports right scalar multiplication like p*c
        template<class U> cplx operator*(const U &c) const {
            return {x * c, y * c};
        }
        template<class U> cplx operator/(const U &c) const {
            return {x / c, y / c};
        }
        template<class U> void operator/=(const U &c) {
            x /= c;
            y /= c;
        }
    };
    #define polar(r,a)  (cplx<ld>){r*cos(a),r*sin(a)}
 
    const int32_t DIG = 9, FDIG = 4;
    const int32_t BASE = 1e9, FBASE = 1e4;
    typedef cplx<ld> Cplx;
 
 
    // use mulmod when taking mod by int32_t v and v>2e9
    // you can use mod by bigint in that case too
    struct bigint {
        int32_t sgn;
        vector<int32_t> a;
        bigint() : sgn(1) {}
        bigint(ll v) {
            *this = v;
        }
        bigint& operator = (ll v) {
            sgn = 1;
            if (v < 0) sgn = -1, v = -v;
            a.clear();
            for (; v > 0; v /= BASE) a.push_back(v % BASE);
            return *this;
        }
        bigint(const bigint& other) {
            sgn = other.sgn;
            a = other.a;
        }
        friend void swap(bigint& a, bigint& b) {
            swap(a.sgn, b.sgn);
            swap(a.a, b.a);
        }
        bigint& operator = (bigint other) {
            swap(*this, other);
            return *this;
        }
        bigint(bigint&& other) : bigint() {
            swap(*this, other);
        }
        bigint(const string& s) {
            read(s);
        }
        void read(const string& s) {
            sgn = 1;
            a.clear();
            int32_t k = 0;
            for (; k < (int32_t) s.size() && (s[k] == '-' | s[k] == '+'); k++)
                if (s[k] == '-') sgn = -sgn;
            for (int32_t i = s.size() - 1; i >= k; i -= DIG) {
                int32_t x = 0;
                for (int32_t j = max(k, i - DIG + 1); j <= i; j++) x = x * 10 + s[j] - '0';
                a.push_back(x);
            }
            trim();
        }
        friend istream& operator>>(istream &in, bigint &v) {
            string s;
            in >> s;
            v.read(s);
            return in;
        }
        friend ostream& operator<<(ostream &out, const bigint &v) {
            if (v.sgn == -1 && !v.zero()) out << '-';
            out << (v.a.empty() ? 0 : v.a.back());
            for (int32_t i = (int32_t) v.a.size() - 2; i >= 0; --i)
                out << setw(DIG) << setfill('0') << v.a[i];
            return out;
        }
        bool operator<(const bigint &v) const {
            if (sgn != v.sgn) return sgn < v.sgn;
            if (a.size() != v.a.size()) return a.size() * sgn < v.a.size() * v.sgn;
            for (int32_t i = (int32_t)a.size() - 1; i >= 0; i--)
                if (a[i] != v.a[i]) return a[i] * sgn < v.a[i] * sgn;
            return 0;
        }
        bool operator>(const bigint &v) const {
            return v < *this;
        }
        bool operator<=(const bigint &v) const {
            return !(v < *this);
        }
        bool operator>=(const bigint &v) const {
            return !(*this < v);
        }
        bool operator==(const bigint &v) const {
            return !(*this < v) && !(v < *this);
        }
        bool operator!=(const bigint &v) const {
            return *this < v || v < *this;
        }
        friend int32_t __cmp(const bigint& x, const bigint& y) {
            if (x.a.size() != y.a.size()) return x.a.size() < y.a.size() ? -1 : 1;
            for (int32_t i = (int32_t) x.a.size() - 1; i >= 0; --i) if (x.a[i] != y.a[i])
                    return x.a[i] < y.a[i] ? -1 : 1;
            return 0;
        }
 
        bigint operator-() const {
            bigint res = *this;
            if (zero()) return res;
            res.sgn = -sgn;
            return res;
        }
 
        void __add(const bigint& v) {
            if (a.size() < v.a.size()) a.resize(v.a.size(), 0);
            for (int32_t i = 0, carry = 0; i < (int32_t) max(a.size(), v.a.size()) || carry; ++i) {
                if (i == (int32_t) a.size()) a.push_back(0);
                a[i] += carry + (i < (int32_t) v.a.size() ? v.a[i] : 0);
                carry = a[i] >= BASE;
                if (carry) a[i] -= BASE;
            }
        }
 
        void __sub(const bigint& v) {
            for (int32_t i = 0, carry = 0; i < (int32_t) v.a.size() || carry; ++i) {
                a[i] -= carry + (i < (int32_t) v.a.size() ? v.a[i] : 0);
                carry = a[i] < 0;
                if (carry) a[i] += BASE;
            }
            this->trim();
        }
 
        bigint operator+=(const bigint& v) {
            if (sgn == v.sgn) __add(v);
            else if (__cmp(*this, v) >= 0) __sub(v);
            else {
                bigint vv = v;
                swap(*this, vv);
                __sub(vv);
            }
            return *this;
        }
 
        bigint operator-=(const bigint& v) {
            if (sgn == v.sgn) {
                if (__cmp(*this, v) >= 0) __sub(v);
                else {
                    bigint vv = v;
                    swap(*this, vv);
                    __sub(vv);
                    sgn = -sgn;
                }
            } else __add(v);
            return *this;
        }
 
        template< typename L, typename R >
        typename enable_if <
        is_convertible<L, bigint>::value &&
        is_convertible<R, bigint>::value &&
        is_lvalue_reference < R&& >::value,
        bigint >::type friend operator + (L&& l, R&& r) {
            bigint result(forward<L>(l));
            result += r;
            return result;
        }
        template< typename L, typename R >
        typename enable_if <
        is_convertible<L, bigint>::value &&
        is_convertible<R, bigint>::value &&
        is_rvalue_reference < R&& >::value,
        bigint >::type friend operator + (L&& l, R&& r) {
            bigint result(move(r));
            result += l;
            return result;
        }
        template< typename L, typename R >
        typename enable_if <
        is_convertible<L, bigint>::value &&
        is_convertible<R, bigint>::value,
        bigint >::type friend operator - (L&& l, R&& r) {
            bigint result(forward<L>(l));
            result -= r;
            return result;
        }
 
        friend pair<bigint, bigint> divmod(const bigint& a1, const bigint& b1) {
            ll norm = BASE / (b1.a.back() + 1);
            bigint a = a1.abs() * norm, b = b1.abs() * norm, q = 0, r = 0;
            q.a.resize(a.a.size());
            for (int32_t i = a.a.size() - 1; i >= 0; i--) {
                r *= BASE;
                r += a.a[i];
                ll s1 = r.a.size() <= b.a.size() ? 0 : r.a[b.a.size()];
                ll s2 = r.a.size() <= b.a.size() - 1 ? 0 : r.a[b.a.size() - 1];
                ll d = ((ll) BASE * s1 + s2) / b.a.back();
                r -= b * d;
                while (r < 0) r += b, --d;
                q.a[i] = d;
            }
            q.sgn = a1.sgn * b1.sgn;
            r.sgn = a1.sgn;
            q.trim();
            r.trim();
            auto res = make_pair(q, r / norm);
            if (res.second < 0) res.second += b1;
            return res;
        }
        bigint operator/(const bigint &v) const {
            return divmod(*this, v).first;
        }
        bigint operator%(const bigint &v) const {
            return divmod(*this, v).second;
        }
        void operator/=(int32_t v) {
            if (llabs(v) >= BASE) {
                *this /= bigint(v);
                return;
            }
            if (v < 0) sgn = -sgn, v = -v;
            for (int32_t i = (int32_t) a.size() - 1, rem = 0; i >= 0; --i) {
                ll cur = a[i] + rem * (ll)BASE;
                a[i] = (int32_t) (cur / v);
                rem = (int32_t) (cur % v);
            }
            trim();
        }
        bigint operator/(int32_t v) const {
            if (llabs(v) >= BASE) return *this / bigint(v);
            bigint res = *this;
            res /= v;
            return res;
        }
        void operator/=(const bigint &v) {
            *this = *this / v;
        }
        ll operator%(ll v) const {
            int32_t m = 0;
            for (int32_t i = a.size() - 1; i >= 0; --i) m = (a[i] + m * (ll) BASE) % v;
            return m * sgn;
        }
        void operator*=(int32_t v) {
            if (llabs(v) >= BASE) {
                *this *= bigint(v);
                return;
            }
            if (v < 0) sgn = -sgn, v = -v;
            for (int32_t i = 0, carry = 0; i < (int32_t) a.size() || carry; ++i) {
                if (i == (int32_t) a.size()) a.push_back(0);
                ll cur = a[i] * (ll) v + carry;
                carry = (int32_t) (cur / BASE);
                a[i] = (int32_t) (cur % BASE);
            }
            trim();
        }
        bigint operator*(int32_t v) const {
            if (llabs(v) >= BASE) return *this * bigint(v);
            bigint res = *this;
            res *= v;
            return res;
        }
 
        static vector<int32_t> convert_base(const vector<int32_t> &a, int32_t old_digits, int32_t new_digits) {
            vector<ll> p(max(old_digits, new_digits) + 1);
            p[0] = 1;
            for (int32_t i = 1; i < (int32_t) p.size(); i++)
                p[i] = p[i - 1] * 10;
            vector<int32_t> res;
            ll cur = 0;
            int32_t cur_digits = 0;
            for (int32_t i = 0; i < (int32_t) a.size(); i++) {
                cur += a[i] * p[cur_digits];
                cur_digits += old_digits;
                while (cur_digits >= new_digits) {
                    res.push_back((ll)(cur % p[new_digits]));
                    cur /= p[new_digits];
                    cur_digits -= new_digits;
                }
            }
            res.push_back((int32_t) cur);
            while (!res.empty() && !res.back())
                res.pop_back();
            return res;
        }
 
        void fft(vector<Cplx>& a, bool invert) const {
            int32_t n = a.size();
            for (int32_t i = 1, j = 0; i < n; ++i) {
                int32_t bit = n / 2;
                for (; j >= bit; bit /= 2) j -= bit;
                j += bit;
                if (i < j) swap(a[i], a[j]);
            }
            for (int32_t len = 2; len <= n; len *= 2) {
                ld ang = 2 * PI / len * (invert ? -1 : 1);
                Cplx wlen = polar(1, ang);
                for (int32_t i = 0; i < n; i += len) {
                    Cplx w(1);
                    for (int32_t j = 0; j < len / 2; ++j) {
                        Cplx u = a[i + j], v = a[i + j + len / 2] * w;
                        a[i + j] = u + v;
                        a[i + j + len / 2] = u - v;
                        w *= wlen;
                    }
                }
            }
            if (invert) for (int32_t i = 0; i < n; ++i) a[i] /= n;
        }
        void multiply_fft(const vector<int32_t> &a, const vector<int32_t> &b, vector<int32_t> &res) const {
            vector<Cplx> fa(a.begin(), a.end()), fb(b.begin(), b.end());
            int32_t n = 1;
            while (n < (int32_t) max(a.size(), b.size())) n *= 2;
            n *= 2;
            fa.resize(n);
            fb.resize(n);
            fft(fa, 0);
            fft(fb, 0);
            for (int32_t i = 0; i < n; ++i) fa[i] *= fb[i];
            fft(fa, 1);
            res.resize(n);
            ll carry = 0;
            for (int32_t i = 0; i < n; i++) {
                ll t = (ll)(fa[i].real() + 0.5) + carry;
                carry = t / FBASE;
                res[i] = t % FBASE;
            }
        }
        static inline int32_t rev_incr(int32_t a, int32_t n) {
            int32_t msk = n / 2, cnt = 0;
            while ( a & msk ) {
                cnt++;
                a <<= 1;
            }
            a &= msk - 1;
            a |= msk;
            while ( cnt-- ) a >>= 1;
            return a;
        }
        static vector<Cplx> FFT(vector<Cplx> v, int32_t dir = 1) {
            Cplx wm, w, u, t;
            int32_t n = v.size();
            vector<Cplx> V(n);
            for (int32_t k = 0, a = 0; k < n; ++k, a = rev_incr(a, n))
                V[a] = v[k] / ld(dir > 0 ? 1 : n);
            for (int32_t m = 2; m <= n; m <<= 1) {
                wm = polar( (ld)1, dir * 2 * PI / m );
                for (int32_t k = 0; k < n; k += m) {
                    w = 1;
                    for (int32_t j = 0; j < m / 2; ++j, w *= wm) {
                        u = V[k + j];
                        t = w * V[k + j + m / 2];
                        V[k + j] = u + t;
                        V[k + j + m / 2] = u - t;
                    }
                }
            }
            return V;
        }
        static void convolution(const vector<int32_t>& a, const vector<int32_t>& b, vector<int32_t>& c) {
            int32_t sz = a.size() + b.size() - 1;
            int32_t n  = 1 << int32_t(ceil(log2(sz)));
            vector<Cplx> av(n, 0), bv(n, 0), cv;
            for (int32_t i = 0; i < (int32_t) a.size(); i++) av[i] = a[i];
            for (int32_t i = 0; i < (int32_t) b.size(); i++) bv[i] = b[i];
            cv = FFT(bv);
            bv = FFT(av);
            for (int32_t i = 0; i < n; i++) av[i] = bv[i] * cv[i];
            cv = FFT(av, -1);
            c.resize(n);
            ll carry = 0;
            for (int32_t i = 0; i < n; i++) {
                ll t = ll(cv[i].real() + 0.5) + carry;
                carry = t / FBASE;
                c[i] = t % FBASE;
            }
        }
        bigint mul_simple(const bigint &v) const {
            bigint res;
            res.sgn = sgn * v.sgn;
            res.a.resize(a.size() + v.a.size());
            for (int32_t i = 0; i < (int32_t) a.size(); i++) if (a[i])
                    for (int32_t j = 0, carry = 0; j < (int32_t) v.a.size() || carry; j++) {
                        ll cur = res.a[i + j] + (ll) a[i] * (j < (int32_t) v.a.size() ? v.a[j] : 0) + carry;
                        carry = (int32_t) (cur / BASE);
                        res.a[i + j] = (int32_t) (cur % BASE);
                    }
            res.trim();
            return res;
        }
        bigint mul_fft(const bigint& v) const {
            bigint res;
            convolution(convert_base(a, DIG, FDIG), convert_base(v.a, DIG, FDIG), res.a);
            res.a = convert_base(res.a, FDIG, DIG);
            res.trim();
            return res;
        }
        void operator*=(const bigint &v) {
            *this = *this * v;
        }
        bigint operator*(const bigint &v) const {
            if (1LL * a.size() * v.a.size() <= 1000111) return mul_simple(v);
            return mul_fft(v);
        }
 
        bigint abs() const {
            bigint res = *this;
            res.sgn *= res.sgn;
            return res;
        }
        void trim() {
            while (!a.empty() && !a.back()) a.pop_back();
        }
        bool zero() const {
            return a.empty() || (a.size() == 1 && !a[0]);
        }
        friend bigint gcd(const bigint &a, const bigint &b) {
            return b.zero() ? a : gcd(b, a % b);
        }
    };
    bigint power(bigint a, ll k) {
        bigint ans = 1;
        while (k > 0) {
            if (k & 1) ans *= a;
            a *= a;
            k >>= 1;
        }
        return ans;
    }
}
 
using BigNum :: bigint;
using BigNum :: power;
 
bigint sq(bigint x) {
    return x * x;
}
 
bigint cb(bigint x) {
    return x * x * x;
}
 
ll n;
bigint res;
void solve() {
    cin >> n;
 
    // Loại 1
    bigint tmp = n;
    res = tmp * (tmp + 1) / 2;
 
    // Loại 2
    for (bigint i = 1; sq(i) <= n; i += 1) {
        res += (sq(i) - sq(i - 1)) * i;
    }
    tmp = sqrt(n);
    res += (tmp + 1) * (n - sq(tmp));
 
    // Loại 3
    for (bigint i = 2; cb(i) <= n; i += 1) {
        res += (cb(i) - cb(i - 1)) * (i - 1);
    }
    tmp = cbrt(n);
    res += tmp * (n - cb(tmp) + 1);
 
    cout << res << endl;
}
 
signed main() {
    ios::sync_with_stdio(false), cin.tie(nullptr);
    srand(time(NULL));
    #define name "test"
    if (fopen(name".INP", "r")) {
        freopen(name".INP", "r", stdin);
        freopen(name".OUT", "w", stdout);
    }
    bool testCase = false;
    int numTest = 1;
//    cin >> numTest;
    forw (i, 1, numTest) {
        if (testCase) cout << "Case " << i << ": ";
        solve();
    }
    return 0;
}