The recent All-Berland Olympiad in Informatics featured n participants with each scoring a certain amount of points.

As the head of the programming committee, you are to determine the set of participants to be awarded with diplomas with respect to the following criteria: 

  * At least one participant should get a diploma. 
  * None of those with score equal to zero should get awarded. 
  * When someone is awarded, all participants with score not less than his score should also be awarded. 



Determine the number of ways to choose a subset of participants that will receive the diplomas.

Input

The first line contains a single integer n (1 ≤ n ≤ 100) — the number of participants.

The next line contains a sequence of n integers a1, a2, ..., an (0 ≤ ai ≤ 600) — participants' scores.

It's guaranteed that at least one participant has non-zero score.

Output

Print a single integer — the desired number of ways.

Examples

Input

4
1 3 3 2


Output

3


Input

3
1 1 1


Output

1


Input

4
42 0 0 42


Output

1

Note

There are three ways to choose a subset in sample case one.

  1. Only participants with 3 points will get diplomas. 
  2. Participants with 2 or 3 points will get diplomas. 
  3. Everyone will get a diploma! 



The only option in sample case two is to award everyone.

Note that in sample case three participants with zero scores cannot get anything.
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Scanner;
import java.util.TreeMap;




public class Main {

	
	private static Scanner in = new Scanner(System.in);
	 

	
	public static void main(String[] args) {
		
		
		int n = in.nextInt();
		
		HashSet<Integer> set = new HashSet<>();
		
		for (int i = 0; i < n; i++) {
			int temp = in.nextInt();
			if(temp>0) set.add(temp);
		}
		
		System.out.println(set.size());
		
	} 
	
	static int diameter(int [] a) {
		return a[a.length - 1] - a [0];
	}
	static StringBuilder transform(StringBuilder S) {
		
	
		for (int i = 0; i < S.length() -1; i++) {
			
			char c = S.charAt(i);
			char cc = S.charAt(i+1);
			
			if(c=='a' || c=='e' || c=='i' || c=='u' || c=='o' || c=='y') {
				if(cc=='a' || cc=='e' || cc=='i' || cc=='u' || cc=='o' || cc=='y') {
					S.deleteCharAt(i+1);					
				}			
			}
		}
		
		return S;
	}

	
	static boolean hasVowels(StringBuilder S) {
		for (int i = 0; i < S.length()-1; i++) {
			char c = S.charAt(i);
			char cc = S.charAt(i+1);
			if(c=='a' || c=='e' || c=='i' || c=='u' || c=='o' || c=='y') {
				if(cc=='a' || cc=='e' || cc=='i' || cc=='u' || cc=='o' || cc=='y') {
					return true;
				}
			}
		}
		
		return false;
	}
	
	static int sum(int [] f, int n) {
		
		int result = 0;
		
		for (; n>=0; n= (n & (n + 1)) - 1) {
			result+=f[n];
		}
		return result;
	}
	//сумма элементов от l до r
	static int summa(int [] f, int l, int r) {
	    if (l>0) {
	        return sum(f,r) - sum(f,l - 1);
	    } else {
	        return sum(f,r);
	    }
	}
	
	static void increase(int [] a, int []f ,int idx, int delta) {
	    a[idx] += delta;
	 
	    for (; idx < a.length; idx |= idx + 1) {
	        f[idx] += delta;
	    }
	}
	
	static boolean isSquare(int n) {
		return (int)Math.sqrt(n)==Math.sqrt(n);
	}
	static int sumOfNumbers(int n) {
		int sum = 0;
		while(n>0) {
			sum+=n%10;
			n/=10;
		}
		return sum;
	}
	static int [] fibonacci(int n) {
		int [] f = new int[n];
		f[0]=1;
		f[1]=1;
		
		for (int i = 2; i < f.length; i++) {
			f[i]=f[i-1]+f[i-2];
		}
		
		return f;
	}
	static long fact(long n) {
		if(n<=1) return 1;
		else return n*fact(n-1);
	}
	static void closeLeft(int [] a , int l) {
		for (int i = 0; i < l; i++) {
			a[i]=1;
		}
	}
	static void closeRight (int [] a, int r) {
		for (int i = r+1; i < a.length; i++) {
			a[i]=1;
		}
	}
	static boolean isFinish(int [] a) {
		
		int num = 0;
		
		for (int i = 0; i < a.length; i++) {
			if(a[i]==-1 || a[i]==1) num++;
		}

		return num==a.length;
	}
	
	static int findAPeak(int [] a) {
		
		int n = a.length;
		
		int lo = 0;
		int hi = n-1;
		
		while(lo<=hi) {
			
			int mid = lo+(hi-lo)/2;
			if(a[mid]<a[mid-1]) hi = mid-1;
			else if(a[mid]<a[mid+1]) lo=mid+1;
			else return mid;
			
		}	
		
		
		return -1;
	}
	 static HashMap<String, ArrayList<String>> solve(HashMap<String, String []> map) {
		
		boolean flag = false;
		 
		HashMap<String, ArrayList<String>> ans = new HashMap<>();
		
		for (Map.Entry<String, String []> m : map.entrySet()) {
			String [] ss = m.getValue();
			for (int i = 0; i < ss.length; i++) {
				for (int j = i+1; j < ss.length; j++) {
					if(ss[j].endsWith(ss[i]))  {
						flag = true;
						break;
					}					
				}
				if(!flag) {
				//	ans.put(m.getKey(), value)
				}
			}
		}
		
		return null;
	}
	
	static void fillAnArray(long [] a) {
		for (int i = 0; i < a.length - 1; i++) {
			a[i]=in.nextLong();
		}
	}
	static int []  shuffleAnArray(int [] a) {
		
		for (int i = 0; i < a.length; i++) {
			int index = (int)(Math.random()*a.length);
			int temp = a[i];
			a[i]=a[index];
			a[index]=temp;			
		}
				
		return a;
		
	}
	static int gcd(int a,int b) {
		return a==0 ? b : gcd(b%a,a);
	}
	
	static boolean eulerFunction(int n, int k) {
		return gcd(n,k)==1;
	}
	static String operate(String S, int l,int r,char o,char n) {
		
		String ss = "";
		
		for (int i = 0; i < S.length() ; i++) {
			
			if(i>=l-1 && i<=r-1) {
				
				if(S.charAt(i)== o) {
					ss+=n;
				}
				
				else {
					ss+=S.charAt(i);
				}
			}
			else {
				ss+=S.charAt(i);
			}
		}
		
		return ss;
	}
	static int sumOfArray(int [] a) {
		int sum = 0;
		for (int i = 0; i < a.length; i++) 
			if(a[i]>0)sum+=a[i];			
		return sum;
	}
	
	private static long convert(int i) {
		long res = i;
		while(i>0){
			int lastNum = i % 10;
			res = res * 10 + lastNum;
			i /=10;
		}
		
		return res;
	}

	static int numberOfElementsAboveZero(int [] a) {
		int num = 0;
		for (int i = 0; i < a.length; i++) {
			if(a[i]>0) num++;
		}		
		return num;
	}
	static int min(int [] a) {
		int min = Integer.MAX_VALUE;
		for (int i = 0; i < a.length; i++) {
			if(a[i]>0 && a[i]<min) {
				min=a[i];
			}
		}
		return min;
	}
	static void dis(int [] a ,int min) {
		for (int i = 0; i < a.length; i++) {
			a[i]-=min;
		}
	}
	static boolean isPrime(int n) {
		
		if(n < 2) return false;
		
		for (int i = 2; i <= (int)Math.sqrt(n); i++) 
			if(n%i==0) return false;
			return true;
		
	}

}
