import java.util.*;
import java.io.*;
import java.lang.Math;
 
public class HelloWorld
{
   public static int n;
   public static int[] t = new int[300010];
   
   public static int abss(int x)
   {
      if (x<0) return (-x); else
         return x;
   }
   
   public static long f(int x)
   {
      long sum=0;
      
      for (int i = 1;i <= n;i++) sum = sum + abss(x-t[i]);
      
      return sum;
   }
   
   public static void main(String[] avgs) throws Exception
   {
      InputReader in = new InputReader(System.in);
      OutputWriter out = new OutputWriter(System.out);
      
      n = in.nextInt();
      
      for (int i = 1;i <= n;i++) t[i] = in.nextInt();
         
      //Arrays.sort(t,1,n+1);
      
      int st,dr;
      
      st = -1000000000; dr = 1000000000;
      
      while ( st<dr ) {
         int m1 = st+(dr-st)/3;
         int m2 = dr-(dr-st)/3;
         
         if (f(m1)<=f(m2)) {
            if (dr==m2) dr=m2-1; else
               dr=m2;
         } else {
            if (st==m1) st=m1+1; else
               st=m1;
         }
      }
      
      out.println(st);
      
      out.close();
   }
 
   static class InputReader
   {
       private InputStream stream;
       private byte[] buf = new byte[ 2048 ];
       private int curChar;
       private int numChars;
 
       public InputReader(InputStream stream)
       {
           this.stream = stream;
       }
 
       public InputReader(FileReader fileReader)
      {
         // TODO Auto-generated constructor stub
      }
 
      public int read()
       {
           if (numChars == -1)
               throw new InputMismatchException();
 
           if (curChar >= numChars)
           {
               curChar = 0;
               try
               {
                   numChars = stream.read(buf);
               } catch (IOException e)
               {
                   throw new InputMismatchException();
               }
               if (numChars <= 0)
                   return -1;
           }
 
           return buf[curChar++];
       }
 
       public int nextInt()
       {
           int c = read();
 
           while (isSpaceChar(c))
               c = read();
 
           int sgn = 1;
 
           if (c == '-')
           {
               sgn = -1;
               c = read();
           }
 
           int res = 0;
 
           do
           {
               if (c < '0' || c > '9')
                   throw new InputMismatchException();
 
               res *= 10;
               res += c & 15;
 
               c = read();
           } while (!isSpaceChar(c));
 
           return res * sgn;
       }
 
       public int[] nextIntArray(int arraySize)
       {
           int array[] = new int[arraySize];
 
           for (int i = 0; i < arraySize; i++)
               array[i] = nextInt();
 
           return array;
       }
 
       public long nextLong()
       {
           int c = read();
 
           while (isSpaceChar(c))
               c = read();
 
           int sign = 1;
 
           if (c == '-')
           {
               sign = -1;
 
               c = read();
           }
 
           long result = 0;
 
           do
           {
               if (c < '0' || c > '9')
                   throw new InputMismatchException();
 
               result *= 10;
               result += c & 15;
 
               c = read();
           } while (!isSpaceChar(c));
 
           return result * sign;
       }
 
       public long[] nextLongArray(int arraySize)
       {
           long array[] = new long[arraySize];
 
           for (int i = 0; i < arraySize; i++)
               array[i] = nextLong();
 
           return array;
       }
 
       public float nextFloat() // problematic
       {
           float result, div;
           byte c;
 
           result = 0;
           div = 1;
           c = (byte) read();
 
           while (c <= ' ')
               c = (byte) read();
 
           boolean isNegative = (c == '-');
 
           if (isNegative)
               c = (byte) read();
 
           do
           {
               result = result * 10 + c - '0';
           } while ((c = (byte) read()) >= '0' && c <= '9');
 
           if (c == '.')
               while ((c = (byte) read()) >= '0' && c <= '9')
                   result += (c - '0') / (div *= 10);
 
           if (isNegative)
               return -result;
 
           return result;
       }
 
       public double nextDouble() // not completely accurate
       {
           double ret = 0, div = 1;
           byte c = (byte) read();
 
           while (c <= ' ')
               c = (byte) read();
 
           boolean neg = (c == '-');
 
           if (neg)
               c = (byte) read();
 
           do
           {
               ret = ret * 10 + c - '0';
           } while ((c = (byte) read()) >= '0' && c <= '9');
 
           if (c == '.')
               while ((c = (byte) read()) >= '0' && c <= '9')
                   ret += (c - '0') / (div *= 10);
 
           if (neg)
               return -ret;
 
           return ret;
       }
 
       public String next()
       {
           int c = read();
 
           while (isSpaceChar(c)) c = read();
 
           StringBuilder res = new StringBuilder();
 
           do
           {
               res.appendCodePoint(c); c = read();
           } while (!isSpaceChar(c));
 
           return res.toString();
       }
 
       public boolean isSpaceChar(int c)
       {
           return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
       }
 
       public String nextLine()
       {
           int c = read();
 
           StringBuilder result = new StringBuilder();
 
           do
           {
               result.appendCodePoint(c);
 
               c = read();
           } while (!isNewLine(c));
 
           return result.toString();
       }
 
       public boolean isNewLine(int c) { return c == '\n'; }
 
       public void close()
       {
           try
           {
               stream.close();
           } catch (IOException e)
           {
               e.printStackTrace();
           }
       }
 
   }
 
   static class OutputWriter
   {
       private PrintWriter writer;
 
       public OutputWriter(OutputStream stream)
       {
           writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(
                   stream)));
       }
 
       public OutputWriter(Writer writer) { this.writer = new PrintWriter(writer); }
 
       public void println(int x) { writer.println(x); }
 
       public void print(int x) { writer.print(x); }
 
       public void println(char x) { writer.println(x); }
 
       public void print(char x) { writer.print(x); }
 
       public void println(int array[], int size)
       {
           for (int i = 0; i < size; i++) println(array[i]);
       }
 
       public void print(int array[], int size)
       {
           for (int i = 0; i < size; i++)
               print(array[i] + " ");
       }
 
       public void println(long x) { writer.println(x); }
 
       public void print(long x) { writer.print(x); }
 
       public void println(long array[], int size)
       {
           for (int i = 0; i < size; i++)
               println(array[i]);
       }
 
       public void print(long array[], int size)
       {
           for (int i = 0; i < size; i++)
               print(array[i]);
       }
 
       public void println(float num) { writer.println(num); }
 
        
       public void print(float num) { writer.print(num); }
 
       public void println(double num) { writer.println(num); }
 
       public void print(double num) { writer.print(num); }
 
       public void println(String s) { writer.println(s); }
 
       public void print(String s) { writer.print(s); }
 
       public void println() { writer.println(); }
 
       public void printSpace() { writer.print(" "); }
 
       public void printf(String format, Object args) { writer.printf(format, args); }
 
       public void flush() { writer.flush(); }
 
       public void close() { writer.close(); }
 
   }
}