This year, as in previous years, MemSQL is inviting the top 25 competitors from the Start[c]up qualification round to compete onsite for the final round. Not everyone who is eligible to compete onsite can afford to travel to the office, though. Initially the top 25 contestants are invited to come onsite. Each eligible contestant must either accept or decline the invitation. Whenever a contestant declines, the highest ranked contestant not yet invited is invited to take the place of the one that declined. This continues until 25 contestants have accepted invitations.After the qualifying round completes, you know K of the onsite finalists, as well as their qualifying ranks (which start at 1, there are no ties). Determine the minimum possible number of contestants that declined the invitation to compete onsite in the final round.

The first line of input contains K (1 ≤ K ≤ 25), the number of onsite finalists you know. The second line of input contains r1, r2, ..., rK (1 ≤ ri ≤ 106), the qualifying ranks of the finalists you know. All these ranks are distinct.

Print the minimum possible number of contestants that declined the invitation to compete onsite.

NoteIn the first example, you know all 25 onsite finalists. The contestants who ranked 1-st, 13-th, and 27-th must have declined, so the answer is 3.

import java.io.*;
import java.util.*;

public class Solution {

    public static void main(String[] args) {
 Scanner snr = new Scanner(System.in);
		int n = snr.nextInt();
		ArrayList<Integer> p = new ArrayList<>();
		for(int i=0; i<n; i++) {
		p.add(snr.nextInt());
		}
		System.out.println(out(n,p));
    }
	public static int out(int n, ArrayList<Integer> arr) {
		Collections.sort(arr);
		int sum=0;
		for(int i=0; i<arr.size(); i++) {
			if(arr.get(i)<=25) {
				sum=0;
			}
			else{
				sum=arr.get(n-1)-25;
			}
		}
		return sum;
	}
}

import java.util.Scanner;
public class DeclinedFinalists{
	static Scanner kbd=new Scanner(System.in);
	public static void main(String[]args){
		int noContestants=kbd.nextInt();
		int [] contestants=new int[noContestants];
		int declined=0;
		int temp=0;
		int max=0;
		for(int x=0; x<noContestants; x++){
			contestants[x]=kbd.nextInt();
		}
		for (int counter=0; counter<noContestants; counter++){
     		if (contestants[counter]>max){
      			max=contestants[counter];
     		}
		}
		//System.out.print(max);
		for(int y=0; y<noContestants; y++){
			if(contestants[y]>25){
				declined=max-25;
			}
		}
		System.out.print(declined);
	}
}

import java.io.*;
import java.util.*;
import java.text.*;
import java.math.*;
import java.util.regex.*;

public class Finalist {

	public static void main(String[] args){
		Scanner scanner = new Scanner(System.in);
		int numbersFinalist = scanner.nextInt();

		int maxValue = 0;
		int[] arrFinalist = new int[numbersFinalist];
		for(int i=0; i<numbersFinalist; i++){
			arrFinalist[i] = scanner.nextInt();

			if(arrFinalist[i] > maxValue) maxValue = arrFinalist[i];
		}

		int diff = maxValue - 25;

		if(diff > 0) System.out.println(diff);
		else if(diff <= 0) System.out.println(0);
	}

}

import java.util.Scanner;

public class DeclinedFinalists {

    public static void main(String[] args) {
        int maxRank = 0;
        Scanner scan = new Scanner(System.in);
        int numRanks = Integer.parseInt(scan.nextLine());
        int[] allRanks = new int[numRanks];

        String ranks = scan.nextLine();

        int arrayCount = 0;
        int count = 0;
        int subCount = 1;
        if (ranks.length() == 1) {
            allRanks[arrayCount] = Integer.parseInt(ranks.substring(count,
                subCount).trim());
        }
        else {
            while (count < ranks.length()) {
                while (!(ranks.substring(count, subCount).contains(" "))
                    && subCount < ranks.length()) {
                    subCount++;
                }
                allRanks[arrayCount] = Integer.parseInt(ranks.substring(count,
                    subCount).trim());
                arrayCount++;
                count = subCount;
                subCount++;
            }
        }

        for (int i = 0; i < allRanks.length; i++) {
            if (allRanks[i] > maxRank) {
                maxRank = allRanks[i];
            }
        }

        int diff = maxRank - 25;

        if (diff <= 0) {
            System.out.println(0);
        }
        else {
            System.out.println(diff);
        }
    }

}

/* package codechef; // don't place package name! */

import java.util.*;
import java.lang.*;
import java.io.*;
import java.math.*;

/* Name of the class has to be "Main" only if the class is public. */
public class Codechef
{
	public static void main (String[] args) throws java.lang.Exception
	{
		// your code goes here
		Scanner sc=new Scanner(System.in);
	    long n,i,max=0,num;
	    n=sc.nextLong();
	    for(i=0;i<n;i++)
	    {
	          num=sc.nextInt();
	       max=Math.max(num,max);
	    }

	    System.out.println(Math.max(0,(max-25)));
	}}

import java.util.Scanner;

public class Declined{
	public static void main(String[] args) {
		Scanner input = new Scanner(System.in);
		int a, b, max = 0;
		a = input.nextInt();
		for(int i = 0; i < a; i++) {
			b = input.nextInt();
			if(b > max) {
				max = b;
			}
		}
		if(max < 26) {
			System.out.println("0");
		} else {
			System.out.println(max - 25);
		}
	}
}

	import java.util.*;
    import java.math.*;
    import java.io.*;

    public class problem2 {
    	public static void main(String[] args) throws IOException {
    		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    		int n = Integer.parseInt(br.readLine());
    		StringTokenizer st = new StringTokenizer(br.readLine());
    		int arr[] = new int[n];
    		int max = Integer.MIN_VALUE;
    		for(int i=0;i<n;i++) {
    			arr[i] = Integer.parseInt(st.nextToken());
    			max = Math.max(max, arr[i]);
    		}
    		int x = max-25;
    		if(x>0)System.out.println(x);
    		else System.out.println(0);
    	}
    }

import java.util.Scanner;

public class Main {
	public static void main(String[] args) {
		Scanner input = new Scanner(System.in);
		int number = input.nextInt();
		int ans = 0;

		for (int i = number; i > 0; i--) {
			int x = input.nextInt();
			ans = Math.max(ans, x);

		}
		if (ans < 25) {
			System.out.println(0);
		} else {
			System.out.println(ans - 25);
		}
	}
}

import java.util.*;
public class Finalists
{
    public static void main(String args[])
    {
        Scanner obj = new Scanner(System.in);
        int n = obj.nextInt();
        int max=0;
        for(int i=0;i<n;i++)
        {
           int crap = obj.nextInt();
           if(crap>max)
               max=crap;
        }
        int answer=0;
        if(max-25>0)
            answer = max-25;
        System.out.println(answer);
    }
}

import java.io.*;
import java.util.*;

public class A764 {
    public static void main(String [] args) {
        InputStream inputReader = System.in;
        OutputStream outputReader = System.out;
        InputReader in = new InputReader(inputReader);
        PrintWriter out = new PrintWriter(outputReader);
        Algorithm solver = new Algorithm();
        solver.solve(in, out);
        out.close();
    }
}

class Algorithm {
    void solve(InputReader ir, PrintWriter pw) {

        int K = ir.nextInt(), max;
        int [] array = new int[K];

        for (int i = 0; i < K; i++) array[i] = ir.nextInt();

        Arrays.sort(array);

        max = array[K - 1] - 25;

        pw.print(max > 0 ? max : 0);

    }

    boolean isPolyndrom(String str) {
        String newStr = "";
        for (int i = str.length() - 1; i >= 0; i--) newStr = newStr + str.charAt(i);
        return newStr.equals(str);
    }

    private static void Qsort(int[] array, int low, int high) {

        int i = low;
        int j = high;
        int x = array[low + (high - low) / 2];

        do {
            while (array[i] < x) ++i;
            while (array[j] > x) --j;
            if (i <= j) {
                int tmp = array[i];
                array[i] = array[j];
                array[j] = tmp;
                i++;
                j--;
            }
        } while (i <= j);

        if (low < j) Qsort(array, low, j);
        if (i < high) Qsort(array, i, high);

    }
}

class InputReader {
    private BufferedReader reader;
    private StringTokenizer tokenizer;

    InputReader(InputStream stream) {
        reader = new BufferedReader(new InputStreamReader(stream), 32768);
        tokenizer = null;
    }

    public String next() {
        while (tokenizer == null || !tokenizer.hasMoreTokens()) {
            try {
                tokenizer = new StringTokenizer(reader.readLine());
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }
        return tokenizer.nextToken();
    }

    int nextInt() {
        return Integer.parseInt(next());
    }
    double nextDouble() {
        return Double.parseDouble(next());
    }
    long nextLong() {
        return Long.parseLong(next());
    }

}

import java.io.IOException;
import java.util.Scanner;

public class Solutions {

	public static void main(String[] args) throws IOException {
		Scanner sc = new Scanner(System.in);

		int k = sc.nextInt();

		int max = -1;
		for(int i =0; i < k; i++) {
			int r = sc.nextInt();
			if(r > max)
				max = r;
		}

		if(max <= 25) {
			System.out.println(0);
		}else {
			System.out.println(max - 25);
		}
		sc.close();
	}
}

import java.util.*;
public class Solution
{
	static Scanner sc = new Scanner(System.in);
	public static int solve()
	{
		int n = sc.nextInt();
		int max = 0;
		for(int i=0;i<n;i++)
		{
			max = Math.max(max, sc.nextInt());
		}
		return (max <= 25) ? 0 : max-25;
	}

	public static void main(String args[])
	{
		System.out.println(solve());
	}
}

import java.io.*;
import java.util.Scanner;
public class Main {
    public static void main(String[] args) throws IOException {
        Scanner in = new Scanner(System.in);
        byte k = in.nextByte();
        int a = 0, max = Integer.MIN_VALUE;
        for (int i = 0; i < k; i++){
            a = in.nextInt();
            if (a > max) max = a;
        }
        System.out.println(max > 25 ? (max-25) : 0);
    }
}

import java.util.Scanner;

public class Solution {

	static Scanner sc=new Scanner(System.in);
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		int n=sc.nextInt();
		int a[]=new int[n];
		int max=0;
		int i=0;
		int temp=0;
		for(i=0;i<n;i++) {
			if((temp=sc.nextInt())>max){
				max=temp;
			};
		}
		max-=25;
		if(max<0) {
			System.out.print(0);
		}
		else {
			System.out.print(max);
		}
	}

}

import java.util.*;

public class Declined {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int k = sc.nextInt();
		int[] r = new int[k];
		for(int i = 0; i < k; i++) {
			r[i] = sc.nextInt();
		}
		Arrays.sort(r);
		System.out.println(r[k - 1] > 25 ? r[k - 1] - 25 : 0);
	}
}

import java.util.*;
public class JavaApplication7 {
 public static void main(String[] args) {
  Scanner obj = new Scanner(System.in);
  int size = obj.nextInt();
  int [] arr= new int [size];
  for(int i=0;i<size ; i++) arr[i]=obj.nextInt();
  Arrays.sort(arr);
  if (arr[size-1]>25)
  System.out.println(arr[size-1]-25);
  else
  System.out.println(0);
 }}

import java.io.*;
import java.util.*;
import java.math.*;
import static java.lang.System.out;

public class A
{
    public static void main(String[] args) throws IOException
    {
        //BufferedReader f = new BufferedReader(new FileReader("/Users/spencersharp/Desktop/input.txt"));

        BufferedReader f = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter writer = new PrintWriter(new BufferedOutputStream(System.out));

        String output = ""; //Write all output to this string

        //Code here
        StringTokenizer st;
        int numKnown = Integer.parseInt(f.readLine());
        st = new StringTokenizer(f.readLine());

        long max = -1;
        for(int i = 0; i < numKnown; i++)
        {
            max = Math.max(Long.parseLong(st.nextToken()),max);
        }

        if(max > 25)
            output = ""+(max-25);
        else
            output = ""+0;

        //Code here

        writer.println(output);

        //writer.println(output);
        writer.close();
        System.exit(0);

    }
}

import java.util.Scanner;

public class q2 {

	public static void main(String[] args) {

		Scanner in=new Scanner(System.in);
		int n,arr[];
		n=in.nextInt();
		arr=new int[n];
		for(int i=0;i<n;i++)
			arr[i]=in.nextInt();
		int max=findmax(arr);
		if(max<=25)
			System.out.println(0);
		else
		System.out.println(max-25);
	}

	private static int findmax(int[] arr) {
			int max=0;
			for (int i = 0; i < arr.length; i++) {
				if(arr[i]>max)
					max=arr[i];
			}
			return max;
	}
}

import java.util.Scanner;

public class Problem_A {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner s=new Scanner(System.in);
		int k=s.nextInt();
            int max=0;
             for(int i=0;i<k;i++)
                {
                  int n=s.nextInt();
                  max=Math.max(max, n);

                 }

           if(max<=25)
           {
        	   System.out.println("0");
           }
           else{
	System.out.println(max-25);
           }
           }
}

import java.io.*;
import java.util.*;

public class Main {

    static StringBuilder data = new StringBuilder();
    final static FastReader in = new FastReader();

    public static void main(String[] args) {
        int k = in.nextInt();
       int max=0;
        for (int i = 0; i < k; i++) {
            max=Math.max(max,in.nextInt());
        }
        System.out.println(Math.max(0,max-25));
    }

    static void fileOut(String s) {
        File out = new File("output.txt");
        try {
            FileWriter fw = new FileWriter(out);
            fw.write(s);
            fw.flush();
            fw.close();
        } catch (IOException e) {
            e.printStackTrace();
        }

    }

    static class FastReader {
        BufferedReader br;
        StringTokenizer st;

        public FastReader() {
            br = new BufferedReader(new
                    InputStreamReader(System.in));
        }

        public FastReader(String path) {
            try {
                br = new BufferedReader(new
                        InputStreamReader(new FileInputStream(path)));
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            }
        }

        String next() {
            while (st == null || !st.hasMoreElements()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }

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

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

        float nextFloat() {
            return Float.parseFloat(next());
        }

        double nextDouble() {
            return Double.parseDouble(next());
        }

        String nextLine() {
            String str = "";
            try {
                str = br.readLine();
            } catch (IOException e) {
                e.printStackTrace();
            }
            return str;
        }
    }

}

import java.util.Scanner;

public class DeclinedFinalists
{
    public static void main(String[] args)
    {
        Scanner scan = new Scanner(System.in);
        int num = scan.nextInt();
        int temp = 0;
        int max = 0;
        while (num != 0)
        {
            temp = scan.nextInt();
            if (temp > max)
            {
                max = temp;
            }
            num--;
        }
        int output = max - 25;
        if (output <= 0)
        {
            System.out.println(0);
        }
        else
        {
            System.out.println(output);
        }

    }
}

import java.io.*;

import java.util.*;

public class B

{

	public static void main(String[] args)

	{

		Scanner c= new Scanner(System.in);

		int K = c.nextInt();

		int max = 25;

		for(int i=0; i<K; i++) max = Math.max(max, c.nextInt());

		System.out.println(max-25);

		//31324
	}

}

import java.util.ArrayList;
import java.util.Collections;
import java.util.Scanner;

public class DeclinedFinalists {

