using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;

namespace Competitive
{
    internal class Solution
    {
        public long N;
        public long[] A, AS;
        public long MM = 1000000;
        public void Run()
        {
            N = Input.ReadLong();
            A = Input.ReadLongArray();
            AS = A.ToArray();
            Array.Sort(AS);

            var bs = new BinarySearch(AS, this.Cond);
            int ind = bs.Search();

            long ret = AS[ind];
            Console.WriteLine(ret);
        }

        // インデックスに対応する値が、答えとなる中央値以上ならtrue
        public bool Cond(int i)
        {
            // 答えとなる値 -> それ以下の値が半数より大きい
            // 答えとなる値より大きい -> それ以下の値が半数以上より大きい

            // 対象値より小さいを-1, 対象値以上を+1にエンコードし累積和をとる。
            // その差がマイナスの組み合わせが、中央値が対応する値より小さい場合の数
            long x = AS[i];
            int[] E = A.Select(e => e <= x ? -1 : 1).ToArray();
            int[] ES = new int[N+1];
            for (int ii = 0; ii < N; ii++)
            {
                ES[ii + 1] = E[ii] + ES[ii];
            }

            // 「中央値が対応する値より小さい場合の数」が半数以上ならば、対象値は十分大きいのでtrue
            long count = new InversionCount().Calc(ES.ToArray());
          
            long comb = (N) * (N + 1) / 2;
            long threshold = comb / 2;
            // Console.WriteLine($"i:{i} x:{x} {count} {count >= threshold}");
            return count > threshold;
        }
    }

    // libs ----------
    // 転倒数の計算
    class InversionCount
    {
        public int[] A;

        public long Calc(int[] A)
        {
            this.A = A.ToArray(); // 一応コピーすることにする
            return dfs(0, A.Length);
        }

        long dfs(int L, int R)
        {
            // [L, M), [M, R) に分ける
            int n = R - L;
            if (n <= 1) return 0;
            int m = (L + R) / 2;

            long ret = 0;
            ret += dfs(L, m);
            ret += dfs(m, R);

            int r = m;
            for (int l = L; l < m; l++)
            {
                while (r < R && A[l] > A[r])
                {
                    r++;
                }
                ret += (r - m);
            }

            // 対象範囲をソートする
            int M = (L + R) / 2;
            var aryL = new int[M - L];
            var aryR = new int[R - M];

            for (int i = L; i < M;i++)
            {
                aryL[i - L] = A[i];
            }
            for (int i = M; i < R; i++)
            {
                aryR[i - M] = A[i];
            }

            int il = 0;
            int ir = 0;
            while (true)
            {
                if (il == aryL.Length && ir == aryR.Length)
                    break;

                if (il == aryL.Length)
                {
                    A[L + il + ir] = aryR[ir];
                    ir++;
                }
                else if (ir == aryR.Length)
                {
                    A[L + il + ir] = aryL[il];
                    il++;
                }
                else if (aryL[il] <= aryR[ir])
                {
                    A[L + il + ir] = aryL[il];
                    il++;
                }
                else
                {
                    A[L + il + ir] = aryR[ir];
                    ir++;
                }
            }


            return ret;
        }
    }

    internal class BinarySearch
    {
        public long[] S;
        public int N { get { return S.Length; } }
        public Func<int, bool> Cond;
        public BinarySearch(long[] s, Func<int, bool> cond)
        {
            S = s;
            Cond = cond;
        }

        // 初めてCondがtrueを返すindexを返す
        // 全て条件を満たさない場合はNを返す
        public int Search()
        {
            int left = 0;
            int right = N;

            if (Cond(0)) return 0;
            if (!Cond(N - 1)) return N;

            while (left + 1 < right)
            {
                int mid = (left + right) / 2;
                if (!Cond(mid))
                {
                    left = mid;
                }
                else
                {
                    right = mid;
                }
            }
            return right;
        }
    }

    // common ----------

    internal static class Input
    {
        public static string ReadString()
        {
            string line = Console.ReadLine();
            return line;
        }

        public static int ReadInt()
        {
            string line = Console.ReadLine();
            return int.Parse(line);
        }

        public static int[] ReadIntArray()
        {
            string line = Console.ReadLine();
            return line.Split(' ').Select(int.Parse).ToArray();            
        }

        public static long ReadLong()
        {
            string line = Console.ReadLine();
            return long.Parse(line);
        }

        public static long[] ReadLongArray()
        {
            string line = Console.ReadLine();
            return line.Split(' ').Select(long.Parse).ToArray();
        }

        public static double[] ReadDoubleArray()
        {
            string line = Console.ReadLine();
            return line.Split(' ').Select(double.Parse).ToArray();
        }
    }
    
    internal class Program
    {
        public static void Main(string[] args)
        {
            var s = new Solution();
            s.Run();
        }
    }
}

Measured memory_bytes: 42432