Given an array a1, a2, ..., an of n integers, find the largest number in the array that is not a perfect square.

A number x is said to be a perfect square if there exists an integer y such that x = y2.

Input

The first line contains a single integer n (1 ≤ n ≤ 1000) — the number of elements in the array.

The second line contains n integers a1, a2, ..., an ( - 106 ≤ ai ≤ 106) — the elements of the array.

It is guaranteed that at least one element of the array is not a perfect square.

Output

Print the largest number in the array which is not a perfect square. It is guaranteed that an answer always exists.

Examples

Input

2
4 2


Output

2


Input

8
1 2 4 8 16 32 64 576


Output

32

Note

In the first sample case, 4 is a perfect square, so the largest number in the array that is not a perfect square is 2.
import java.util.*;
import java.io.*;

import static java.lang.Integer.compare;
import static java.lang.Math.*;
import static java.lang.System.in;
import static java.lang.System.out;
import static java.util.Arrays.deepToString;

/**
 * 20/1/18
 * 9:01 PMz
 *
 * @author remedy441
 */
public class CF914 {
    public static int mod = (int) (1e9 + 7);
    public static InputReader in;
    public static PrintWriter out;

    public static void solve() throws FileNotFoundException {


        in = new InputReader(System.in);
        out = new PrintWriter(System.out);
        int n = in.ni();
        int ar[] = in.nIArr(n);
        int max = Integer.MIN_VALUE;
        for(int i=0;i<n;i++){
            if(ar[i]>=0){
                int sqrt = (int)Math.sqrt(ar[i]);
                if(sqrt*sqrt!=ar[i]){
                    max = Math.max(max,ar[i]);
                }
            }
            else{
                max = Math.max(max,ar[i]);
            }
        }
        out.println(max);
        out.close();
    }