	public static void main(String[] args) {
		Scanner s= new Scanner(System.in);
		int a= s.nextInt();
		int result=0;
		//int b= s.nextInt();
		s.nextLine();
		ArrayList<Integer> rankHolder=new ArrayList<Integer>();
		while(s.hasNextInt())
		{
				rankHolder.add(s.nextInt());
		}
		if(rankHolder.size()>0)
			result=Collections.max(rankHolder)-25>0 ?Collections.max(rankHolder)-25:0;
System.out.println(result);
	}
}

import java.util.ArrayList;
import java.util.Collections;
import java.util.Scanner;

/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */
/**
 *
 * @author anhnth37
 */
public class A_0859 {

    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        int k = input.nextInt();
        ArrayList<Integer> r = new ArrayList<>();
        for (int i = 0; i < k; i++) {
            r.add(input.nextInt());
        }

        Collections.sort(r);

        System.out.println(r.get(k - 1) - 25 > 0 ? r.get(k - 1) - 25 : 0);
    }
}

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner cin = new Scanner(System.in);
        int[] v;
        int n, maximum;

        n = cin.nextInt();
        maximum = -1;

        v = new int[n];
        for (int i = 0; i < n; ++i) {
            v[i] = cin.nextInt();
            if (v[i] > maximum)
                maximum = v[i];
        }

        if (maximum < 25)
            maximum = 25;

        System.out.println(maximum - 25);
    }
}

import java.util.Scanner;

public class DeclinedFinalists {

	public static void main(String args[]) {
		Scanner in = new Scanner(System.in);

		int n = in.nextInt();
		int[] ar= new int[n];
		int i;
		int l =-1;
		for(i=0;i<n;i++) {
			ar[i]=in.nextInt();
			if(l<ar[i])	l=ar[i];
		}

		if(l<=25)
		System.out.println(0);
		else
			System.out.println(l-25);

	}

}

import java.util.Scanner;

public class NewClass {
    public static long max(long ...x){
        long max= x[0];
        for (int i = 1; i < x.length; i++) {
            if (x[i]>max) {
                max=x[i];
            }
        }
        return max;
    }
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
         long[] a= new long[n];
        for (int i = 0; i < n; i++) {
            a[i]=sc.nextLong();
        }
        long m = max(a);
        if (m>25) {
            System.out.println(m-25);
        }
        else System.out.println(0);

    }
}

import java.util.Arrays;
import java.util.Scanner;

public class Finalist {

    private int n;
    private int  arr[];
    public Finalist()
    {
        Scanner sc= new Scanner(System.in);
        n=sc.nextInt();
arr= new int[n];
    for(int i=0;i<n;i++)
 arr[i]=sc.nextInt();
    Arrays.sort(arr);
    }

    public static void main(String[] args) {
        Finalist f = new Finalist();
        System.out.println(f.check());

    }

public int indexOf(int a)
{
    for(int i=0; i<n;i++)
      if(arr[i]==a) return i;
    return -1;

}
    public int check()
    {
        int s=0;
        for(int i=1;i<=arr[n-1];i++) {
            if (this.indexOf(i) == -1)
                s++;
        }
       if (s>25-n)return s-25+n;else return 0;

    }

}

import java.util.*;

public class DeclinedFinalists {

	public static void main(String[] args)
	{

		Scanner sc = new Scanner(System.in);

		int finalists = sc.nextInt();

		int max = -1;

		for(int i=0; i<finalists; i++)
		{
			int next = sc.nextInt();
			if(max < next)
			{
				max = next;
			}
		}
		int ans = max - 25;
		if(ans < 0)
		{
			ans = 0;
		}
		System.out.println(ans);

	}

}

import java.util.*;
import java.io.*;

public class DeclinedFinalists {
    public static void main(String[] arg) {
        Scanner scan = new Scanner(System.in);

        int K = scan.nextInt();

        int max = 0;

        for(int i=0; i<K; i++) {
            max = Math.max(max, scan.nextInt());
        }
        // System.out.println(max);

        if(max<=25) {
            System.out.println(0);
        }
        else{
            System.out.println(max - 25);
        }
    }
}

import java.util.Scanner;
public class Solution {

	public static void main(String[] args) {

		Scanner kbd = new Scanner(System.in);

		String input = kbd.nextLine();
		int numFinalist = Integer.parseInt(input);

		input = kbd.nextLine();
		Scanner scan = new Scanner(input);
		int num = Integer.parseInt(scan.next());
		boolean check = true;

		while (scan.hasNext()) {

			int nextNum = Integer.parseInt(scan.next());

			if (num <= nextNum) {

				num = nextNum;

			}

		}

		if (num >= 25) {

			System.out.println(num - 25);

		} else {

			System.out.println(0);

		}

	}

}

import java.io.DataInputStream;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;
import java.math.BigDecimal;
import java.math.BigInteger;

public class JavaApplication9 {

//***************************************************************************************
    static class Reader
    {
        final private int BUFFER_SIZE = 1 << 16;
        private DataInputStream din;
        private byte[] buffer;
        private int bufferPointer, bytesRead;

        public Reader()
        {
            din = new DataInputStream(System.in);
            buffer = new byte[BUFFER_SIZE];
            bufferPointer = bytesRead = 0;
        }

        public Reader(String file_name) throws IOException
        {
            din = new DataInputStream(new FileInputStream(file_name));
            buffer = new byte[BUFFER_SIZE];
            bufferPointer = bytesRead = 0;
        }

        public String readLine() throws IOException
        {
            byte[] buf = new byte[64]; // line length
            int cnt = 0, c;
            while ((c = read()) != -1)
            {
                if (c == '\n')
                    break;
                buf[cnt++] = (byte) c;
            }
            return new String(buf, 0, cnt);
        }

        public int nextInt() throws IOException
        {
            int ret = 0;
            byte c = read();
            while (c <= ' ')
                c = read();
            boolean neg = (c == '-');
            if (neg)
                c = read();
            do
            {
                ret = ret * 10 + c - '0';
            }  while ((c = read()) >= '0' && c <= '9');

            if (neg)
                return -ret;
            return ret;
        }

        public long nextLong() throws IOException
        {
            long ret = 0;
            byte c = read();
            while (c <= ' ')
                c = read();
            boolean neg = (c == '-');
            if (neg)
                c = read();
            do {
                ret = ret * 10 + c - '0';
            }
            while ((c = read()) >= '0' && c <= '9');
            if (neg)
                return -ret;
            return ret;
        }

        public double nextDouble() throws IOException
        {
            double ret = 0, div = 1;
            byte c = read();
            while (c <= ' ')
                c = read();
            boolean neg = (c == '-');
            if (neg)
                c = read();

            do {
                ret = ret * 10 + c - '0';
            }
            while ((c = read()) >= '0' && c <= '9');

            if (c == '.')
            {
                while ((c = read()) >= '0' && c <= '9')
                {
                    ret += (c - '0') / (div *= 10);
                }
            }

            if (neg)
                return -ret;
            return ret;
        }

        private void fillBuffer() throws IOException
        {
            bytesRead = din.read(buffer, bufferPointer = 0, BUFFER_SIZE);
            if (bytesRead == -1)
                buffer[0] = -1;
        }

        private byte read() throws IOException
        {
            if (bufferPointer == bytesRead)
                fillBuffer();
            return buffer[bufferPointer++];
        }

        public void close() throws IOException
        {
            if (din == null)
                return;
            din.close();
        }
    }
//****************************************************************************************
/*static boolean isp(long n)
{

   if(n==3||n==2)
   return true;
   if(n%2==0||n%3==0||n==1)
   return false;
   for(int i=5;i*i<=n;i=i+6)
   {
       if(n%i==0||n%(i+2)==0)
       return false;
   }
   return true;
}*/
//********************************************************
   /* static int factorial(int n)
    {
        if (n == 0)
          return 1;

        return n*factorial(n-1);
    } */
    /*  public int BinaryToDecimal(int binaryNumber){

    int decimal = 0;
    int p = 0;
    while(true){
      if(binaryNumber == 0){
        break;
      } else {
          int temp = binaryNumber%10;
          decimal += temp*Math.pow(2, p);
          binaryNumber = binaryNumber/10;
          p++;
       }
    }
    return decimal;
   }*/

/*-**********************  Start   *********************************-*/

public static void main(String[] args) throws IOException{
//-----------------------  Input   ---------------------------------------//

Reader st=new Reader();
Scanner in=new Scanner(System.in);
//HashMap dp = new HashMap();

Vector <Integer>v=new Vector(0,1);

int n=in.nextInt(),j;

for(int i=0;i<n;i++)
{

    v.add(in.nextInt());
}
Collections.sort(v);
 j=v.get(n-1);

 if(j>=25)
 System.out.print(j-25);
 else
     System.out.print(0);
}}

import java.io.*;
import java.util.StringTokenizer;

public class Codeforces_MemSQL_round_1_DeclinedFinalists {

    public static void main(String[] args) {
        FScanner input = new FScanner();
        out = new PrintWriter(new BufferedOutputStream(System.out), true);
        int n = input.nextInt();
        int max = -1;
        for (int i = 0; i < n; i++) {
            max = Math.max(max, input.nextInt());
        }
        out.println(Math.max(0, max - 25));
        out.close();
    }

    public static PrintWriter out;

    public static class FScanner {
        BufferedReader br;
        StringTokenizer st;

        public FScanner() {
            br = new BufferedReader(new InputStreamReader(System.in));
        }

        private String next() {
            while (st == null || !st.hasMoreElements()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }

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

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

        public double nextDouble() {
            return Double.parseDouble(next());
        }

        public String nextLine() {
            String str = "";
            try {
                str = br.readLine();
            } catch (IOException e) {
                e.printStackTrace();
            }
            return str;
        }

    }
}

/**
 * 859 A. Declined Finalists
 */

import java.util.Scanner;

public class Declined{
	public static void main(String[] args) {
		Scanner input = new Scanner(System.in);

		int a, b, max = 0;
		a = input.nextInt();
		for(int i = 0; i < a; i++) {
			b = input.nextInt();
			if(b > max) {
				max = b;
			}
		}
		if(max < 26) {
			System.out.println("0");
		} else {
			System.out.println(max - 25);
		}
	}
}

import java.util.ArrayList;
import java.util.Collections;
import java.util.Scanner;

public class DeclinedFinalists_859A {
	public static void main(String[] args) {
		Scanner input = new Scanner(System.in);
		int k = input.nextInt();
		ArrayList<Integer> arr = new ArrayList<Integer>();
		for (int i = 0; i < k; i++) {
			arr.add(input.nextInt());
		}
		System.out.println(Math.max(0, Collections.max(arr) - 25));
		input.close();
	}
}

import java.util.Scanner;

public class TestClass {
    public static void main(String args[]) {
        Scanner in = new Scanner(System.in);
        int K=in.nextInt();
        int j=0;
        int[] m=new int[K];
        int[] r=new int[K];
        for(int i=0; i<K; i++)
        {
               r[i]=in.nextInt();

        }
        int maxIndex = 0;
        for (int i = 0; i < r.length; i++) {
            if (r[maxIndex] < r[i]) {
                maxIndex = i;
            }
        }

   if(r[maxIndex]>25)
   { System.out.println(r[maxIndex]-25);}
   else
   {System.out.println(0);}

    }
}

import java.util.Scanner;

public class Main {
	public static void main(String[] args) {
		Scanner input = new Scanner(System.in);
		int number = input.nextInt();
		int ans = 0;

		for (int i = number; i > 0; i--) {
			int x = input.nextInt();
			ans = Math.max(ans, x);

		}
		if (ans < 25) {
			System.out.println(0);
		} else {
			System.out.println(ans - 25);
		}
	}
}

import java.util.Scanner;

public class Declined{
	public static void main(String[] args) {
		Scanner input = new Scanner(System.in);
		int a, b, max = 0;
		a = input.nextInt();
		for(int i = 0; i < a; i++) {
			b = input.nextInt();
			if(b > max) {
				max = b;
			}
		}
		if(max < 26) {
			System.out.println("0");
		} else {
			System.out.println(max - 25);
		}
	}
}

import java.util.*;
public class declined_finalist {
	public static void main(String args[]) {
		Scanner in = new Scanner(System.in);
		int n,i;
		n=in.nextInt();
		int a[]=new int[n];
		for(i=0;i<n;i++)
		{
			a[i]=in.nextInt();
		}
		int max=0;
		for(i=0;i<n;i++)
		{
			if(max<a[i])
				max=a[i];
		}
		if(max>25)
		{
			System.out.println((max-25));
		}
		else
			System.out.println(0);
	}
}

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner cin = new Scanner(System.in);
        int[] v;
        int n, maximum;

        n = cin.nextInt();
        maximum = -1;

        v = new int[n];
        for (int i = 0; i < n; ++i) {
            v[i] = cin.nextInt();
            if (v[i] > maximum)
                maximum = v[i];
        }

        if (maximum < 25)
            maximum = 25;

        System.out.println(maximum - 25);
    }
}

import java.util.*;

public class Main {

	public static void main(String[] args) {
       		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();
		int a[] = new int[n];
		for(int i=0;i<n;i++) {
			a[i] = sc.nextInt();
		}
		Arrays.sort(a);
		if(a[n-1]<=25) {
			System.out.println("0");
		}
		else {
			System.out.println(a[n-1]-25);
		}

}}

import java.io.*;
import java.util.*;

public class PalindromicSupersequence
{
	public static void main(String[] args) throws IOException
	{
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		StringTokenizer st = new StringTokenizer(br.readLine());

		int hrank = 0;
		int n = Integer.parseInt(st.nextToken());
		st = new StringTokenizer(br.readLine());
		for(int j=0; j<n; j++)
		{
		      int rank = Integer.parseInt(st.nextToken());
		      if(rank > hrank) hrank = rank;
		}
		if(hrank >= 25) System.out.println(hrank - 25);
            else System.out.println(0);
	}
}

import java.util.*;
public class DeclinedFinalists {

	public static void main(String[] args) {
		Scanner sc=new Scanner(System.in);
		int n=sc.nextInt();
		int arr[]=new int[n];
		for(int i=0;i<n;i++) {
			arr[i]=sc.nextInt();
		}
		Arrays.parallelSort(arr);
		if(arr[n-1]<=25) {
		System.out.println(0);
		}
		else {
			System.out.println(arr[n-1]-25);
		}

	}

}

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.Arrays;

public class A {
	public static void main(String[] args) {
		String s = "";
		try {
			InputStreamReader converter = new InputStreamReader(System.in);
			BufferedReader in = new BufferedReader(converter);
			int K = Integer.parseInt(in.readLine());
			String[] r = in.readLine().split(" ");
			Integer[] numbers = new Integer[K];
			for (int i = 0; i < r.length; i++) {
				numbers[i] = Integer.parseInt(r[i]);
			}
			Arrays.sort(numbers);
			if (numbers[numbers.length - 1] > 25) {
				System.out.println(numbers[numbers.length - 1] - 25);
			} else {
				System.out.println(0);
			}
		} catch (Exception e) {
			System.out.println("Error! Exception: " + e);
		}
	}
}

import java.util.*;

public class Main {
    private static Scanner scanner = new Scanner(System.in);
    public static void main(String[] args) {

        int n = scanner.nextInt();
        int m = Integer.MIN_VALUE;
        for (int i = 0; i < n; ++i) {
            m = Math.max(m, scanner.nextInt());
        }
        if(m < 25) {
            System.out.println(0);
        } else {
            System.out.println(m-25);
        }

    }
}

