You are given an array a consisting of n integers. Each a_i is one of the six following numbers: 4, 8, 15, 16, 23, 42.

Your task is to remove the minimum number of elements to make this array good.

An array of length k is called good if k is divisible by 6 and it is possible to split it into k/6 subsequences 4, 8, 15, 16, 23, 42.

Examples of good arrays:

  * [4, 8, 15, 16, 23, 42] (the whole array is a required sequence); 
  * [4, 8, 4, 15, 16, 8, 23, 15, 16, 42, 23, 42] (the first sequence is formed from first, second, fourth, fifth, seventh and tenth elements and the second one is formed from remaining elements); 
  * [] (the empty array is good). 



Examples of bad arrays: 

  * [4, 8, 15, 16, 42, 23] (the order of elements should be exactly 4, 8, 15, 16, 23, 42); 
  * [4, 8, 15, 16, 23, 42, 4] (the length of the array is not divisible by 6); 
  * [4, 8, 15, 16, 23, 42, 4, 8, 15, 16, 23, 23] (the first sequence can be formed from first six elements but the remaining array cannot form the required sequence). 

Input

The first line of the input contains one integer n (1 ≤ n ≤ 5 ⋅ 10^5) — the number of elements in a.

The second line of the input contains n integers a_1, a_2, ..., a_n (each a_i is one of the following numbers: 4, 8, 15, 16, 23, 42), where a_i is the i-th element of a.

Output

Print one integer — the minimum number of elements you have to remove to obtain a good array.

Examples

Input


5
4 8 15 16 23


Output


5


Input


12
4 8 4 15 16 8 23 15 16 42 23 42


Output


0


Input


15
4 8 4 8 15 16 8 16 23 15 16 4 42 23 42


Output


3

import java.io.BufferedReader;
import java.util.*;
import java.io.IOException;
import java.io.InputStreamReader;
 
public class CODE{
    static class FastReader {
        BufferedReader br;
        StringTokenizer st;
 
        public FastReader()
        {
            br = new BufferedReader(
                new InputStreamReader(System.in));
        }
 
        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()); }
 
        double nextDouble()
        {
            return Double.parseDouble(next());
        }
 
        String nextLine()
        {
            String str = "";
            try {
                str = br.readLine();
            }
            catch (IOException e) {
                e.printStackTrace();
            }
            return str;
        }
        boolean hasNext() {
            if (st != null && st.hasMoreTokens()) {
                return true;
            }
            String tmp;
            try {
                br.mark(1000);
                tmp = br.readLine();
                if (tmp == null) {
                    return false;
                }
                br.reset();
            } catch (IOException e) {
                return false;
            }
            return true;
        }
    }
 
    static int solve(int arr[],int given[],int m,int n)
    {
    	if((m==0 && n==0) || n==0)
    		return 1;
    	
    	if(m==0)
    		return 0;
    	
    	if(arr[m-1]==given[n-1]) {
    		System.out.println(arr[m-1]);
    		return solve(arr,given,m-1,n-1)+solve(arr,given,m-1,n);}
    	else
    		return solve(arr,given,m-1,n);
    }
    
    
    public static void main(String[] args)
    {
    	FastReader sc=new FastReader();
    	int n=sc.nextInt();
    	StringBuilder s=new StringBuilder();
    	String s1="abcdef";
    		for(int i=0;i<n;i++)
    		{
    			int temp=sc.nextInt();
    			if(temp==4) s.append('a'); if(temp==8)s.append('b'); if(temp==15)s.append('c');if(temp==16)s.append('d');
    			if(temp==23) s.append('e'); if(temp==42)s.append('f');
    		}
    		int a=0,b=0,c=0,d=0,e=0,f=0;
    		int ans=0;
    		
    		if(s.length()<6) {
    			System.out.println(s.length());
    			return;
    		}
    		
    		
    		for(int i=0;i<s.length();i++)
    		{
    			if(s.charAt(i)=='a') {  a++;}
    			if(s.charAt(i)=='b') { if(b+1>a) ans++; else b++;}
    			if(s.charAt(i)=='c') { if(c+1>b) ans++; else c++;}
    			if(s.charAt(i)=='d') { if(d+1>c) ans++; else d++;}
    			if(s.charAt(i)=='e') { if(e+1>d) ans++; else e++;}
    			if(s.charAt(i)=='f') { if(f+1>e) ans++; else f++;}
    		}
    		System.out.println(n-(f*6));
    	
		}
      
       
    

}
