We will define the median of a sequence b of length M, as follows:

* Let b' be the sequence obtained by sorting b in non-decreasing order. Then, the value of the (M / 2 + 1)-th element of b' is the median of b. Here, / is integer division, rounding down.



For example, the median of (10, 30, 20) is 20; the median of (10, 30, 20, 40) is 30; the median of (10, 10, 10, 20, 30) is 10.

Snuke comes up with the following problem.

You are given a sequence a of length N. For each pair (l, r) (1 \leq l \leq r \leq N), let m_{l, r} be the median of the contiguous subsequence (a_l, a_{l + 1}, ..., a_r) of a. We will list m_{l, r} for all pairs (l, r) to create a new sequence m. Find the median of m.

Constraints

* 1 \leq N \leq 10^5
* a_i is an integer.
* 1 \leq a_i \leq 10^9

Input

Input is given from Standard Input in the following format:


N
a_1 a_2 ... a_N


Output

Print the median of m.

Examples

Input

3
10 30 20


Output

30


Input

1
10


Output

10


Input

10
5 9 5 9 8 9 3 5 4 3


Output

8

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.Random;
import java.util.StringTokenizer;

public final class Main {

    static class Bit {
        private final int n;
        private final long[] table;

        Bit(int n) {
            this.n = n;
            table = new long[n];
        }

        Bit(long[] a) {
            this(a.length);
            for (int i = 0; i < n; i++) {
                table[i] = a[i];
                final int j = i + (i & -i);
                if (j < n) {
                    table[j] += table[i];
                }
            }
        }

        private long getSum(int i) {
            long sum = 0;
            for (; i > 0; i -= i & -i) {
                sum += table[i - 1];
            }
            return sum;
        }

        void add(int i, long x) {
            for (i++; i <= n; i += i & -i) {
                table[i - 1] += x;
            }
        }

        void set(int i, long x) {
            add(i, x - get(i));
        }

        long get(int i) {
            return getSum(i + 1) - getSum(i);
        }

        long getSum(int l, int r) {
            return l >= r ? 0 : getSum(r) - getSum(l);
        }

        int lowerBound(long x) {
            if (x <= 0) {
                return 0;
            }
            int i = 0;
            for (int j = Integer.highestOneBit(n); j > 0; j /= 2) {
                if (i + j <= n && table[i + j - 1] < x) {
                    x -= table[i + j - 1];
                    i += j;
                }
            }
            return i;
        }

        int upperBound(long x) {
            if (x <= 0) {
                return 0;
            }
            int i = 0;
            for (int j = Integer.highestOneBit(n); j > 0; j /= 2) {
                if (i + j <= n && table[i + j] <= x) {
                    i += j;
                    x -= table[i];
                }
            }
            return i;
        }

        long[] getAll() {
            final long[] res = new long[n];
            for (int i = 0; i < n; i++) {
                res[i] = get(i);
            }
            return res;
        }

        @Override
        public String toString() {
            return Arrays.toString(getAll());
        }
    }

    public static void main(String[] args) {
        final FastScanner fs = new FastScanner();
        final int n = fs.nextInt();
        final int[] arr = fs.nextIntArray(n);
        int lo = 0, hi = (int) 1e9 + 5;
        while (hi - lo > 1) {
            final int mid = lo + hi >>> 1;
            final int[] s = new int[n + 1];
            for (int i = 0; i < n; i++) {
                s[i + 1] = s[i] + (arr[i] < mid ? -1 : 1);
            }
            final Bit bit = new Bit(4 * n + 1);
            long score = 0;
            for (int i = 0; i <= n; i++) {
                score += bit.getSum(0, s[i] + 2 * n + 1);
                bit.add(s[i] + 2 * n, 1);
            }
            if (score >= ((long) n * (n + 1) / 2 + 1) / 2) {
                lo = mid;
            } else {
                hi = mid;
            }
        }
        System.out.println(lo);
    }

    static final class Util {
        public static void shuffleSort(int[] x) {
            shuffle(x);
            Arrays.sort(x);
        }

        public static void shuffleSort(long[] x) {
            shuffle(x);
            Arrays.sort(x);
        }

        public static void shuffle(int[] x) {
            final Random r = new Random();

            for (int i = 0; i <= x.length - 2; i++) {
                final int j = i + r.nextInt(x.length - i);
                swap(x, i, j);
            }
        }

        public static void shuffle(long[] x) {
            final Random r = new Random();

            for (int i = 0; i <= x.length - 2; i++) {
                final int j = i + r.nextInt(x.length - i);
                swap(x, i, j);
            }
        }

        public static void swap(int[] x, int i, int j) {
            final int t = x[i];
            x[i] = x[j];
            x[j] = t;
        }

        public static void swap(long[] x, int i, int j) {
            final long t = x[i];
            x[i] = x[j];
            x[j] = t;
        }

        private Util() {}
    }

    static class FastScanner {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st = new StringTokenizer("");

        private String next() {
            while (!st.hasMoreTokens()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (IOException e) {
                    //noinspection CallToPrintStackTrace
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }

        int nextInt() {
            return Integer.parseInt(next());
        }

        long nextLong() {
            return Long.parseLong(next());
        }

        int[] nextIntArray(int n) {
            final int[] a = new int[n];
            for (int i = 0; i < n; i++) { a[i] = nextInt(); }
            return a;
        }

        long[] nextLongArray(int n) {
            final long[] a = new long[n];
            for (int i = 0; i < n; i++) { a[i] = nextLong(); }
            return a;
        }
    }
}