import java.util.*;

public class DeclinedFinalists {

    public static void main (String args[]){
        int k, mx =-1;
        Scanner in = new Scanner(System.in);
        k = in.nextInt();
        for(int i =0;i< k ;i++){
            mx = Math.max(mx, in.nextInt());
        }
        System.out.println((mx-25 > 0 )?mx-25:0 );

    }
}

import java.util.Scanner;

public class q2 {

	public static void main(String[] args) {

		Scanner in=new Scanner(System.in);
		int n,arr[];
		n=in.nextInt();
		arr=new int[n];
		for(int i=0;i<n;i++)
			arr[i]=in.nextInt();
		int max=findmax(arr);
		if(max<=25)
			System.out.println(0);
		else
		System.out.println(max-25);
	}

	private static int findmax(int[] arr) {
			int max=0;
			for (int i = 0; i < arr.length; i++) {
				if(arr[i]>max)
					max=arr[i];
			}
			return max;
	}
}

import java.io.* ;
import java.util.*;

public class declinedFinalists {
    public static void main (String[] args) {

        Scanner scan = new Scanner(System.in);
        int k = scan.nextInt();
        int[] ranks = new int[k];

        for (int i=0; i<k; i++) {
            ranks[i]=scan.nextInt();
        }
        Arrays.sort(ranks);
        int declined = 0;
        if (ranks[k-1]>25) {
            declined = ranks[k-1] - 25;
        }
        System.out.println(declined);
    }
}

import java.util.Scanner;

public class Main {
   public static void main(String[] args) {
       Scanner scanner = new Scanner(System.in);
       int K = scanner.nextInt();
       int maxRank = 25;
       for (int i = 1; i <= K; i++) {
           int ri = scanner.nextInt();
           if (ri > maxRank)
               maxRank = ri;
       }
       int result = maxRank - 25;
       System.out.println(result);
   }
}

import java.io.*;
import java.text.*;
import java.util.*;
import java.math.*;
public class A {
	public static void main(String[] args) throws Exception {
		new A().run();
	}
	public void run() throws Exception {
		FastScanner f = new FastScanner();
		PrintWriter out = new PrintWriter(System.out);
		int a = f.nextInt();
		String[] s = f.reader.readLine().split(" ");
		int max = Integer.parseInt(s[0]);
		for(int i = 1; i < s.length; i++)
		{
			if(Integer.parseInt(s[i]) > max) max = Integer.parseInt(s[i]);
		}
		if(max > 25)
		{
			out.println(max-25);
		} else out.println(0);
		out.flush();
	}

    static class FastScanner {
        public BufferedReader reader;
        public StringTokenizer tokenizer;

        public FastScanner() {
            reader = new BufferedReader(new InputStreamReader(System.in), 32768);
            tokenizer = null;
        }

        public String next() {
            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
                try {
                    tokenizer = new StringTokenizer(reader.readLine());
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            return tokenizer.nextToken();
        }
        public int nextInt() {
            return Integer.parseInt(next());
        }
        public long nextLong() {
        	return Long.parseLong(next());
        }
        public double nextDouble() {
        	return Double.parseDouble(next());
        }

    }
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.*;
import java.util.stream.Collectors;

public class Main {
    private static IO io = new IO();

    public static void main(String[] args) throws Exception {
        int k = io.getInt(), max = 25, cnt = 0;
        int[] arr = new int[1000002];
        for(int i = 0 ; i < k ; i++){
            int cur = io.getInt();
            arr[cur] = 1;
            max = Math.max(max, cur);
        }
        k = 25 - k;
        for(int i = 1 ; i <= max && k != 0 ; i++){
            if(arr[i] == 0){
                arr[i] = 1;
                k--;
            }
        }
        for(int i = 1; i <= max ; i++){
            if(arr[i] == 0)
                cnt++;
        }
        System.out.println(cnt);
    }
}

class IO {
    private BufferedReader br = null;
    private StringTokenizer st = null;

    public IO() {
        this(System.in);
    }

    public IO(InputStream is) {
        this.br = new BufferedReader(new InputStreamReader(is));
    }

    public List<String> getStringArray(int n) throws IOException {
        if (n == 0)
            return new ArrayList<>();
        if (st == null || !st.hasMoreTokens())
            st = new StringTokenizer(br.readLine());
        List<String> res = new ArrayList<>();
        for (int i = 0; i < n; i++) {
            if (!st.hasMoreTokens())
                st = new StringTokenizer(br.readLine());
            res.add(st.nextToken());
        }
        return res;
    }

    public String getString() throws IOException {
        List<String> res = this.getStringArray(1);
        return res.size() == 0 ? "" : res.get(0);
    }

    public List<Integer> getIntegerArray(int n) throws IOException {
        if (n == 0)
            return new ArrayList<>();
        List<String> res = getStringArray(n);
        return res.stream().map(Integer::parseInt).collect(Collectors.toList());
    }

    public Integer getInt() throws IOException {
        List<Integer> res = this.getIntegerArray(1);
        return res.size() == 0 ? 0 : res.get(0);
    }

    public List<Long> getLongArray(int n) throws IOException {
        if (n == 0)
            return new ArrayList<>();
        List<String> res = getStringArray(n);
        return res.stream().map(Long::parseLong).collect(Collectors.toList());
    }

    public Long getLong() throws IOException {
        List<Long> res = this.getLongArray(1);
        return res.size() == 0 ? 0L : res.get(0);
    }

    public List<Double> getDoubleArray(int n) throws IOException {
        if (n == 0)
            return new ArrayList<>();
        List<String> res = getStringArray(n);
        return res.stream().map(Double::parseDouble).collect(Collectors.toList());
    }

    public Double getDouble() throws IOException {
        List<Double> res = this.getDoubleArray(1);
        return res.size() == 0 ? 0.0 : res.get(0);
    }
}

class Utils {
    static int[][] fourDirs = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}};
    static int[][] eightDirs = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}, {1, 1}, {1, -1}, {-1, 1}, {-1, -1}};

    static int modAdd(int a, int b) {
        return (int) ((a + (long) b) % 1000000007);
    }

    static int modSub(int a, int b) {
        return (int) ((a - (long) b + 1000000007) % 1000000007);
    }

    public static List<Integer> sieve(int n) {
        boolean b[] = new boolean[n + 1];
        List<Integer> ans = new ArrayList<>();
        Arrays.fill(b, true);

        for (int i = 2; i <= n; i++) {
            if (b[i]) {
                ans.add(i);
                for (int j = i * i; j >= 0 && j <= n; j += i) {
                    b[j] = false;
                }
            }
        }
        return ans;
    }

    public static boolean isPrime(long n) {
        long sqrt = (long) Math.sqrt(n);
        for (int i = 2; i <= sqrt; i++) {
            if (n % i == 0)
                return false;
        }
        return true;
    }

    public static long mod(long n) {
        if (n > 0)
            return n % 1000000007;
        return (n + 2000000014) % 1000000007;
    }

    public static boolean isSqr(long n) {
        int sqrt = (int) Math.sqrt(n);
        return n == (long) sqrt * sqrt;
    }

    public static boolean inRange(long i, long l, long h) {
        return i >= l && i <= h;
    }

    public static boolean isValid(int i, int j, int n, int m) {
        return i >= 0 && j >= 0 && i < n && j < m;
    }

    public static void swap(List<Integer> ls, int i, int j) {
        int temp = ls.get(i);
        ls.set(i, ls.get(j));
        ls.set(j, temp);
    }

    public static long gcd(long a, long b) {
        if (a < b)
            return gcd(b, a);
        else if (a == b || b == 0)
            return a;
        else {
            return gcd(b, a % b);
        }
    }

    public static long subSum(long[] pre, int l, int h) {
        return l == 0 ? pre[h] : pre[h] - pre[l - 1];
    }

    public static void ifPrint(boolean test, Object ifValue, Object elseValue) {
        System.out.println(test ? ifValue : elseValue);
    }

    public static void print(Character delim, Object... a) {
        List<String> top = new ArrayList<>();
        for (Object aa : a)
            top.add(aa == null ? "null" : aa.toString());
        System.out.println(join(top, delim.toString()));
    }

    public static void print(Object... a) {
        print(' ', a);
    }

    public static <T extends Comparable<T>> int lowerBound(T[] arr, int l, int h, T key) {
        while (l < h) {
            int mid = (l + h) / 2;
            if (arr[mid].compareTo(key) < 0)
                l = mid + 1;
            else
                h = mid;
        }
        return arr[l].compareTo(key) >= 0 ? l : -1;
    }

    public static <T extends Comparable<T>> int upperBound(T[] arr, int l, int h, T key) {
        while (l < h) {
            int mid = (l + h) / 2;
            if (arr[mid].compareTo(key) < 0)
                l = mid + 1;
            else if (arr[mid].compareTo(key) == 0)
                l = mid;
            else
                h = mid;
            if (h == l + 1)
                break;
        }
        return arr[l].compareTo(key) >= 0 ? l : -1;
    }

    public static <T> String join(List<T> ls) {
        return join(ls, " ");
    }

    public static <T> String join(List<T> ls, String delim) {
        StringJoiner sj = new StringJoiner(delim);
        for (T a : ls)
            sj.add(a.toString());
        return sj.toString();
    }

    public static <T> void print2DArray(List<List<T>> mat) {
        for (List<T> m : mat) {
            System.out.println("{ " + join(m, ", ") + " }");
        }
    }

    public static <T> void reverseArrray(T[] arr, int l, int h) {
        while (l < h) {
            T temp = arr[l];
            arr[l] = arr[h];
            arr[h] = temp;
            l++;
            h--;
        }
    }
}

import java.io.*;
import java.util.*;

public class Solution {

    public static void main(String[] args) {
 Scanner snr = new Scanner(System.in);
		int n = snr.nextInt();
		ArrayList<Integer> p = new ArrayList<>();
		for(int i=0; i<n; i++) {
		p.add(snr.nextInt());
		}
		System.out.println(out(n,p));
    }
	public static int out(int n, ArrayList<Integer> a) {
		Collections.sort(a);
		int sum=0;
		for(int i=0; i<a.size(); i++) {
			if(a.get(i)<=25) {
				sum=0;
			}
			else{
				sum=a.get(n-1)-25;
			}
		}
		return sum;
	}
}

/**
 * 859 A. Declined Finalists
 */

import java.util.Scanner;

public class Declined{
	public static void main(String[] args) {
		Scanner input = new Scanner(System.in);

		int a, b, max = 0;
		a = input.nextInt();
		for(int i = 0; i < a; i++) {
			b = input.nextInt();
			if(b > max) {
				max = b;
			}
		}
		if(max < 26) {
			System.out.println("0");
		} else {
			System.out.println(max - 25);
		}
	}
}

import java.util.*;
import java.io.*;

 public class Param
{

      public static  void main( String[]args)
    {
    Scanner param = new Scanner(System.in);
    int n=param.nextInt();
   int []arr=new int[n];
   for(int i=0;i<arr.length;i++){
      arr[i]=param.nextInt();
   }
   Arrays.sort(arr);
   int sum=arr[n-1]-25;
   if(sum<=0){
      System.out.println(0);
   }
   else{
      System.out.println(sum);
   }

}
}

import java.util.*;
import java.io.*;

public class DeclinedFinalists {
    public static void main(String[] arg) {
        Scanner scan = new Scanner(System.in);

        int K = scan.nextInt();

        int max = 0;

        for(int i=0; i<K; i++) {
            max = Math.max(max, scan.nextInt());
        }
        // System.out.println(max);

        if(max<=25) {
            System.out.println(0);
        }
        else{
            System.out.println(max - 25);
        }
    }
}

import java.util.Scanner;

public class A859 {
    public static void main(String q[]){
        Scanner sc=new Scanner(System.in);
        int n=sc.nextInt();
        int ar[]=new int[n];
        int mx=-999;
        for (int i=0;i<n;i++){
            ar[i]=sc.nextInt();
            if(mx<ar[i])
                mx=ar[i];
        }
        if(mx<=25)
            System.out.println(0);
        else
            System.out.println(mx-25);
    }
}

import java.util.*;
import java.io.*;

public class A {
	FastScanner in;
	PrintWriter out;
	boolean systemIO = true;

	public static void quickSort(int[] a, int from, int to) {
		if (to - from <= 1) {
			return;
		}
		int i = from;
		int j = to - 1;
		int x = a[from + (new Random()).nextInt(to - from)];
		while (i <= j) {
			while (a[i] < x) {
				i++;
			}
			while (a[j] > x) {
				j--;
			}
			if (i <= j) {
				int t = a[i];
				a[i] = a[j];
				a[j] = t;
				i++;
				j--;
			}
		}
		quickSort(a, from, j + 1);
		quickSort(a, j + 1, to);
	}

	public void solve() {
		int n = in.nextInt();
		int x = 0;
		for (int i = 0; i < n; i++) {
			x = Math.max(x, in.nextInt());
		}
		out.print(Math.max(0, x - 25));
	}

	public void run() {

		try {
			if (systemIO) {
				in = new FastScanner(System.in);
				out = new PrintWriter(System.out);
			} else {
				in = new FastScanner(new File("input.txt"));
				out = new PrintWriter(new File("output.txt"));
			}
			solve();

			out.close();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

	class FastScanner {
		BufferedReader br;
		StringTokenizer st;

		FastScanner(File f) {
			try {
				br = new BufferedReader(new FileReader(f));
			} catch (FileNotFoundException e) {
				e.printStackTrace();
			}
		}

		FastScanner(InputStream f) {
			br = new BufferedReader(new InputStreamReader(f));
		}

		String nextLine() {
			try {
				return br.readLine();
			} catch (IOException e) {
				return null;
			}
		}

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

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

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

		double nextDouble() {
			return Double.parseDouble(next());
		}

	}

	// AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
	public static void main(String[] args) {
		new A().run();
	}
}

import java.util.*;
public class abcd
{
    public static void main(String args[])
    {
        Scanner sc = new Scanner(System.in);
         int n= sc.nextInt();
         int arr[]=new int[n];
         int count = 0;
         for(int i = 0;i<n;i++)
         arr[i]=sc.nextInt();
         Arrays.sort(arr);
         for(int i = 0 ;i<n;i++)
         {
             if(arr[i]<26)
             ++count;
         }
         if(count==n)
         System.out.println(0);
         else
         {
             System.out.println(arr[n-1]-25);
         }

    }
}

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        int x = 25;
        for (int i = input.nextInt(); i > 0; i--) {
            int t = input.nextInt();
            if (x < t) {
                x = t;
            }
        }
        System.out.println(x - 25);
    }
}

import java.util.Scanner;

public class Main {
	public static void main(String[] args) {
		Scanner input = new Scanner(System.in);
		int number = input.nextInt();
		int ans = 0;

		for (int i = number; i > 0; i--) {
			int x = input.nextInt();
			ans = Math.max(ans, x);

		}
		if (ans < 25) {
			System.out.println(0);
		} else {
			System.out.println(ans - 25);
		}
	}
}

// hello
// hi

import java.util.Scanner;

