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.io.*;
import java.util.*;

import static java.lang.Math.*;


public class Main {
    BufferedReader br;
    StringTokenizer in;
    PrintWriter pw;
    Random r;

    int INF = (int) 1e9;
    long LNF = (long) 1e18;
    long mod = (long) (1e9 + 7);
    // you shall not hack!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
    //        /*\
    //       ///          /^\
    //      ///    ~~~~  (___)
    //     ///   ~~~~~~~~  \\__
    //   _/_/_  ~/ .& . \~  \\ \
    //  [____] ~|  (__)  |~/ \\/
    //  /_/\  \~|~~~~~~~~~~  /\\
    //      \   ~~~~~~~~~~ _/ \\
    //       \ _    ~~   _/\   \\
    //      /  |        /   \   \\
    //     |  /        |     \   \\
    //    /  /   ___   |      \
    //   /___|  | __|  |_______\
    //      _|  |   |  |_
    //     |____|   |____|
    //       P.S this is omnipotent Gandalf

    void solve() throws IOException {
        int n = nextInt();
        int mx = (int) -1e7;
        for (int i = 0; i < n; i++) {
            int a = nextInt();
            if (a < 0) mx = max(mx, a);
            else {
                if ((int)Math.sqrt(a) * (int)Math.sqrt(a) != a) {
                    mx = max(mx, a);
                }
            }
        }
        pw.print(mx);
    }

    //***************************************
    class road {
        int to;

        int w;

        public road(int tto, int ww) {
            to = tto;
            w = ww;
        }
    }

    class pair {
        int a;

        int b;

        public pair(int aa, int bb) {
            a = aa;
            b = bb;
        }

    }

    Comparator<pair> bya = new Comparator<pair>() {
        @Override
        public int compare(pair o1, pair o2) {
            if (o1.a != o2.a) return Integer.compare(o1.a, o2.a);
            return Integer.compare(o1.b, o2.b);
        }
    };

    Comparator<pair> byb = new Comparator<pair>() {
        @Override
        public int compare(pair o1, pair o2) {
            if (o1.b != o2.b) return Integer.compare(o1.b, o2.b);
            return Integer.compare(o1.a, o2.a);
        }
    };
    Comparator<road> byw = new Comparator<road>() {
        @Override
        public int compare(road o1, road o2) {
            if (o1.w != o2.w) return Integer.compare(o1.w, o2.w);
            return Integer.compare(o1.to, o2.to);
        }
    };
    Comparator<road> byto = new Comparator<road>() {
        @Override
        public int compare(road o1, road o2) {
            return Integer.compare(o1.to, o2.to);
        }
    };

    class node {
        int sz;
        int val;
        //        long sum;
        node L;
        node R;
        int prior;

        public node(int val) {
            this.val = val;
            prior = r.nextInt();
            L = null;
            R = null;
            sz = 1;
//            sum = (long)val * val;
        }

        void add(int z) {
            val = val + z;
//            sum = (long)val * val;
        }
    }

    void relax(node c) {
        if (c == null) return;
        c.sz = sfsz(c.L) + sfsz(c.R) + 1;
//        c.sum = sfsum(c.L) + sfsum(c.R) + c.val * c.val;
    }

    int sfsz(node c) {
        if (c == null) return 0;
        return c.sz;
    }

    node merge(node a, node b) {
        if (a == null) return b;
        if (b == null) return a;
        if (a.prior > b.prior) {
            a.R = merge(a.R, b);
            relax(a);
            return a;
        } else {
            b.L = merge(a, b.L);
            relax(b);
            return b;
        }
    }

    pairn split(node c, int s) {
        if (c == null) return new pairn(null, null);
        if (sfsz(c.L) >= s) {
            pairn p = split(c.L, s);
            c.L = p.b;
            relax(c);
//            relax(p.a);
            return new pairn(p.a, c);
        } else {
            pairn p = split(c.R, s - sfsz(c.L) - 1);
            c.R = p.a;
            relax(c);
//            relax(p.b);
            return new pairn(c, p.b);
        }
    }

    class pairn {
        node a;
        node b;

        public pairn(node a, node b) {
            this.a = a;
            this.b = b;
        }
    }

    String nextToken() throws IOException {
        while (in == null || !in.hasMoreTokens()) {
            in = new StringTokenizer(br.readLine());
        }
        return in.nextToken();
    }

    int nextInt() throws IOException {
        return Integer.parseInt(nextToken());
    }

    long nextLong() throws IOException {
        return Long.parseLong(nextToken());
    }

    //    boolean check()
    public void run() throws IOException {
        r = new Random(5);
        br = new BufferedReader(new InputStreamReader(System.in));
        pw = new PrintWriter(new OutputStreamWriter(System.out));
//        br = new BufferedReader(new FileReader("input.txt"));
//        pw = new PrintWriter(new FileWriter("output.txt"));
//        br = new BufferedReader(new FileReader("river.in"));
//        pw = new PrintWriter(new FileWriter("river.out"));
        solve();
        pw.close();
    }

    public static void main(String[] args) throws IOException {
        new Main().run();
    }
}