    public static void main(String[] args) {
        new Thread(null, new Runnable() {
            public void run() {
                try {
                    solve();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }, "1", 1 << 26).start();
    }

    static class Pair implements Comparable<Pair> {

        int x, y, i;

        Pair(int x, int y, int i) {
            this.x = x;
            this.y = y;
            this.i = i;
        }

        Pair(int x, int y) {
            this.x = x;
            this.y = y;
        }

        public int compareTo(Pair o) {
            if (this.x != o.x)
                return compare(this.x, o.x);
            else
                return compare(this.y, o.y);
            //return 0;
        }

        public boolean equals(Object o) {
            if (o instanceof Pair) {
                Pair p = (Pair) o;
                return p.x == x && p.y == y && p.i == i;
            }
            return false;
        }

        public int hashCode() {
            return new Integer(x).hashCode() * 31 + new Integer(y).hashCode() + new Integer(i).hashCode() * 37;
        }

    }

    public static long add(long a, long b) {
        long x = (a + b);
        while (x >= mod)
            x -= mod;
        return x;
    }

    public static long sub(long a, long b) {
        long x = (a - b);
        while (x < 0)
            x += mod;
        return x;
    }

    public static long mul(long a, long b) {
        long x = (a * b);
        while (x >= mod)
            x -= mod;
        return x;
    }

    public static boolean isPal(String s) {
        for (int i = 0, j = s.length() - 1; i <= j; i++, j--) {
            if (s.charAt(i) != s.charAt(j))
                return false;
        }
        return true;
    }

    public static String rev(String s) {
        StringBuilder sb = new StringBuilder(s);
        sb.reverse();
        return sb.toString();
    }

    public static long gcd(long x, long y) {
        if (x % y == 0)
            return y;
        else
            return gcd(y, x % y);
    }

    public static int gcd(int x, int y) {
        if (x % y == 0)
            return y;
        else
            return gcd(y, x % y);
    }

    static int modInverse(int a, int m) {
        int m0 = m, t, q;
        int x0 = 0, x1 = 1;
        if (m == 1)
            return 0;
        while (a > 1) {
            // q is quotient
            q = a / m;
            t = m;
            // m is remainder now, process same as
            // Euclid's algo
            m = a % m;
            a = t;
            t = x0;
            x0 = x1 - q * x0;
            x1 = t;
        }
        // Make x1 positive
        if (x1 < 0)
            x1 += m0;
        return x1;
    }

    public static long gcdExtended(long a, long b, long[] x) {

        if (a == 0) {
            x[0] = 0;
            x[1] = 1;
            return b;
        }
        long[] y = new long[2];
        long gcd = gcdExtended(b % a, a, y);

        x[0] = y[1] - (b / a) * y[0];
        x[1] = y[0];

        return gcd;
    }

    public static long mulmod(long a, long b, long m) {
        if (m <= 1000000009)
            return a * b % m;

        long res = 0;
        while (a > 0) {
            if ((a & 1) != 0) {
                res += b;
                if (res >= m)
                    res -= m;
            }
            a >>= 1;
            b <<= 1;
            if (b >= m)
                b -= m;
        }
        return res;
    }

    public static int abs(int a, int b) {
        return (int) Math.abs(a - b);
    }

    public static long abs(long a, long b) {
        return (long) Math.abs(a - b);
    }

    public static int max(int a, int b) {
        if (a > b)
            return a;
        else
            return b;
    }

    public static int min(int a, int b) {
        if (a > b)
            return b;
        else
            return a;
    }

    public static long max(long a, long b) {
        if (a > b)
            return a;
        else
            return b;
    }

    public static long min(long a, long b) {
        if (a > b)
            return b;
        else
            return a;
    }

    public static long pow(long n, long p, long m) {
        long result = 1;
        if (p == 0)
            return 1;
        if (p == 1)
            return n;
        while (p != 0) {
            if (p % 2 == 1)
                result *= n;
            if (result >= m)
                result %= m;
            p >>= 1;
            n *= n;
            if (n >= m)
                n %= m;
        }
        return result;
    }

    public static long pow(long n, long p) {
        long result = 1;
        if (p == 0)
            return 1;
        if (p == 1)
            return n;
        while (p != 0) {
            if (p % 2 == 1)
                result *= n;
            p >>= 1;
            n *= n;
        }
        return result;
    }

    public static void debug(Object... o) {
        System.out.println(deepToString(o));
    }

    static class InputReader {
        private final InputStream stream;
        private final byte[] buf = new byte[8192];
        private int curChar, snumChars;
        private SpaceCharFilter filter;

        public InputReader(InputStream stream) {
            this.stream = stream;
        }

        public int snext() {
            if (snumChars == -1)
                throw new InputMismatchException();
            if (curChar >= snumChars) {
                curChar = 0;
                try {
                    snumChars = stream.read(buf);
                } catch (IOException e) {
                    throw new InputMismatchException();
                }
                if (snumChars <= 0)
                    return -1;
            }
            return buf[curChar++];
        }

        public int ni() {
            int c = snext();
            while (isSpaceChar(c)) {
                c = snext();
            }
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = snext();
            }
            int res = 0;
            do {
                if (c < '0' || c > '9')
                    throw new InputMismatchException();
                res *= 10;
                res += c - '0';
                c = snext();
            } while (!isSpaceChar(c));
            return res * sgn;
        }

        public long nl() {
            int c = snext();
            while (isSpaceChar(c)) {
                c = snext();
            }
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = snext();
            }
            long res = 0;
            do {
                if (c < '0' || c > '9')
                    throw new InputMismatchException();
                res *= 10;
                res += c - '0';
                c = snext();
            } while (!isSpaceChar(c));
            return res * sgn;
        }

        public int[] nIArr(int n) {
            int a[] = new int[n];
            for (int i = 0; i < n; i++) {
                a[i] = ni();
            }
            return a;
        }

        public long[] nLArr(int n) {
            long a[] = new long[n];
            for (int i = 0; i < n; i++) {
                a[i] = nl();
            }
            return a;
        }

        public String readString() {
            int c = snext();
            while (isSpaceChar(c)) {
                c = snext();
            }
            StringBuilder res = new StringBuilder();
            do {
                res.appendCodePoint(c);
                c = snext();
            } while (!isSpaceChar(c));
            return res.toString();
        }

        public String nextLine() {
            int c = snext();
            while (isSpaceChar(c))
                c = snext();
            StringBuilder res = new StringBuilder();
            do {
                res.appendCodePoint(c);
                c = snext();
            } while (!isEndOfLine(c));
            return res.toString();
        }

        public boolean isSpaceChar(int c) {
            if (filter != null)
                return filter.isSpaceChar(c);
            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
        }

        private boolean isEndOfLine(int c) {
            return c == '\n' || c == '\r' || c == -1;
        }

        public interface SpaceCharFilter {
            public boolean isSpaceChar(int ch);
        }

    }
}