public class Declined{
	public static void main(String[] args) {
		Scanner input = new Scanner(System.in);
		int a, b, max = 0;
		a = input.nextInt();
		for(int i = 0; i < a; i++) {
			b = input.nextInt();
			if(b > max) {
				max = b;
			}
		}
		if(max < 26) {
			System.out.println("0");
		} else {
			System.out.println(max - 25);
		}
	}
}

import java.io.*;
import java.util.*;
public class DeclinedFinalists {

	public static void main(String[] args) throws IOException{
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		int num = Integer.parseInt(br.readLine());
		StringTokenizer st = new StringTokenizer(br.readLine());
		ArrayList<Integer> list = new ArrayList<Integer>();
		for(int i = 0; i < num; i++) {
			list.add(Integer.parseInt(st.nextToken()));
		}
		Collections.sort(list);
		int diff = list.get(num-1) - 25;
		if(diff > 0) {
			System.out.println(diff);
		}else System.out.println(0);
	}

}

import java.util.Scanner;

public class Problem_A {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner s=new Scanner(System.in);
		int k=s.nextInt();
            int max=0;
             for(int i=0;i<k;i++)
                {
                  int n=s.nextInt();
                  max=Math.max(max, n);

                 }

           if(max<=25)
           {
        	   System.out.println("0");
           }
           else{
	System.out.println(max-25);
           }
           }
}

import java.util.Scanner;

public class DeclinedFinalists {
    private static Scanner reader = new Scanner(System.in);

    public static void main (String[] args){
        int k ;
        int max = Integer.MIN_VALUE;
        k = reader.nextInt();

        for (int i = 0 ; i < k ; ++i)
            max = Integer.max(max, reader.nextInt());

        if (max <= 25)
            System.out.println("0");
        else
            System.out.println(max - 25 );
    }
}

import java.util.*;

public class DeclinedFinalists {
	public static void main(String[] args) {
		Scanner in = new Scanner(System.in);
		int K = Integer.parseInt(in.nextLine());
		int[] ranks = new int[K];
		for (int i = 0; i < ranks.length; i++) {
			ranks[i] = in.nextInt();
		}

		Arrays.sort(ranks);
		int numDeclines = ranks[ranks.length - 1] - 25;
		if (numDeclines <= 0) {
			System.out.println(0);
		}
		else {
			System.out.println(numDeclines);
		}
	}
}

import java.util.*;

public class Main {

	public static void main(String[] args) {

		Scanner sc = new Scanner(System.in);

		int contestants = sc.nextInt();
		int[] attended = new int[contestants];
		int high = 0;

		for(int i =0; i< contestants; i++) {
			attended[i] = sc.nextInt();

			if(attended[i] > 25 && attended[i] > high)
				high = attended[i];

		}
		if(high != 0)
			System.out.println(high -25);
		else
			System.out.println(high);

		sc.close();

	}

}

import java.util.*;

public class Main {
    private static Scanner scanner = new Scanner(System.in);
    public static void main(String[] args) {

        int n = scanner.nextInt();
        int m = Integer.MIN_VALUE;
        for (int i = 0; i < n; ++i) {
            m = Math.max(m, scanner.nextInt());
        }
        if(m < 25) {
            System.out.println(0);
        } else {
            System.out.println(m-25);
        }

    }
}

import java.util.*;
public class JavaApplication7 {
 public static void main(String[] args) {
  Scanner obj = new Scanner(System.in);
  int size = obj.nextInt();
  int [] arr= new int [size];
  for(int i=0;i<size ; i++) arr[i]=obj.nextInt();
  Arrays.sort(arr);
  if (arr[size-1]>25)
  System.out.println(arr[size-1]-25);
  else
  System.out.println(0);
 }}

/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */

//import com.sun.xml.internal.ws.util.StringUtils;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.lang.reflect.Array;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Scanner;
import java.util.Set;
import java.util.Vector;
import java.util.regex.Pattern;
import java.util.stream.Collectors;

/**
 *
 * @author george
 */

public class main {
    /*
public static boolean isPrime(long n) {
    if(n < 2) return false;
    if(n == 2 || n == 3) return true;
    if(n%2 == 0 || n%3 == 0) return false;
    long sqrtN = (long)Math.sqrt(n)+1;
    for(long i = 6L; i <= sqrtN; i += 6) {
        if(n%(i-1) == 0 || n%(i+1) == 0) return false;
    }
    return true;
}*/
/*
    private static long f(long l) {
        throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
    }

public static boolean contains(final int[] arr, final int key) {
    return Arrays.stream(arr).anyMatch(i -> i == key);
}
 static boolean isSubSequence(String str1, String str2, int m, int n)
    {

        if (m == 0)
            return true;
        if (n == 0)
            return false;

        if (str1.charAt(m-1) == str2.charAt(n-1))
            return isSubSequence(str1, str2, m-1, n-1);

        return isSubSequence(str1, str2, m, n-1);
    }

    static int gcdThing(int a, int b) {
    BigInteger b1 = BigInteger.valueOf(a);
    BigInteger b2 = BigInteger.valueOf(b);
    BigInteger gcd = b1.gcd(b2);
    return gcd.intValue();
}
    public static boolean checkAnagram(String str1, String str2) {
        int i=0;
        for (char c : str1.toCharArray()) {
        i = str2.indexOf(c, i) + 1;
        if (i <= 0) { return false; }
    }
    return true;

}
   */
    public static Set primeFactors(int num)
    {
        Set<Integer>Prime=new HashSet<Integer>();
        // Print the number of 2s that divide n
        int tw=2;
        while (num%2==0)
        {
            Prime.add(tw);
            num /= 2;
        }

        // n must be odd at this point.  So we can
        // skip one element (Note i = i +2)
        for (int i = 3; i <= Math.sqrt(num); i+= 2)
        {
            // While i divides n, print i and divide n
            while (num%i == 0)
            {
                Prime.add(i);
                num/= i;
            }
        }

        // This condition is to handle the case whien
        // n is a prime number greater than 2
        if (num> 2)
            Prime.add(num);
        return Prime;
    }
    /*
    public static String Winner(int [] arr)
    {
        int maxsum=-1;
        int temp=0;
        List<Integer> L=Arrays.stream(arr).boxed().collect(Collectors.toList());
        int count=0;
        String winner="First";
        while(L.isEmpty()!=true){
           if(count%2==0){winner="First";
           //take max odd interval
            for (int i = 0; i < L.size(); i++) {

            }
            }
           else{winner="Second";

           }
           count++;
        }

    return winner;
    }
    public static String changeCharInPosition(int position, char ch, String str){
    char[] charArray = str.toCharArray();
    charArray[position] = ch;
    return new String(charArray);
    }
    public static boolean CheckCanObtainYfromX(String y,String x){
        boolean cond=true;
        String help="";
        for (int i = 0; i < y.length(); i++) {
            help="";help+=y.charAt(i);
            if(y.contains(help)==false){x=x.replaceFirst(help,"A");cond=false;break;}

        }
        return cond;
    }
   public static int LongestPalindrome(String x){
    int n=x.length();
    boolean table[][] = new boolean[n][n];
    int maxLength = 1;
     for (int i = 0; i < n; ++i)
            table[i][i] = true;
   int start = 0;
    for (int i = 0; i < n - 1; ++i) {
            if (x.charAt(i) == x.charAt(i + 1)) {
                table[i][i + 1] = true;
                start = i;
                maxLength = 2;
            }
        }
     for (int k = 3; k <= n; ++k) {
            for (int i = 0; i < n - k + 1; ++i)
            {
                int j = i + k - 1;
               if (table[i + 1][j - 1] && x.charAt(i) == x.charAt(j)) {
                    table[i][j] = true;
                if (k > maxLength) {
                        start = i;
                        maxLength = k;
                    }
                }
            }
     }
   return maxLength;
   }
   public static long choose(long total, long choose){
    if(total < choose)
        return 0;
    if(choose == 0 || choose == total)
        return 1;
    return choose(total-1,choose-1)+choose(total-1,choose);
}
    public static long bitwiseAdd(int n1, int n2) {
        int x = n1, y = n2;
        int xor, and, temp;
        and = x & y;
        xor = x ^ y;

        while (and != 0) {
            and <<= 1;
            temp = xor ^ and;
            and &= xor;
            xor = temp;
        }
        return (xor%2);
    }
    public static boolean compare(String a,String b){
        for (int i = 0; i < a.length(); i++) {
            if(a.charAt(i)!=b.charAt(i)&&a.charAt(i)!='?'){return false;}
        }
  return true;
    }*/
/*public static boolean isUniqueChars(String str) {
    // short circuit - supposed to imply that
    // there are no more than 256 different characters.
    // this is broken, because in Java, char's are Unicode,
    // and 2-byte values so there are 32768 values
    // (or so - technically not all 32768 are valid chars)
    if (str.length() > 256) {
        return false;
    }
    // checker is used as a bitmap to indicate which characters
    // have been seen already
    int checker = 0;
    for (int i = 0; i < str.length(); i++) {
        // set val to be the difference between the char at i and 'a'
        // unicode 'a' is 97
        // if you have an upper-case letter e.g. 'A' you will get a
        // negative 'val' which is illegal
        int val = str.charAt(i) - 'a';
        // if this lowercase letter has been seen before, then
        // the corresponding bit in checker will have been set and
        // we can exit immediately.
        if ((checker & (1 << val)) > 0) return false;
        // set the bit to indicate we have now seen the letter.
        checker |= (1 << val);
    }
    // none of the characters has been seen more than once.
    return true;
}*/
 /*private static int [] PossibilitiesAsBinaryTruthTable(int n) {
        int rows = (int) Math.pow(2,n);
        int [] possibleTrack=new int[rows];
        int trackPerRow;
        for (int i=0; i<rows; i++) {
            trackPerRow=0;
            for (int j=n-1; j>=0; j--) {
                if(((i/(int) Math.pow(2, j))%2)==0){trackPerRow--;}
                else if(((i/(int) Math.pow(2, j))%2)==1){trackPerRow++;}
            }
            possibleTrack[i]=trackPerRow;
        }
        return possibleTrack;
    }
    //Steins GCD Algo
     public static long gcd(long u, long v)
    {
        long shift;
        if (u == 0)
            return v;
        if (v == 0)
            return u;
        for (shift = 0; ((u | v) & 1) == 0; ++shift)
        {
            u >>= 1;
            v >>= 1;
        }
        while ((u & 1) == 0)
            u >>= 1;
        do
        {
            while ((v & 1) == 0)
                v >>= 1;

            if (u > v)
            {
                long t = v;
                v = u;
                u = t;
            }
            v = v - u;
        } while (v != 0);

        return u << shift;
    }
     public static long gcd(long p, long q) {
        if (q == 0) return p;
        else return gcd(q, p % q);
    }*/
    public static void main (String []  args) throws IOException
    {
        Scanner s=new Scanner(System.in);
        BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
        PrintWriter pw=new PrintWriter(new OutputStreamWriter(System.out));
        int k=Integer.parseInt(br.readLine());
        String line=br.readLine();
        String [] nums=line.split(" ");
        int [] numsarr=new int[nums.length];
        for (int i = 0; i <nums.length ; i++) {
            numsarr[i]=Integer.parseInt(nums[i]);
        }
        int max;
        Arrays.sort(numsarr);
        max=numsarr[k-1];
        if(max>25){System.out.print(max-25);}
        else{System.out.print(0);}
    }
}

import java.util.Scanner;

public class Problem0859a {
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        int K = sc.nextInt();
        int max = 0;
        for(int i = 0; i < K; i++){
            max = Math.max(max, sc.nextInt());
        }
        System.out.println(Math.max(0, max-25));
    }
}

import java.util.Scanner;

public class Contestents {

    public static void main(String[] args){
        Scanner scan = new Scanner(System.in);
        scan.nextLine();
        String[] contestents = scan.nextLine().split(" ");
        int largest = -1;
        for(String contestent : contestents) {
            if(Integer.valueOf(contestent) > largest) {
                largest = Integer.valueOf(contestent);
            }
        }
        System.out.println(largest-25 >= 0 ? largest-25 : 0);
    }

}

import java.util.*;
public class declined_finalist {
	public static void main(String args[]) {
		Scanner in = new Scanner(System.in);
		int n,i;
		n=in.nextInt();
		int a[]=new int[n];
		for(i=0;i<n;i++)
		{
			a[i]=in.nextInt();
		}
		int max=0;
		for(i=0;i<n;i++)
		{
			if(max<a[i])
				max=a[i];
		}
		if(max>25)
		{
			System.out.println((max-25));
		}
		else
			System.out.println(0);
	}
}

import java.util.*;

public class DeclinedFinalists{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        int K = sc.nextInt();
        TreeSet<Integer> ts = new TreeSet();
        for(int k = 0; k < K; k++){
            ts.add(sc.nextInt());
        }
        int res;
        System.out.println(ts.last() < 25? 0: ts.last() - 25);
    }
}

import java.util.Arrays;
import java.util.Scanner;

public class DeclinedFinalists {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        int n = scan.nextInt();
        int[] arr = new int[n];
        for (int i = 0; i < arr.length; i++) {
            arr[i] = scan.nextInt();
        }
        Arrays.sort(arr);
        if (arr[arr.length - 1] <= 25) {
            System.out.println(0);
        } else {
            System.out.println(arr[arr.length - 1] - 25);
        }

    }
}

import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.StringTokenizer;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        Scanner in = new Scanner(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        TaskA solver = new TaskA();
        solver.solve(1, in, out);
        out.close();
    }

    static class TaskA {
        public void solve(int testNumber, Scanner sc, PrintWriter out) {
            int n = sc.nextInt();
            int max = 0;
            for (int i = 0; i < n; i++)
                max = Math.max(max, Math.max(0, sc.nextInt() - 25));
            out.println(max);
        }

    }

    static class Scanner {
        StringTokenizer st;
        BufferedReader br;

        public Scanner(InputStream s) {
            br = new BufferedReader(new InputStreamReader(s));
        }

        public String next() {
            while (st == null || !st.hasMoreTokens()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (Exception e) {
                }
                ;
            }
            return st.nextToken();
        }

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

    }
}

import java.util.*;

public class DeclinedFinalists {

	public static void main(String[] args)
	{

		Scanner sc = new Scanner(System.in);

		int finalists = sc.nextInt();

		int max = -1;

		for(int i=0; i<finalists; i++)
		{
			int next = sc.nextInt();
			if(max < next)
			{
				max = next;
			}
		}
		int ans = max - 25;
		if(ans < 0)
		{
			ans = 0;
		}
		System.out.println(ans);

	}

}

        import java.util.*;
        public class arr {
            public static void main(String[] args) {
                Scanner scn = new Scanner(System.in);
int k=scn.nextInt();
int max=0;
for(int i=0;i<k;i++){
    int num=scn.nextInt();
    max=Math.max(max,num);
}

if(max<=25){
    System.out.println(0);
}else{
    System.out.println(max-25);
}

}
                    }

import java.util.Scanner;

public class A859 {
    public static void main(String q[]){
        Scanner sc=new Scanner(System.in);
        int n=sc.nextInt();
        int ar[]=new int[n];
        int mx=-999;
        for (int i=0;i<n;i++){
            ar[i]=sc.nextInt();
            if(mx<ar[i])
                mx=ar[i];
        }
        if(mx<=25)
            System.out.println(0);
        else
            System.out.println(mx-25);
    }
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.*;
import java.util.stream.Collectors;

public class Main {
    private static IO io = new IO();

