#include <bits/stdc++.h>

#define clr(x) memset((x), 0, sizeof(x))
#define all(x) (x).begin(), (x).end()
#define pb push_back
#define mp make_pair
#define x first
#define y second
#define forn(i, n) for(int i = 0; i < (int)(n); ++i)
#define ford(i, n) for(int i = (int)(n) - 1; i >= 0; --i)
#define for1(i, n) for(int i = 1; i <= (int)(n); ++i)

using namespace std;

typedef vector<int> vi;
typedef pair<int, int> pii;
typedef vector<long long> vll;
typedef long double ld;
typedef long long ll;
typedef unsigned long long ull;
typedef int itn;

const ld PI = 3.1415926535897932384626433832795L;

template<class T>
bool uin(T &, const T &);

template<class T>
bool uax(T &, const T &);

template<class T>
T gcd(T, T);

template<class T>
T lcm(T, T);

template<class _T>
inline string tostr(const _T &);

template<typename T>
void input(T &);

template<typename T = long long>
T nxt();

bool checkp(long long);

long long pw(long long a, long long n, long long p);

long long inv(long long a, long long p);

void pre() {}


void solve(int test) {
    int n = nxt();

    ll a[n];
    forn(i, n) a[i] = nxt();



    vi primes;

    ll BOUND = 10000000000ll;

    for (ll j = 2; j * j * j <= BOUND; ++j) {
        if (checkp(j)) {
            primes.push_back(j);
        }
    }

    vll aprimes;

    for (ll j = 2; j * j <= BOUND; ++j) {
        if (checkp(j)) {
            aprimes.push_back(j);
        }
    }

    map <ll, pii> t;

    int ans = 0;
    int fl = 0;

    forn(i, n) {
        ll x = a[i];
        ll y = 1;
        ll z = 1;
        for (int j : primes) {
            int degree = 0;
            while (x % j == 0) {
                degree += 1;
                x /= j;
            }
            degree %= 3;
            if (degree == 2) {
                y *= j;
                z *= j;
                z *= j;
            }
            if (degree == 1) {
                y *= j;
                y *= j;
                z *= j;
            }
        }
        if (x != 1) {
            ll r = sqrt(x + 0.5);
            if (r * r == x && binary_search(all(aprimes), r)) {
                z *= r;
                z *= r;
                y *= r;
                goto l1;
            }
            if (binary_search(all(aprimes), x)) {
                z *= x;
                y *= x;
                y *= x;
                goto l1;
            }
            ++ans;
            continue;
            l1:;
        }
        if (y == z) {
            if (!fl) {
                ans += 1;
                fl = 1;
            }
        } else if (y < z) {
            t[y].x += 1;
        } else {
            t[z].y += 1;
        }
    }

    for (auto p : t) {
        ans += max(p.y.x, p.y.y);
    }

    cout << ans << "\n";
}


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

#ifdef LOCAL
    freopen("input.txt", "r", stdin);
//    freopen("output.txt", "w", stdout);
#else
    #define fname "sequence"
    //freopen(fname".in", "r", stdin);
    //freopen(fname".out", "w", stdout);
#endif
    pre();
    int t = 1;
#ifdef LOCAL
#else
#endif
    for (int test = 1; test <= t; ++test) {
        solve(test);
    }

#ifdef LOCAL
    cerr << "Time elapsed: " << 1.0 * clock() / CLOCKS_PER_SEC * 1000 << " ms." << endl;
#endif
    return 0;
}


template<typename T>
T gcd(T x, T y) {
    while (y > 0) {
        x %= y;
        swap(x, y);
    }
    return x;
}

template<class T>
T lcm(T a, T b) {
    return a / gcd(a, b) * b;
}


template<class _T>
inline _T sqr(const _T &x) {
    return x * x;
}

template<class _T>
inline string tostr(const _T &a) {
    ostringstream os("");
    os << a;
    return os.str();
}


template<typename T>
inline void input(T &a) {
    static int ed;
    a = 0;
    while (!isdigit(ed = getchar()) && ed != '-') {}
    char neg = 0;
    if (ed == '-') {
        neg = 1;
        ed = getchar();
    }
    while (isdigit(ed)) {
        a = 10 * a + ed - '0';
        ed = getchar();
    }
    if (neg) a = -a;
}

template<typename T = long long>
inline T nxt() {
    T res;
    input(res);
    return res;
}

void myassert(bool v) {
    assert(v);
    //cout << "FAIL\n";
    //exit(0);
}

mt19937 generator;

bool checkp(long long v) {
    if (v < 2) return false;
    for (long long i = 2; i * i <= v; ++i) {
        if (v % i == 0) {
            return false;
        }
    }
    return true;
}

long long pw(long long a, long long n, long long m) {
    ll res = 1;
    while (n) {
        if (n & 1ll) {
            res = res * a % m;
        }
        a = a * a % m;
        n >>= 1;
    }
    return res;
}

long long inv(long long a, long long p) {
    long long res = 1;
    while (a > 1) {
        res = res * (p - p / a) % p;
        a = p % a;
    }
    return res;
}


template<class T>
bool uin(T &a, const T &b) {
    if (b < a) {
        a = b;
        return true;
    }
    return false;
}

template<class T>
bool uax(T &a, const T &b) {
    if (b > a) {
        a = b;
        return true;
    }
    return false;
}


Measured memory_bytes: 6272