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.*;
import java.math.*;
import java.security.KeyStore.Entry;
import java.util.*;

public class my {
	private static boolean[] vis;
	private static long[] dist;
	private static long mod = 1000000000 + 7;
	public static void merge(int arr[], int l, int m, int r) 
    { 
        // Find sizes of two subarrays to be merged 
        int n1 = m - l + 1; 
        int n2 = r - m; 
  
        /* Create temp arrays */
        int L[] = new int [n1]; 
        int R[] = new int [n2]; 
  
        /*Copy data to temp arrays*/
        for (int i=0; i<n1; ++i) 
            L[i] = arr[l + i]; 
        for (int j=0; j<n2; ++j) 
            R[j] = arr[m + 1+ j]; 
  
  
        /* Merge the temp arrays */
  
        // Initial indexes of first and second subarrays 
        int i = 0, j = 0; 
  
        // Initial index of merged subarry array 
        int k = l; 
        while (i < n1 && j < n2) 
        { 
            if (L[i] <= R[j]) 
            { 
                arr[k] = L[i]; 
                i++; 
            } 
            else
            { 
                arr[k] = R[j]; 
                j++; 
            } 
            k++; 
        } 
  
        /* Copy remaining elements of L[] if any */
        while (i < n1) 
        { 
            arr[k] = L[i]; 
            i++; 
            k++; 
        } 
  
        /* Copy remaining elements of R[] if any */
        while (j < n2) 
        { 
            arr[k] = R[j]; 
            j++; 
            k++; 
        } 
    } 
	 public static void sort(int arr[], int l, int r) 
	    { 
	        if (l < r) 
	        { 
	            // Find the middle point 
	            int m = (l+r)/2; 
	  
	            // Sort first and second halves 
	            sort(arr, l, m); 
	            sort(arr , m+1, r); 
	  
	            // Merge the sorted halves 
	            merge(arr, l, m, r); 
	        } 
	    } 
	 private static int gcd(int n, int l) {
	        if (l == 0)
	            return n;
	        return gcd(l, n % l);
	    }
//	 public static void dfs(ArrayList<Integer>[] gr,int v,int[] ans,HashMap<Integer,HashMap<Integer,Integer>> map)
//	    {
//	         vis[v]=true;
//	         ArrayList<Integer> arr=gr[v];
//	         for(int i=0;i<arr.size();i++)
//	         {
//	             if(!vis[arr.get(i)])
//	             {  
//	            	 
//	            	 dfs(gr,arr.get(i));
//	             }
//	         }
//	    }
	 private static class Pairs implements Comparable<Pairs>{
	        String v;int i;int j;
	        public Pairs(String a,int b,int c){
	            v=a;
	            i=b;
	            j=c;
	        }
	        @Override
	        public int compareTo(Pairs arg0) {
	            {
	            	if(!this.v.equals(arg0.v))
	            		return this.v.compareTo(arg0.v);
	            	else
	            		return arg0.i-this.i;
	            }
	        }
	    }
	 private static class Pair implements Comparable<Pair>{
	        int v,i;Pair j;
	        public Pair(int a,int b){
	            v=a;
	            i=b;
	        }
	        public Pair(int a,Pair b)
	        {
	            v=a;
	            j=b;
	        }
	        @Override
	        public int compareTo(Pair arg0) {
	            {
	            	return this.v-arg0.v;
	            }
	        }
	    }
	 public static long mmi(long a, long m) 
	    { 
	        long m0 = m; 
	        long y = 0, x = 1; 
	      
	        if (m == 1) 
	          return 0; 
	      
	        while (a > 1) 
	        { 
	            // q is quotient 
	            long q = a / m; 
	            long t = m; 
	      
	            // m is remainder now, process same as 
	            // Euclid's algo 
	            m = a % m; a = t; 
	            t = y; 
	      
	            // Update y and x 
	            y = x - q * y; 
	            x = t; 
	        } 
	      
	        // Make x positive 
	        if (x < 0) 
	           x += m0; 
	      
	        return x; 
	    }
	private static long pow(long a, long b, long c) {
	        if (b == 0)
	            return 1;
	        long p = pow(a, b / 2, c);
	        p = (p * p) % c;
	        return (b % 2 == 0) ? p : (a * p) % c;
	    }
	public static int ub(ArrayList<Integer> array, int low,int high, int value) {
        while (low < high) {
            final int mid = (low + high) / 2;
            if (value >= array.get(mid)) {
                low = mid + 1;
            } else {
                high = mid;
            }
        }
        return low;
	}
	public static void main(String[] args) throws Exception
	{
		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(n<6)
			System.out.println(n);
		else
		{
			ArrayList<Integer>[] g=new ArrayList[6];
			for(int i=0;i<6;i++)	g[i]=new ArrayList<>();
			for(int i=0;i<n;i++)
			{
				if(arr[i]==4)	g[0].add(i);
				else if(arr[i]==8)	g[1].add(i);
				else if(arr[i]==15) g[2].add(i);
				else if(arr[i]==16)	g[3].add(i);
				else if(arr[i]==23)	g[4].add(i);
				else g[5].add(i);
			}
			int k=0;boolean f=false;
			int k1=-1,k2=-1,k3=-1,k4=-1,k5=-1;
			//for(int i=0;i<6;i++)	System.out.println(g[i]);
			while(true)
			{
				if(g[0].size()<=k)
					break;
				int e1=g[0].get(k);
				int e2=ub(g[1],k1+1,g[1].size(),e1);
				if(e2==g[1].size())	break;
				else	k1=e2;
				//System.out.print(e2+" ");
				int e3=ub(g[2],k2+1,g[2].size(),g[1].get(e2));
				if(e3==g[2].size())	break;
				else	k2=e3;
				//System.out.print(e3+" ");
				int e4=ub(g[3],k3+1,g[3].size(),g[2].get(e3));
				if(e4==g[3].size())	break;
				else	k3=e4;
				//System.out.print(e4+" ");
				int e5=ub(g[4],k4+1,g[4].size(),g[3].get(e4));
				if(e5==g[4].size())	break;
				else	k4=e5;
				//System.out.print(e5+" ");
				int e6=ub(g[5],k5+1,g[5].size(),g[4].get(e5));
				if(e6==g[5].size())	break;
				else	k5=e6;
				//System.out.print(e6+" ");
				k++;
			}
			System.out.println(n-6*k);
		}
	}
}