    public static void main(String[] args) throws Exception {
        int k = io.getInt();
        List<Integer> ls = io.getIntegerArray(k);
        List<Integer> fil = ls.stream().filter(a -> a > 25).collect(Collectors.toList());
        if(fil.size() == 0){
            System.out.println(0);
        }
        else{
            System.out.println(fil.get(fil.size() - 1) - 25);
        }

    }
}

class IO {
    private BufferedReader br = null;
    private StringTokenizer st = null;

    public IO() {
        this(System.in);
    }

    public IO(InputStream is) {
        this.br = new BufferedReader(new InputStreamReader(is));
    }

    public List<String> getStringArray(int n) throws IOException {
        if (n == 0)
            return new ArrayList<>();
        if (st == null || !st.hasMoreTokens())
            st = new StringTokenizer(br.readLine());
        List<String> res = new ArrayList<>();
        for (int i = 0; i < n; i++) {
            if (!st.hasMoreTokens())
                st = new StringTokenizer(br.readLine());
            res.add(st.nextToken());
        }
        return res;
    }

    public String getString() throws IOException {
        List<String> res = this.getStringArray(1);
        return res.size() == 0 ? "" : res.get(0);
    }

    public List<Integer> getIntegerArray(int n) throws IOException {
        if (n == 0)
            return new ArrayList<>();
        List<String> res = getStringArray(n);
        return res.stream().map(Integer::parseInt).collect(Collectors.toList());
    }

    public Integer getInt() throws IOException {
        List<Integer> res = this.getIntegerArray(1);
        return res.size() == 0 ? 0 : res.get(0);
    }

    public List<Long> getLongArray(int n) throws IOException {
        if (n == 0)
            return new ArrayList<>();
        List<String> res = getStringArray(n);
        return res.stream().map(Long::parseLong).collect(Collectors.toList());
    }

    public Long getLong() throws IOException {
        List<Long> res = this.getLongArray(1);
        return res.size() == 0 ? 0L : res.get(0);
    }

    public List<Double> getDoubleArray(int n) throws IOException {
        if (n == 0)
            return new ArrayList<>();
        List<String> res = getStringArray(n);
        return res.stream().map(Double::parseDouble).collect(Collectors.toList());
    }

    public Double getDouble() throws IOException {
        List<Double> res = this.getDoubleArray(1);
        return res.size() == 0 ? 0.0 : res.get(0);
    }
}

class Utils {
    static int[][] fourDirs = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}};
    static int[][] eightDirs = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}, {1, 1}, {1, -1}, {-1, 1}, {-1, -1}};

    static int modAdd(int a, int b) {
        return (int) ((a + (long) b) % 1000000007);
    }

    static int modSub(int a, int b) {
        return (int) ((a - (long) b + 1000000007) % 1000000007);
    }

    public static List<Integer> sieve(int n) {
        boolean b[] = new boolean[n + 1];
        List<Integer> ans = new ArrayList<>();
        Arrays.fill(b, true);

        for (int i = 2; i <= n; i++) {
            if (b[i]) {
                ans.add(i);
                for (int j = i * i; j >= 0 && j <= n; j += i) {
                    b[j] = false;
                }
            }
        }
        return ans;
    }

    public static boolean isPrime(long n) {
        long sqrt = (long) Math.sqrt(n);
        for (int i = 2; i <= sqrt; i++) {
            if (n % i == 0)
                return false;
        }
        return true;
    }

    public static long mod(long n) {
        if (n > 0)
            return n % 1000000007;
        return (n + 2000000014) % 1000000007;
    }

    public static boolean isSqr(long n) {
        int sqrt = (int) Math.sqrt(n);
        return n == (long) sqrt * sqrt;
    }

    public static boolean inRange(long i, long l, long h) {
        return i >= l && i <= h;
    }

    public static boolean isValid(int i, int j, int n, int m) {
        return i >= 0 && j >= 0 && i < n && j < m;
    }

    public static void swap(List<Integer> ls, int i, int j) {
        int temp = ls.get(i);
        ls.set(i, ls.get(j));
        ls.set(j, temp);
    }

    public static long gcd(long a, long b) {
        if (a < b)
            return gcd(b, a);
        else if (a == b || b == 0)
            return a;
        else {
            return gcd(b, a % b);
        }
    }

    public static long subSum(long[] pre, int l, int h) {
        return l == 0 ? pre[h] : pre[h] - pre[l - 1];
    }

    public static void ifPrint(boolean test, Object ifValue, Object elseValue) {
        System.out.println(test ? ifValue : elseValue);
    }

    public static void print(Character delim, Object... a) {
        List<String> top = new ArrayList<>();
        for (Object aa : a)
            top.add(aa == null ? "null" : aa.toString());
        System.out.println(join(top, delim.toString()));
    }

    public static void print(Object... a) {
        print(' ', a);
    }

    public static <T extends Comparable<T>> int lowerBound(T[] arr, int l, int h, T key) {
        while (l < h) {
            int mid = (l + h) / 2;
            if (arr[mid].compareTo(key) < 0)
                l = mid + 1;
            else
                h = mid;
        }
        return arr[l].compareTo(key) >= 0 ? l : -1;
    }

    public static <T extends Comparable<T>> int upperBound(T[] arr, int l, int h, T key) {
        while (l < h) {
            int mid = (l + h) / 2;
            if (arr[mid].compareTo(key) < 0)
                l = mid + 1;
            else if (arr[mid].compareTo(key) == 0)
                l = mid;
            else
                h = mid;
            if (h == l + 1)
                break;
        }
        return arr[l].compareTo(key) >= 0 ? l : -1;
    }

    public static <T> String join(List<T> ls) {
        return join(ls, " ");
    }

    public static <T> String join(List<T> ls, String delim) {
        StringJoiner sj = new StringJoiner(delim);
        for (T a : ls)
            sj.add(a.toString());
        return sj.toString();
    }

    public static <T> void print2DArray(List<List<T>> mat) {
        for (List<T> m : mat) {
            System.out.println("{ " + join(m, ", ") + " }");
        }
    }

    public static <T> void reverseArrray(T[] arr, int l, int h) {
        while (l < h) {
            T temp = arr[l];
            arr[l] = arr[h];
            arr[h] = temp;
            l++;
            h--;
        }
    }
}

import java.util.Scanner;
public class MyClass {
    public static void main(String args[]) {
        Scanner s= new Scanner(System.in);
        int n=s.nextInt();
        int arreglo[]= new int[n];
        int numero=0;
        boolean saber=true;
        for(int i=0; i<n; i++){
            arreglo[i]=s.nextInt();
            if(arreglo[i]>25){
                saber=false;
            }
        }
        if(saber){
            System.out.println("0");
        }
        else{
            numero= arreglo[n-1]-25;
            System.out.println(numero);
        }

    }
}

import java.io.*;
import java.text.*;
import java.util.*;
import java.math.*;
public class A {
	public static void main(String[] args) throws Exception {
		new A().run();
	}
	public void run() throws Exception {
		FastScanner f = new FastScanner();
		PrintWriter out = new PrintWriter(System.out);
		int a = f.nextInt();
		String[] s = f.reader.readLine().split(" ");
		int max = Integer.parseInt(s[0]);
		for(int i = 1; i < s.length; i++)
		{
			if(Integer.parseInt(s[i]) > max) max = Integer.parseInt(s[i]);
		}
		out.println(max-25);
		out.flush();
	}

    static class FastScanner {
        public BufferedReader reader;
        public StringTokenizer tokenizer;

        public FastScanner() {
            reader = new BufferedReader(new InputStreamReader(System.in), 32768);
            tokenizer = null;
        }

        public String next() {
            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
                try {
                    tokenizer = new StringTokenizer(reader.readLine());
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            return tokenizer.nextToken();
        }
        public int nextInt() {
            return Integer.parseInt(next());
        }
        public long nextLong() {
        	return Long.parseLong(next());
        }
        public double nextDouble() {
        	return Double.parseDouble(next());
        }

    }
}

import java.util.*;
import java.io.*;
import java.math.*;

public class A{

	static int n,r[],res;
	static void MainMethod()throws Exception{
		n=reader.nextInt();
		r=new int [n+1];
		r[0]=0;
		int i;
		for (i=1;i<=n;i++) r[i]=reader.nextInt();
		Arrays.sort(r);
		res=0;
		for (i=1;i<=n;i++) res+=(r[i]-r[i-1]-1);
		printer.println(res);
	}
	public static void main(String[] args)throws Exception{
		MainMethod();
		printer.close();
	}
	static void halt(){
		printer.close();
		System.exit(0);
	}
	static PrintWriter printer=new PrintWriter(new OutputStreamWriter(System.out));
	static class reader{
		static BufferedReader bReader=new BufferedReader(new InputStreamReader(System.in));
		static StringTokenizer token=new StringTokenizer("");
		static String readNextLine() throws Exception{
			return bReader.readLine();
		}
		static String next() throws Exception{
			while (token.hasMoreTokens()==false){
				token=new StringTokenizer(bReader.readLine());
			}
			return token.nextToken();
		}
		static int nextInt()throws Exception{
			while (token.hasMoreTokens()==false){
				token=new StringTokenizer(bReader.readLine());
			}
			return Integer.parseInt(token.nextToken());
		}
		static long nextLong()throws Exception{
			while (token.hasMoreTokens()==false){
				token=new StringTokenizer(bReader.readLine());
			}
			return Long.parseLong(token.nextToken());
		}
		static double nextDouble()throws Exception{
			while (token.hasMoreTokens()==false){
				token=new StringTokenizer(bReader.readLine());
			}
			return Double.parseDouble(token.nextToken());
		}
	}
	static class MyMathCompute{
		static long [][] MatrixMultiplyMatrix(long [][] A, long [][] B, long mod) throws Exception{
			int n=A.length, m=B[0].length;
			int p=A[0].length;
			int i,j,k;
			if (B.length!=p) throw new Exception("invalid matrix input");
			long [][] res=new long [n][m];
			for (i=0;i<n;i++) for (j=0;j<m;j++){
				if (A[i].length!=p) throw new Exception("invalid matrix input");
				res[i][j]=0;
				for (k=0;k<p;k++)
					res[i][j]=(res[i][j]+((A[i][k]*B[k][j])% mod))% mod;
			}
			return res;
		}
		static double [][] MatrixMultiplyMatrix(double [][] A, double [][] B ) throws Exception{
			int n=A.length, m=B[0].length;
			int p=A[0].length;
			int i,j,k;
			if (B.length!=p) throw new Exception("invalid matrix input");
			double [][] res=new double [n][m];
			for (i=0;i<n;i++) for (j=0;j<m;j++){
				if (A[i].length!=p) throw new Exception("invalid matrix input");
				res[i][j]=0;
				for (k=0;k<p;k++)
					res[i][j]=res[i][j]+(A[i][k]*B[k][j]);
			}
			return res;
		}
		static long [][] MatrixPow(long [][] A,long n, long mod) throws Exception{
			if (n==1) return A;
			long [][] res=MatrixPow(A, n/2, mod);
			res=MatrixMultiplyMatrix(res, res, mod);
			if ((n % 2) == 1) res=MatrixMultiplyMatrix(A,res, mod);
			return res;
		}
		static double [][] MatrixPow(double [][] A,long n) throws Exception{
			if (n==1) return A;
			double[][] res=MatrixPow(A, n/2);
			res=MatrixMultiplyMatrix(res, res);
			if ((n % 2) == 1) res=MatrixMultiplyMatrix(A,res);
			return res;
		}
		static long pow(long a,long n,long mod){
			a= a % mod;
			if (n==0) return 1;
			long k=pow(a,n/2,mod);
			if ((n % 2)==0) return ((k*k)%mod);
			else return (((k*k) % mod)*a) % mod;
		}
		static double pow(double a,long n){
			if (n==0) return 1;
			double k=pow(a,n/2);
			if ((n % 2)==0) return (k*k);
			else return (((k*k) )*a) ;
		}
	}
}

import java.util.Scanner;
public class ADeclinedFinalists {

	public static void main(String[] args) {
		try {
			ADeclinedFinalists adf = new ADeclinedFinalists();
			adf.run();
		}catch(Exception e) {
			e.printStackTrace();
		}
	}

	public void run() {
		Scanner scan = new Scanner(System.in);
		int k;
		int r;
		int max=0;
		k = scan.nextInt();
		for(int i=0; i<k; i++) {
			r = scan.nextInt();
			if(r > max)
				max = r;
		}
		scan.close();
		if(max > 26)
			System.out.println(max-25);
		else
			System.out.println("0");
	}

}

import java.util.Scanner;

public class DeclinedFinalists {

