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.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.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.*;
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 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.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.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.*;

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

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.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.*;
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.*;

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) {
		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.*;
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.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.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.*;
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 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);
		}
	}
}

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

/**
 * 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.*;

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.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.*;

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

}

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 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.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.*;

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

/* 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.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 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.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.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.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.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.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.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.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.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.*;
    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);
    	}
    }

/*
 * 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.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.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.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.*;
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.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.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;
        }

    }
}

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[]){
        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 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 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.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.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 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.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 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.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.*;

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

	}

}