    public static void main(String[] args) {
        Scanner cs = new Scanner(System.in);
        int k = cs.nextInt();
        int r[] = new int[k];
        for (int i = 0; i < k; i++) {
            r[i] = cs.nextInt();
        }
        int x = r[k - 1] - 25;
        System.out.println(x >= 0 ? x : 0);
    }

}

/* package whatever; // don't place package name! */

import java.util.*;
import java.lang.*;
import java.io.*;

/* Name of the class has to be "Main" only if the class is public. */
public class Ideone
{
	public static void main (String[] args) throws java.lang.Exception
	{
		// your code goes here
		Scanner in=new Scanner(System.in);
		int n=in.nextInt();
		int a[]=new int[n];
		int max=-1;
		for(int i=0;i<n;i++)
		{
			if(a[i]>max)max=a[i];
		}
		if(max-25>=0)System.out.println(max-25);
		else System.out.println(0);
	}
}

/**
 * Created by Mahesh on 9/16/2017.
 */
import java.io.*;
import java.util.*;

public class A
{
    public static void main(String[] args)
    {
        Scanner read = new Scanner(System.in);

        String num = read.nextLine();
        String[] in = read.nextLine().split(" ");

        Arrays.sort(in);
        int max = Integer.parseInt(in[Integer.parseInt(num)-1]);
        if(max<=25)
        {
            System.out.println("0");
        }
        else
        {
            System.out.println(max-25);
        }

    }
}

/**
 * Created by Mahesh on 9/16/2017.
 */
import java.io.*;
import java.util.*;

public class A
{
    public static void main(String[] args)
    {
        Scanner read = new Scanner(System.in);

        String num = read.nextLine();
        String[] in = read.nextLine().split(" ");

        Arrays.sort(in);
        long max = Long.parseLong(in[Integer.parseInt(num)-1]);
        if(max<=25)
        {
            System.out.println("0");
        }
        else
        {
            System.out.println(max-25);
        }

    }
}

import java.util.Scanner;
public class DeclinedFinalists{
	static Scanner kbd=new Scanner(System.in);
	public static void main(String[]args){
		int noContestants=kbd.nextInt();
		int [] contestants=new int[noContestants];
		int declined=0;
		int temp=0;
		for(int x=0; x<noContestants; x++){
			contestants[x]=kbd.nextInt();
		}
		declined=contestants[noContestants-1]-25;
		System.out.print(declined);
	}
}

import java.util.Scanner;
public class DeclinedFinalists{
	static Scanner kbd=new Scanner(System.in);
	public static void main(String[]args){
		int noContestants=kbd.nextInt();
		int [] contestants=new int[noContestants];
		int declined=0;
		int temp=0;
		int max=0;
		for(int x=0; x<noContestants; x++){
			contestants[x]=kbd.nextInt();
		}
		for (int counter = 1; counter<noContestants; counter++){
     		if (contestants[counter]>max){
      			max=contestants[counter];
     		}
		}
		for(int y=0; y<noContestants; y++){
			if(contestants[noContestants-1]>25){
				declined=max-25;
			}
		}
		System.out.print(declined);
	}
}

import java.util.Scanner;
public class DeclinedFinalists{
	static Scanner kbd=new Scanner(System.in);
	public static void main(String[]args){
		int noContestants=kbd.nextInt();
		int [] contestants=new int[noContestants];
		int declined=0;
		int temp=0;
		for(int x=0; x<noContestants; x++){
			contestants[x]=kbd.nextInt();
		}
		for(int y=0; y<noContestants; y++){
			if(contestants[noContestants-1]>25){
				declined=contestants[noContestants-1]-25;
			}
		}
		System.out.print(declined);
	}
}

import java.util.Scanner;
public class DeclinedFinalists{
	static Scanner kbd=new Scanner(System.in);
	public static void main(String[]args){
		int noContestants=kbd.nextInt();
		int [] contestants=new int[noContestants];
		int declined=0;
		int temp=0;
		for(int x=0; x<noContestants; x++){
			contestants[x]=kbd.nextInt();
		}
		for(int y=0; y<noContestants; y++){
			if(contestants[noContestants-1]>25){
			declined=contestants[noContestants-1]-25;
			System.out.print(declined);
			}
		}
	}
}

import java.util.Scanner;
public class DeclinedFinalists{
	static Scanner kbd=new Scanner(System.in);
	public static void main(String[]args){
		int noContestants=kbd.nextInt();
		int [] contestants=new int[noContestants];
		int declined=0;
		int temp=0;
		int max=0;
		for(int x=0; x<noContestants; x++){
			contestants[x]=kbd.nextInt();
		}
		for (int counter=0; counter<noContestants; counter++){
     		if (contestants[counter]>max){
      			max=contestants[counter];
     		}
		}
		for(int y=0; y<noContestants; y++){
			if(contestants[noContestants-1]>25){
				declined=max-25;
			}
		}
		System.out.print(declined);
	}
}

import java.util.Scanner;
public class DeclinedFinalists{
	static Scanner kbd=new Scanner(System.in);
	public static void main(String[]args){
		int noContestants=kbd.nextInt();
		int [] contestants=new int[noContestants];
		int declined=0;
		int temp=0;
		int max=0;
		for(int x=0; x<noContestants; x++){
			contestants[x]=kbd.nextInt();
		}
		for (int counter = 1; counter<noContestants; counter++){
     		if (contestants[counter]>max){
      			max=contestants[counter];
     		}
		}
		declined=max-35;
		System.out.print(declined);
	}
}

import java.util.*;

public class tp {

	public static void main(String[] args) {
		Scanner scan = new Scanner(System.in);
		int k = scan.nextInt();
		int min = 0 ;
		for(int i=0;i<k;i++){
			int a = scan.nextInt();
			if(a>min)
				min = a;
		}
		System.out.println(min - 25);
		scan.close();

	}

}

import java.util.Scanner;

public class Problem_A {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner s=new Scanner(System.in);
		int k=s.nextInt();
            int max=0;
             for(int i=0;i<k;i++)
                {
                  int n=s.nextInt();
                  max=Math.max(max, n);

                 }

	System.out.println(max-25);
	}
}

import java.util.ArrayList;
import java.util.Collections;
import java.util.Scanner;

public class DeclinedFinalists {

	public static void main(String[] args) {
		Scanner s= new Scanner(System.in);
		int a= s.nextInt();
		int result=0;
		s.nextLine();
		ArrayList<Integer> rankHolder=new ArrayList<Integer>();
		while(s.hasNextInt())
		{
				rankHolder.add(s.nextInt());
		}
		if(rankHolder.size()>0)
		{
			  int max = 0;
			for(int tempMax: rankHolder)
				max=max<tempMax?tempMax:max;
			result=max-25;
		}

System.out.println(result);
	}
}

import java.util.ArrayList;
import java.util.Collections;
import java.util.Scanner;

public class DeclinedFinalists {

	public static void main(String[] args) {
		Scanner s= new Scanner(System.in);
		int a= s.nextInt();
		int result=0;
		//int b= s.nextInt();
		s.nextLine();
		ArrayList<Integer> rankHolder=new ArrayList<Integer>();
		while(s.hasNextInt())
		{
				rankHolder.add(s.nextInt());
		}
		if(rankHolder.size()>0)
			result=Collections.max(rankHolder)-25;
System.out.println(result);
	}
}

import java.util.*;
public class Anon {
    public static void main(String[] args) {
    	Scanner in = new Scanner(System.in);
    	int k = in.nextInt();
    	in.nextLine();
    	int max = Integer.MAX_VALUE;
    	for(int i=1; i<=k; i++) {
    		int r = in.nextInt();
    		if(r>max) max = r;
    	}
    	System.out.printf("%d", max-25);
    }
}

import java.util.*;
public class Anon {
    public static void main(String[] args) {
    	Scanner in = new Scanner(System.in);
    	int k = in.nextInt();
    	in.nextLine();
    	int max = Integer.MIN_VALUE;
    	for(int i=1; i<=k; i++) {
    		int r = in.nextInt();
    		if(r>max) max = r;
    	}
    	System.out.printf("%d", max-25);
    }
}

import java.io.*;
import java.util.*;
import java.text.*;
import java.math.*;
import java.util.regex.*;

public class Finalist {

	public static void main(String[] args){
		Scanner scanner = new Scanner(System.in);
		int numbersFinalist = scanner.nextInt();

		int maxValue = 0;
		int[] arrFinalist = new int[numbersFinalist];
		for(int i=0; i<numbersFinalist; i++){
			arrFinalist[i] = scanner.nextInt();

			if(arrFinalist[i] > maxValue) maxValue = arrFinalist[i];
		}

		int diff = maxValue - 25;

		if(diff > 0) System.out.println(diff);
		else if(diff < 0) System.out.println(0);
	}

}

import java.util.Scanner;
import java.util.Arrays;
public class DeclinedFinalists {
  public static void main(String[] args) {
    Scanner console = new Scanner(System.in);
    int k = console.nextInt();
    int[] ranks = new int[k];
    for (int i = 0; i < k; i++) {
      ranks[i] = console.nextInt();
    }
    console.close();
    Arrays.sort(ranks);
    System.out.println(ranks[k-1] - 25);
  }
}

/**
 * Created by Harmoush on 9/14/2017.
 */

import java.util.Arrays;
import java.util.Scanner;
public class Solution {
    public static void main(String... args) {
        Scanner in = new Scanner(System.in);
        int k = in.nextInt();
        int []arr = new int[k];
        for (int i = 0; i < k; i++) {
            arr[i] = in.nextInt();
        }
        Arrays.sort(arr);
       int x = arr[k-1];
       int ans = 0;
       if(x >25)
           ans = 25 -x;
       System.out.println(ans);
    }
}

import java.util.Scanner;

public class DeclinedFinalists {
    private static Scanner reader = new Scanner(System.in);

    public static void main (String[] args){
        int k ;
        int max = Integer.MIN_VALUE;
        k = reader.nextInt();

        for (int i = 0 ; i < k ; ++i)
            max = Integer.max(max, reader.nextInt());

        if (max >= 25)
            System.out.println("0");
        else
            System.out.println(max - 1 - 24 );
    }
}

import java.util.Scanner;

public class ASQL {

	@SuppressWarnings("resource")
	public static void main(String[] args) {
		Scanner input = new Scanner(System.in);
		int k = input.nextInt();
		int r = 25;
		for (int i = 0; i < k; i++){
			r = input.nextInt();
		}
		System.out.println(Math.max(0, r - 25));
	}

}

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner cin = new Scanner(System.in);
        int[] v;
        int n, maximum;

        n = cin.nextInt();
        maximum = -1;

        v = new int[n];
        for (int i = 0; i < n; ++i) {
            v[i] = cin.nextInt();
            if (v[i] > maximum)
                maximum = v[i];
        }

        System.out.println(maximum - 25);
    }
}

import java.util.*;
import java.io.*;

public class A {
	FastScanner in;
	PrintWriter out;
	boolean systemIO = true;

	public static void quickSort(int[] a, int from, int to) {
		if (to - from <= 1) {
			return;
		}
		int i = from;
		int j = to - 1;
		int x = a[from + (new Random()).nextInt(to - from)];
		while (i <= j) {
			while (a[i] < x) {
				i++;
			}
			while (a[j] > x) {
				j--;
			}
			if (i <= j) {
				int t = a[i];
				a[i] = a[j];
				a[j] = t;
				i++;
				j--;
			}
		}
		quickSort(a, from, j + 1);
		quickSort(a, j + 1, to);
	}

	public void solve() {
		int a = in.nextInt();
		int b = in.nextInt();
		int x = 1;
		for (int i = 1; i <= Math.min(a, b); i++) {
			x *= i;
		}
		System.out.println(x);
	}

	public void run() {
		try {
			if (systemIO) {
				in = new FastScanner(System.in);
				out = new PrintWriter(System.out);
			} else {
				in = new FastScanner(new File("input.txt"));
				out = new PrintWriter(new File("output.txt"));
			}
			solve();

			out.close();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

	class FastScanner {
		BufferedReader br;
		StringTokenizer st;

		FastScanner(File f) {
			try {
				br = new BufferedReader(new FileReader(f));
			} catch (FileNotFoundException e) {
				e.printStackTrace();
			}
		}

		FastScanner(InputStream f) {
			br = new BufferedReader(new InputStreamReader(f));
		}

		String nextLine() {
			try {
				return br.readLine();
			} catch (IOException e) {
				return null;
			}
		}

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

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

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

		double nextDouble() {
			return Double.parseDouble(next());
		}

	}

	// AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
	public static void main(String[] args) {
		new A().run();
	}
}

import java.util.Scanner;
import java.util.Vector;

public class A {
    static int max =0;
    static int K;
    public static void main(String[] args) {
        readInput();
        answer();
    }

    private static void answer() {
        System.out.println(max);
    }
    private static void readInput() {
        Scanner scanner = new Scanner(System.in);
        K = scanner.nextInt();
        for (int i = 0; i < K; i++) {
            int x =scanner.nextInt();
            if(x>max)
                max=x;
        }
    }
}

import java.util.*;

public class LazySecurityGuard {

	public static void main(String[] args)
	{
		Scanner sc = new Scanner(System.in);

		int N = sc.nextInt();

		int lower = (int) Math.floor( Math.sqrt(N) ) ;

		int remaining = N - (lower * lower);

		int perimeter = 0;

		if(remaining > lower)
		{
			perimeter = ( lower + 1 ) * 4;
		}
		else if(remaining == 0)
		{
			perimeter = lower * 4;
		}
		else
		{
			perimeter = (lower * 4) + 2;
		}

		System.out.println(perimeter);

	}

}

import java.util.Scanner;

public class Contestents {

    public static void main(String[] args){
        Scanner scan = new Scanner(System.in);
        scan.nextLine();
        String[] contestents = scan.nextLine().split(" ");
        int largest = -1;
        for(String contestent : contestents) {
            if(Integer.valueOf(contestent) > largest) {
                largest = Integer.valueOf(contestent);
            }
        }
        System.out.println(largest-25);
    }

}

/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */

import java.util.Scanner;
public class Code_forcces {

public static void main(String[] args){
    Scanner reader = new Scanner (System.in);
    int k = reader.nextInt();
    int a;
    int max = 0;
    for (int i=0;i<k;i++){
        a = reader.nextInt();
        if (a>max) max = a;
    }
    if (max<26) {
        System.out.print(0);
    }
    else{
        System.out.print(max);
    }
}

}

import java.util.Scanner;

public class Main {
   public static void main(String[] args) {
       Scanner scanner = new Scanner(System.in);
       int K = scanner.nextInt();
       int maxRank = 25;
       for (int i = 1; i <= K; i++) {
           int ri = scanner.nextInt();
           if (ri > 25)
               maxRank = ri;
       }
       int result = maxRank - 25;
       System.out.println(result);
   }
}

import java.util.*;

public class DeclinedFinalists {
	public static void main(String[] args) {
		Scanner in = new Scanner(System.in);
		int K = Integer.parseInt(in.nextLine());
		int[] ranks = new int[K];
		for (int i = 0; i < ranks.length; i++) {
			ranks[i] = in.nextInt();
		}

		Arrays.sort(ranks);
		int numDeclines = 0;
		if (K == 25) {
			numDeclines = (ranks[0] == 1) ? 0 : 1;
			for (int i = 0; i < ranks.length - 1; i++) {
				numDeclines+=(ranks[i + 1] - ranks[i] - 1);
			}
			System.out.println(numDeclines);
		}
		else if (ranks[ranks.length - 1] <= 25) {
			System.out.println(0);
		}
		else {
			for (int i = ranks.length - 1; i >= 0 && ranks[i] > 25; i--) {
				if (i - 1 >= 0 && ranks[i - 1] > 25) {
					numDeclines+=(ranks[i] - ranks[i - 1]);
				}
				else {
					numDeclines+=(ranks[i] - 25);
				}
			}
			System.out.println(numDeclines);
		}
	}
}

import java.util.*;

public class DeclinedFinalists {
	public static void main(String[] args) {
		Scanner in = new Scanner(System.in);
		int K = Integer.parseInt(in.nextLine());
		int[] ranks = new int[K];
		for (int i = 0; i < ranks.length; i++) {
			ranks[i] = in.nextInt();
		}

		Arrays.sort(ranks);
		int numDeclines = 0;
		if (K == 25) {
			numDeclines = (ranks[0] == 1) ? 0 : 1;
			for (int i = 0; i < ranks.length - 1; i++) {
				for (int j = 1; j < (ranks[i + 1] - ranks[i]); j++) {
					numDeclines++;
				}
			}
			System.out.println(numDeclines);
		}
		else if (ranks[ranks.length - 1] <= 25) {
			System.out.println(0);
		}
		else {
			for (int i = ranks.length - 1; i >= 0 && ranks[i] > 25; i--) {
				if (i - 1 >= 0 && ranks[i - 1] > 25) {
					for (int j = 1; j < (ranks[i] - ranks[i - 1]); j++) {
						numDeclines++;
					}
					numDeclines++;
				}
				else {
					for (int j = 1; j < (ranks[i] - 25); j++) {
						numDeclines++;
					}
					numDeclines++;
				}
			}
			System.out.println(numDeclines);
		}
	}
}

import java.util.*;

public class DeclinedFinalists {
	public static void main(String[] args) {
		Scanner in = new Scanner(System.in);
		int K = Integer.parseInt(in.nextLine());
		int[] ranks = new int[K];
		for (int i = 0; i < ranks.length; i++) {
			ranks[i] = in.nextInt();
		}

		Arrays.sort(ranks);
		int numDeclines = 0;
		if (K == 25) {
			numDeclines = (ranks[0] == 1) ? 0 : 1;
			for (int i = 0; i < ranks.length - 1; i++) {
				numDeclines+=(ranks[i + 1] - ranks[i] - 1);
			}
			System.out.println(numDeclines);
		}
		else if (ranks[ranks.length - 1] <= 25) {
			System.out.println(0);
		}
		else {
			System.out.println(ranks[ranks.length - 1] - 25);
		}
	}
}

/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */

import java.util.*;
import java.io.*;

/**
 *
 * @author rahul kumar
 */
public class Main {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args)throws IOException {
     BufferedReader in =new BufferedReader(new InputStreamReader(System.in));
     long n=Long.parseLong(in.readLine());
     String s[]=in.readLine().split(" ");
     int l=s.length;int max=Integer.MIN_VALUE;
     int arr[]=new int[l];
     for(int i=0;i<l;i++){
       int c=Integer.parseInt(s[i]);
       arr[i]=c;
     }
     for(int i=0;i<l;i++){
        if(arr[i]>max){
            max=arr[i];
        }
     }
     if(n<max){
         System.out.println(max-n);
     }
     else{
          System.out.println(0);
     }
    }

}

/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */

import java.util.*;
import java.io.*;

/**
 *
 * @author rahul kumar
 */
public class Main{

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args)throws IOException {
     BufferedReader in =new BufferedReader(new InputStreamReader(System.in));
     long n=Long.parseLong(in.readLine());
     String s[]=in.readLine().split(" ");
     int l=s.length;int max=Integer.MIN_VALUE;
     int arr[]=new int[l];
     for(int i=0;i<l;i++){
       int c=Integer.parseInt(s[i]);
       arr[i]=c;
     }
     for(int i=0;i<l;i++){
        if(arr[i]>max){
            max=arr[i];
        }
     }
     if(n<arr[l-1]){
         System.out.println(arr[l-1]-n);
     }
     else{
          System.out.println(0);
     }
    }

}

/* package codechef; // don't place package name! */

import java.util.*;
import java.lang.*;
import java.io.*;
import java.math.*;

/* Name of the class has to be "Main" only if the class is public. */
public class Codechef
{
	public static void main (String[] args) throws java.lang.Exception
	{
		// your code goes here
		Scanner sc=new Scanner(System.in);
	    long n,i,max=25,num;
	    n=sc.nextLong();
	    for(i=0;i<n;i++)
	    {
	       num=sc.nextLong();
	       if(num>25)
	       {
	           max=num;
	       }
	    }
	    if(max==25)
	    System.out.println("0");
	    else
	    System.out.println(max-25);
	}}

/* package codechef; // don't place package name! */

import java.util.*;
import java.lang.*;
import java.io.*;
import java.math.*;

/* Name of the class has to be "Main" only if the class is public. */
public class Codechef
{
	public static void main (String[] args) throws java.lang.Exception
	{
		// your code goes here
		Scanner sc=new Scanner(System.in);
	    long n,i,max=0,num;
	    n=sc.nextLong();
	    for(i=0;i<n;i++)
	    {
	       num=sc.nextLong();
	       if(num>25)
	       {
	           max=num;
	       }
	    }

	    System.out.println(Math.max(0,(max-25)));
	}}

import java.util.Scanner;

public class DeclinedFinalists
{
    public static void main(String[] args)
    {
        Scanner scan = new Scanner(System.in);
        int num = scan.nextInt();
        int temp1 = 0;
        int temp2 = 0;
        int max = 0;
        while (num != 0)
        {
            temp1 = scan.nextInt();
            for (int i = 0; i < num; i++)
            {
                max = Math.max(temp1, temp2);
            }
            temp2 = temp1;
            num--;
        }
        int output = max - 25;
        if (output <= 0)
        {
            System.out.println(0);
        }
        else
        {
            System.out.println(output);
        }

    }
}

import java.util.*;
import java.io.*;
public class B{
   public static void main(String args[]){
   	Scanner sc=new Scanner(System.in);
   	PrintWriter o=new PrintWriter(System.out);

   	int n=sc.nextInt();
   	int x=(int)Math.sqrt(n);

    if(x*x==n)
    	o.println(4*x);
    else if(x*(x+1)>=n){
    	o.println(2*(x+1)+2*x);
    }
    else if(x*(x+1)<n)
    	o.println(4*(x+1));
   	//o.println(x);
   	o.flush();
   	o.close();
   }
}

/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */

//import com.sun.xml.internal.ws.util.StringUtils;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.lang.reflect.Array;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Scanner;
import java.util.Set;
import java.util.Vector;
import java.util.regex.Pattern;
import java.util.stream.Collectors;

/**
 *
 * @author george
 */

public class main {
    /*
public static boolean isPrime(long n) {
    if(n < 2) return false;
    if(n == 2 || n == 3) return true;
    if(n%2 == 0 || n%3 == 0) return false;
    long sqrtN = (long)Math.sqrt(n)+1;
    for(long i = 6L; i <= sqrtN; i += 6) {
        if(n%(i-1) == 0 || n%(i+1) == 0) return false;
    }
    return true;
}*/
/*
    private static long f(long l) {
        throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
    }

public static boolean contains(final int[] arr, final int key) {
    return Arrays.stream(arr).anyMatch(i -> i == key);
}
 static boolean isSubSequence(String str1, String str2, int m, int n)
    {

        if (m == 0)
            return true;
        if (n == 0)
            return false;

        if (str1.charAt(m-1) == str2.charAt(n-1))
            return isSubSequence(str1, str2, m-1, n-1);

        return isSubSequence(str1, str2, m, n-1);
    }

    static int gcdThing(int a, int b) {
    BigInteger b1 = BigInteger.valueOf(a);
    BigInteger b2 = BigInteger.valueOf(b);
    BigInteger gcd = b1.gcd(b2);
    return gcd.intValue();
}
    public static boolean checkAnagram(String str1, String str2) {
        int i=0;
        for (char c : str1.toCharArray()) {
        i = str2.indexOf(c, i) + 1;
        if (i <= 0) { return false; }
    }
    return true;

}
   */
    public static Set primeFactors(int num)
    {
        Set<Integer>Prime=new HashSet<Integer>();
        // Print the number of 2s that divide n
        int tw=2;
        while (num%2==0)
        {
            Prime.add(tw);
            num /= 2;
        }

        // n must be odd at this point.  So we can
        // skip one element (Note i = i +2)
        for (int i = 3; i <= Math.sqrt(num); i+= 2)
        {
            // While i divides n, print i and divide n
            while (num%i == 0)
            {
                Prime.add(i);
                num/= i;
            }
        }

        // This condition is to handle the case whien
        // n is a prime number greater than 2
        if (num> 2)
            Prime.add(num);
        return Prime;
    }
    /*
    public static String Winner(int [] arr)
    {
        int maxsum=-1;
        int temp=0;
        List<Integer> L=Arrays.stream(arr).boxed().collect(Collectors.toList());
        int count=0;
        String winner="First";
        while(L.isEmpty()!=true){
           if(count%2==0){winner="First";
           //take max odd interval
            for (int i = 0; i < L.size(); i++) {

            }
            }
           else{winner="Second";

           }
           count++;
        }

    return winner;
    }
    public static String changeCharInPosition(int position, char ch, String str){
    char[] charArray = str.toCharArray();
    charArray[position] = ch;
    return new String(charArray);
    }
    public static boolean CheckCanObtainYfromX(String y,String x){
        boolean cond=true;
        String help="";
        for (int i = 0; i < y.length(); i++) {
            help="";help+=y.charAt(i);
            if(y.contains(help)==false){x=x.replaceFirst(help,"A");cond=false;break;}

        }
        return cond;
    }
   public static int LongestPalindrome(String x){
    int n=x.length();
    boolean table[][] = new boolean[n][n];
    int maxLength = 1;
     for (int i = 0; i < n; ++i)
            table[i][i] = true;
   int start = 0;
    for (int i = 0; i < n - 1; ++i) {
            if (x.charAt(i) == x.charAt(i + 1)) {
                table[i][i + 1] = true;
                start = i;
                maxLength = 2;
            }
        }
     for (int k = 3; k <= n; ++k) {
            for (int i = 0; i < n - k + 1; ++i)
            {
                int j = i + k - 1;
               if (table[i + 1][j - 1] && x.charAt(i) == x.charAt(j)) {
                    table[i][j] = true;
                if (k > maxLength) {
                        start = i;
                        maxLength = k;
                    }
                }
            }
     }
   return maxLength;
   }
   public static long choose(long total, long choose){
    if(total < choose)
        return 0;
    if(choose == 0 || choose == total)
        return 1;
    return choose(total-1,choose-1)+choose(total-1,choose);
}
    public static long bitwiseAdd(int n1, int n2) {
        int x = n1, y = n2;
        int xor, and, temp;
        and = x & y;
        xor = x ^ y;

        while (and != 0) {
            and <<= 1;
            temp = xor ^ and;
            and &= xor;
            xor = temp;
        }
        return (xor%2);
    }
    public static boolean compare(String a,String b){
        for (int i = 0; i < a.length(); i++) {
            if(a.charAt(i)!=b.charAt(i)&&a.charAt(i)!='?'){return false;}
        }
  return true;
    }*/
/*public static boolean isUniqueChars(String str) {
    // short circuit - supposed to imply that
    // there are no more than 256 different characters.
    // this is broken, because in Java, char's are Unicode,
    // and 2-byte values so there are 32768 values
    // (or so - technically not all 32768 are valid chars)
    if (str.length() > 256) {
        return false;
    }
    // checker is used as a bitmap to indicate which characters
    // have been seen already
    int checker = 0;
    for (int i = 0; i < str.length(); i++) {
        // set val to be the difference between the char at i and 'a'
        // unicode 'a' is 97
        // if you have an upper-case letter e.g. 'A' you will get a
        // negative 'val' which is illegal
        int val = str.charAt(i) - 'a';
        // if this lowercase letter has been seen before, then
        // the corresponding bit in checker will have been set and
        // we can exit immediately.
        if ((checker & (1 << val)) > 0) return false;
        // set the bit to indicate we have now seen the letter.
        checker |= (1 << val);
    }
    // none of the characters has been seen more than once.
    return true;
}*/
 /*private static int [] PossibilitiesAsBinaryTruthTable(int n) {
        int rows = (int) Math.pow(2,n);
        int [] possibleTrack=new int[rows];
        int trackPerRow;
        for (int i=0; i<rows; i++) {
            trackPerRow=0;
            for (int j=n-1; j>=0; j--) {
                if(((i/(int) Math.pow(2, j))%2)==0){trackPerRow--;}
                else if(((i/(int) Math.pow(2, j))%2)==1){trackPerRow++;}
            }
            possibleTrack[i]=trackPerRow;
        }
        return possibleTrack;
    }
    //Steins GCD Algo
     public static long gcd(long u, long v)
    {
        long shift;
        if (u == 0)
            return v;
        if (v == 0)
            return u;
        for (shift = 0; ((u | v) & 1) == 0; ++shift)
        {
            u >>= 1;
            v >>= 1;
        }
        while ((u & 1) == 0)
            u >>= 1;
        do
        {
            while ((v & 1) == 0)
                v >>= 1;

            if (u > v)
            {
                long t = v;
                v = u;
                u = t;
            }
            v = v - u;
        } while (v != 0);

        return u << shift;
    }
     public static long gcd(long p, long q) {
        if (q == 0) return p;
        else return gcd(q, p % q);
    }*/
    public static void main (String []  args) throws IOException
    {
        Scanner s=new Scanner(System.in);
        BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
        PrintWriter pw=new PrintWriter(new OutputStreamWriter(System.out));
        int k=Integer.parseInt(br.readLine());
        String line=br.readLine();
        String [] nums=line.split(" ");
        int [] numsarr=new int[k];
        for (int i = 0; i <k ; i++) {
            numsarr[i]=Integer.parseInt(nums[i]);
        }
        int max;
        Arrays.sort(nums);
        max=numsarr[k-1];
        if(max>25){System.out.print((max-25));}
        else{System.out.print(0);}
    }
}

import java.util.Scanner;
public class Solution {

	public static void main(String[] args) {

		Scanner kbd = new Scanner(System.in);

		String input = kbd.nextLine();
		int numFinalist = Integer.parseInt(input);

		input = kbd.nextLine();
		Scanner scan = new Scanner(input);
		int num = Integer.parseInt(scan.next());
		boolean check = true;

		while (scan.hasNext()) {

			int nextNum = Integer.parseInt(scan.next());

			if (num >= nextNum) {

				check = false;
				break;

			}

			num = nextNum;

		}

		if (check) {

			System.out.println(num - 25);

		} else {

			System.out.println(0);

		}

	}

}

import java.util.Scanner;

public class DeclinedFinalists {
	public static void main(String[] args) {
		Scanner k = new Scanner(System.in);

		String K = k.nextLine();
		String list = k.nextLine();

		k.close();

		int n = Integer.parseInt(K);
		int declined = 0;
		String[] ranks = list.split(" ");
		for (int i = 0; i < n; i++) {
			int r = Integer.parseInt(ranks[i]);
			declined += r > 25 ? r - 25 : 0;
		}

		System.out.println(declined);
	}
}

import java.io.*;
import java.util.StringTokenizer;

public class Codeforces_MemSQL_round_1_DeclinedFinalists {
    public static void main(String[] args) {
        FScanner input = new FScanner();
        out = new PrintWriter(new BufferedOutputStream(System.out), true);
        int n = input.nextInt();
        boolean[] array = new boolean[1000000];
        int maxValue = 0;
        for (int i = 0; i < n; i++) {
            int index = input.nextInt() - 1;
            array[index] = true;
            maxValue = Math.max(maxValue, index);
        }
        int pre25 = 0;
        int valid = 0;
        for (int i = 0; i < 25; i++) {
            if (!array[i]) {
                pre25++;
            } else {
                valid++;
            }
        }
        if (valid == n) {
            out.println(0);
        } else {
            int answer = 0;
            for (int i = 24 + pre25; i < array.length && i <= maxValue; i++) {
                if (!array[i]) {
                    answer++;
                }
            }
            out.println(answer + pre25);
        }
        out.close();
    }

    public static PrintWriter out;

    public static class FScanner {
        BufferedReader br;
        StringTokenizer st;

        public FScanner() {
            br = new BufferedReader(new InputStreamReader(System.in));
        }

        private String next() {
            while (st == null || !st.hasMoreElements()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }

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

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

        public double nextDouble() {
            return Double.parseDouble(next());
        }

        public String nextLine() {
            String str = "";
            try {
                str = br.readLine();
            } catch (IOException e) {
                e.printStackTrace();
            }
            return str;
        }
    }
}

import java.io.*;
import java.util.StringTokenizer;

public class Codeforces_MemSQL_round_1_DeclinedFinalists {
    public static void main(String[] args) {
        FScanner input = new FScanner();
        out = new PrintWriter(new BufferedOutputStream(System.out), true);
        int n = input.nextInt();
        boolean[] array = new boolean[1000000];
        int maxValue = 0;
        for (int i = 0; i < n; i++) {
            int index = input.nextInt() - 1;
            array[index] = true;
            maxValue = Math.max(maxValue, index);
        }
        int continuous = 0;
        for (int i = maxValue; i >= 0; i--) {
            if (array[i]) {
                continuous++;
            } else {
                break;
            }
        }
        if (continuous == n && maxValue > 24) {
            out.println(maxValue - 24);
        } else {
            int pre25 = 0;
            int valid = 0;
            for (int i = 0; i < 25; i++) {
                if (!array[i]) {
                    pre25++;
                } else {
                    valid++;
                }
            }
            if (valid == n) {
                out.println(0);
            } else {
                int answer = 0;
                for (int i = 24 + pre25; i < array.length && i <= maxValue; i++) {
                    if (!array[i]) {
                        answer++;
                    }
                }
                out.println(answer + pre25);
            }
        }
        out.close();
    }

    public static PrintWriter out;

    public static class FScanner {
        BufferedReader br;
        StringTokenizer st;

        public FScanner() {
            br = new BufferedReader(new InputStreamReader(System.in));
        }

        private String next() {
            while (st == null || !st.hasMoreElements()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }

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

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

        public double nextDouble() {
            return Double.parseDouble(next());
        }

        public String nextLine() {
            String str = "";
            try {
                str = br.readLine();
            } catch (IOException e) {
                e.printStackTrace();
            }
            return str;
        }
    }
}

import java.util.*;

public class declinedFinalist {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int[] a = new int[n];
        for(int i =0;i<n;i++) {
            a[i]=sc.nextInt();
        }
        Arrays.sort(a);
        int result = a[n-1]-25;
        System.out.println(result);

    }

}

import java.util.*;

public class declinedFinalist {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int[] a = new int[n];
        for(int i =0;i<n;i++) {
            a[i]=sc.nextInt();
        }
        Arrays.sort(a);
        int result = a[n-1]-n;
        System.out.println(result);

    }

}

import java.util.*;

public class Main {

	public static void main(String[] args) {

		Scanner sc = new Scanner(System.in);

		int contestants = sc.nextInt();
		int[] attended = new int[contestants];
		int high = 0;

		for(int i =0; i< contestants; i++) {
			attended[i] = sc.nextInt();

			if(attended[i] > 25)
				high = attended[i];

		}
		if(high != 0)
			System.out.println(high -25);
		else
			System.out.println(high);

		sc.close();

	}

}

import java.io.*;
import java.util.Arrays;
import java.util.Scanner;
public class Main {
    public static void main(String[] args) throws IOException {
        Scanner in = new Scanner(System.in);
        byte k = in.nextByte();
        int a = 0;
        for (int i = 0; i < k; i++)
            a = in.nextInt();
        System.out.println(a > 25 ? (a-25) : 0);
    }
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.Stack;
import java.util.StringTokenizer;

/**
 * @author Andrei Chugunov
 */
public class A {

    BufferedReader br;
    PrintWriter out;
    StringTokenizer st;

    void solve() throws IOException {
        int k = nextInt();
        int max = 0;
        for (int i=0; i < k; i++) {
            int p = nextInt();
            if (p > max) max = p;
        }
        System.out.println(max - 25);

    }

    A() throws IOException {
        br = new BufferedReader(new InputStreamReader(System.in));
        out = new PrintWriter(System.out);
        solve();
        out.close();
    }

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

    String nextToken() {
        while (st == null || !st.hasMoreTokens()) {
            try {
                st = new StringTokenizer(br.readLine());
            } catch (Exception e) {
                return null;
            }
        }
        return st.nextToken();
    }

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

    String nextString() throws IOException {
        return br.readLine();
    }

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

    double nextDouble() throws IOException {
        return Double.parseDouble(nextToken());
    }
}

import java.util.Scanner;

public class Problem0859b {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println(2*((int)Math.ceil(2*Math.sqrt(sc.nextInt()))));
    }
}

import java.util.*;

public class DeclinedFinalists{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        int K = sc.nextInt();
        TreeSet<Integer> ts = new TreeSet();
        for(int k = 0; k < K; k++){
            ts.add(sc.nextInt());
        }
        System.out.println(ts.last() - 25);
    }
}

import java.util.*;
import java.util.Scanner;
public class Salamander
{
	public static void main(String args[])
  	{
	  Scanner s = new Scanner(System.in);
	  int x = s.nextInt();
	  int r=0,count = 0;
	  for(int i=0; i<x ; i++)
	  {
		  	 int y = s.nextInt();
	  		 if(y>=25 && y > r)
	  		 {	count = y - 25;
			 }
			 r = y;
	  }
	  System.out.println(count);
	}
}

import java.util.*;
import java.io.*;
import java.math.*;

    public  class Sample implements Runnable
    {

          public static void solve()
          {
             int n=i();
             int[] a=new int[n];
             int[] hash=new int[10000005];
             boolean flag=false;
             for(int i=0;i<n;i++)
             {
              a[i]=i();
              if(a[i]>25)flag=true;
             }
             if(!flag)out.println("0");
             else
             {
              int less_25=0;
              int gret_25=0;
              for(int i=0;i<n;i++)
              {
                if(a[i]<=25)less_25++;
                if(a[i]>25)gret_25++;
              }
              int ans=gret_25;

              int prev=25;
              for(int i=0;i<n;i++)
              {
                if(a[i]>25)
                {
                  ans+=(a[i]-prev-1);
                  prev=a[i];
                }
              }
              out.println(ans);
             }

          }

          public void run()
          {
              solve();
              out.close();
          }

          public static void main(String[] args) throws IOException
          {
                new Thread(null, new Sample(), "whatever", 1<<26).start();
          }
         static class Pair implements Comparable<Pair>
         {
            long a;
            int b;
            Pair(){}
            Pair(long a,int b)
            {
                       this.a=a;
                       this.b=b;
            }

            public int compareTo(Pair x)
           {
                return Long.compare(x.a,this.a);
           }
        }

    ////////////////////////////////////////////////////// Merge Sort ////////////////////////////////////////////////////////////////////////

   static class Merge
   {

        public static void sort(long inputArr[])
        {
            int length = inputArr.length;
            doMergeSort(inputArr,0, length - 1);
        }

        private static void doMergeSort(long[] arr,int lowerIndex, int higherIndex)
        {
            if (lowerIndex < higherIndex) {
                int middle = lowerIndex + (higherIndex - lowerIndex) / 2;
                doMergeSort(arr,lowerIndex, middle);
                doMergeSort(arr,middle + 1, higherIndex);
                mergeParts(arr,lowerIndex, middle, higherIndex);
            }
        }

        private static void mergeParts(long[]array,int lowerIndex, int middle, int higherIndex)
        {
            long[] temp=new long[higherIndex-lowerIndex+1];
            for (int i = lowerIndex; i <= higherIndex; i++)
            {
                temp[i-lowerIndex] = array[i];
            }
            int i = lowerIndex;
            int j = middle + 1;
            int k = lowerIndex;
            while (i <= middle && j <= higherIndex)
            {
                if (temp[i-lowerIndex] < temp[j-lowerIndex])
                {
                    array[k] = temp[i-lowerIndex];
                    i++;
                } else {
                    array[k] = temp[j-lowerIndex];
                    j++;
                }
                k++;
            }
            while (i <= middle)
            {
                array[k] = temp[i-lowerIndex];
                k++;
                i++;
            }
            while(j<=higherIndex)
            {
                array[k]=temp[j-lowerIndex];
                k++;
                j++;
            }
        }

    }

    /////////////////////////////////////////////////////////// Methods ////////////////////////////////////////////////////////////////////////

     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;
     }
     static String rev(String s)
     {
                StringBuilder sb=new StringBuilder(s);
                sb.reverse();
                return sb.toString();
     }
     static int gcd(int a,int b){return (a==0)?b:gcd(b%a,a);}
     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;
    }

     boolean findSum(int set[], int n, long sum)
    {
      if (sum == 0)
         return true;
      if (n == 0 && sum != 0)
         return false;
      if (set[n-1] > sum)
         return findSum(set, n-1, sum);
      return findSum(set, n-1, sum) ||findSum(set, n-1, sum-set[n-1]);
    }

      public static long modPow(long base, long exp, long mod)
     {
        base = base % mod;
        long result = 1;
        while (exp > 0)
       {
            if (exp % 2 == 1)
            {
                result = (result * base) % mod;
            }
            base = (base * base) % mod;
            exp = exp >> 1;
       }
        return result;
    }

    static long[] fac;
    static long[] inv;
    static long mod=(long)1e9+7;
    public static void cal()
    {
        fac = new long[1000005];
        inv = new long[1000005];
        fac[0] = 1;
        inv[0] = 1;
        for (int i = 1; i <= 1000000; i++)
        {
            fac[i] = (fac[i - 1] * i) % mod;
            inv[i] = (inv[i - 1] * modPow(i, mod - 2, mod)) % mod;
        }
    }

    public static long ncr(int n, int r)
    {
        return (((fac[n] * inv[r]) % mod) * inv[n - r]) % mod;
    }

////////////////////////////////////////// Input Reader ////////////////////////////////////////////////////////////////////////////////////////////////////

    static InputReader sc = new InputReader(System.in);
    static PrintWriter out= new PrintWriter(System.out);

    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 nextInt()
         {
                  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 nextLong()
          {
                  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[] nextIntArray(int n)
          {
                  int a[] = new int[n];
                  for (int i = 0; i < n; i++)
                  {
                          a[i] = nextInt();
                  }
                  return a;
          }

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

          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);
          }

    }

    static int i()
    {
        return sc.nextInt();
    }
    static long l(){
        return sc.nextLong();
    }
    static int[] iarr(int n)
    {
        return sc.nextIntArray(n);
    }
    static long[] larr(int n)
    {
        return sc.nextLongArray(n);
    }
    static String s(){
        return sc.nextLine();
    }

 }

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        int n = input.nextInt(), x = 0;
        for (int i = n; i > 0; i--) {
            int t = input.nextInt();
            if (x < t) {
                x = t;
            }
        }
        System.out.println(x - n);
    }
}

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        int n = input.nextInt(), x = 0;
        for (int i = n; i > 0; i--) {
            int t = input.nextInt();
            if (x < t) {
                x = t;
            }
        }
        System.out.println(x > 25 ? x - n : 0);
    }
}

import java.util.*;
import java.math.*;

public class CP {
	public static void main(String[] args) {
		Scanner sc = new Scanner (System.in);
		int n = 0;
		int max = 0;
		for(int i = 0; i < n; i++) {
			int a = sc.nextInt();
			if (a > max) {
				max = a;
			}
		}
		if(max <= 25) {
			System.out.println(0);
		} else {
			System.out.println(max - 25);
		}
	}
}

import java.io.* ;
import java.util.*;

public class declinedFinalists {
    public static void main (String[] args) {

        Scanner scan = new Scanner(System.in);
        int k = scan.nextInt();
        int[] ranks = new int[k];

        for (int i=0; i<k; i++) {
            ranks[i]=scan.nextInt();
        }
        Arrays.sort(ranks);
        int declined = 0;
        declined = ranks[k-1] - 25;
        System.out.println(declined);
    }
}

import java.util.Scanner;

public class DeclinedFinalist {

	public static void main(String[] args) {
		/*
		 * first convert input string to integer value
		 * for this problem is n array lenght and array itself
		 */
		Scanner sc = new Scanner(System.in);
		String str1 = sc.nextLine();
		String str2 = sc.nextLine();
		sc.close();

		/*
		 * first argument evaluation
		 */
		int K = 0;
		try {
			K = Integer.valueOf(str1);
		} catch (Exception e) {
			System.err.println("Not valid input!");
		}

		if((K < 1) | (K > 25)) {
			return;
		}

		int[] arr = stringTointArray(str2, 1, 1000000);

		/*
		 * actual algorithm (after filtering data)
		 */

		for (int i = 0; i < (arr.length - 1); i++) {
			if(arr[i] >= arr[i + 1]) {
				System.out.println("0");
				return;
			}
		}

		System.out.println((arr[arr.length - 1] - 25));

	}

	/**
	 * Method convert string to integer array in range min to max
	 * @param in	input string
	 * @param min	minimal integer value of array element
	 * @param max	maximal integer value of array element
	 * @return		array of integer created from string
	 */
	private static int[] stringTointArray(String in, int min, int max) {
		String[] str_arr = in.split(" ");
		int[] out = new int[str_arr.length];

		try {
			for (int i = 0; i < out.length; i++) {
				out[i] = Integer.valueOf(str_arr[i]);
				if ((out[i] < min) | (out[i] > max)) {
					System.err.println("Input data out of range!");
					return null;
				}
			}
		} catch (Exception e) {
			System.err.println("Wrong input data!");
			return null;
		}

		return out;
	}

}

import java.util.Scanner;

public class DeclinedFinalist {

	public static void main(String[] args) {
		/*
		 * first convert input string to integer value
		 * for this problem is n array lenght and array itself
		 */
		Scanner sc = new Scanner(System.in);
		String str1 = sc.nextLine();
		String str2 = sc.nextLine();
		sc.close();

		/*
		 * first argument evaluation
		 */
		int K = 0;
		try {
			K = Integer.valueOf(str1);
		} catch (Exception e) {
			System.err.println("Not valid input!");
		}

		if((K < 1) | (K > 25)) {
			return;
		}

		int[] arr = stringTointArray(str2, 1, 1000000);

		/*
		 * actual algorithm (after filtering data)
		 */

		for (int i = 0; i < (arr.length - 1); i++) {
			if (arr[i] == 1000000) {
				System.out.println((1000000 - 25));
				return;
			}
			if(arr[i] >= arr[i + 1]) {
				System.out.println("0");
				return;
			}
		}

		System.out.println((arr[arr.length - 1] - 25));

	}

	/**
	 * Method convert string to integer array in range min to max
	 * @param in	input string
	 * @param min	minimal integer value of array element
	 * @param max	maximal integer value of array element
	 * @return		array of integer created from string
	 */
	private static int[] stringTointArray(String in, int min, int max) {
		String[] str_arr = in.split(" ");
		int[] out = new int[str_arr.length];

		try {
			for (int i = 0; i < out.length; i++) {
				out[i] = Integer.valueOf(str_arr[i]);
				if ((out[i] < min) | (out[i] > max)) {
					System.err.println("Input data out of range!");
					return null;
				}
			}
		} catch (Exception e) {
			System.err.println("Wrong input data!");
			return null;
		}

		return out;
	}

}

// https://codeforces.com/problemset/problem/1374/B

import java.util.*;
import java.io.*;

public class mul2div6 {
    public static void main(String[] arg) {
        Scanner scan = new Scanner(System.in);

        int n = scan.nextInt();

        int moves = 0;

        int NewN = n;

        while (NewN < n * 4 && NewN > 1){
            if(NewN % 6 == 0){
                NewN = NewN / 6;
            }
            else{
                NewN = NewN * 2;
            }
            moves++;
        }

        //the impossible scenario
        if (NewN >= n * 4){
            System.out.println("-1");
        }
        //if it equals 1
        else{
            System.out.println(moves);
        }

    //declined finalist is doable
    //mislove array is harder
    //required remainder is math-invloving
    //photoshoot is god-tier

        //if at any time the new number is more than 3 times larger than the input,
        // then you know that it is impossible

    }
}

import java.util.*;
public class DeclinedFinalists {

	public static void main(String[] args) {
		Scanner sc=new Scanner(System.in);
		int n=sc.nextInt();
		int arr[]=new int[n];
		for(int i=0;i<n;i++) {
			arr[i]=sc.nextInt();
		}
		if(arr[n-1]<=25) {
		System.out.println(0);
		}
		else {
			System.out.println(arr[n-1]-25);
		}

	}

}