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.sql.Array;
import java.util.*;

public class Main {

    public static void main(String[] args) {

        FastReader in =new FastReader();
        OutputStream outputStream=System.out;
        PrintWriter out=new PrintWriter(outputStream);
        A solver=new A();
        solver.solve(1,in,out);
        out.close();
//        String s=read.next();
//        int x=read.nextInt();
//        long y=read.nextLong();
//        double v=read.nextDouble();


    }

    public static class A {
        static Random rand = new Random(232345325234L);
        static long mod = 1000000007;

        void shuffle(int[] tab) {
            int n = tab.length;
            for (int i = 0; i < n; ++i) {
                int nxt = rand.nextInt(n);
                int temp = tab[nxt];
                tab[nxt] = tab[i];
                tab[i] = temp;
            }
        }

        static long power(long x, long y, long p)
        {
            long res = 1;
            x = x % p;
            while (y > 0)
            {
                if((y & 1)==1)
                    res = (res * x) % p;
                y = y >> 1;// y/=2;
                x = (x * x) % p;
            }
            return res;
        }

        public void solve(int testcases, FastReader in, PrintWriter out) {

            int n = in.nextInt();
            int[] arr = new int[n];
            int[] seq = new int[43];
            int s=n/6;
            if(s<1) out.println(n);
            else {
                for (int i = 0; i < n; i++) arr[i] = in.nextInt();
                for(int i = 0; i < n; i++){
                    if(arr[i]==4) seq[4]++;
                    if(arr[i]==8) {
                        if(seq[4]>seq[8]) seq[8]++;
                    }
                    if(arr[i]==15) {
                        if(seq[8]>seq[15]) seq[15]++;
                    }
                    if(arr[i]==16) {
                        if(seq[15]>seq[16]) seq[16]++;
                    }
                    if(arr[i]==23) {
                        if(seq[16]>seq[23]) seq[23]++;
                    }
                    if(arr[i]==42) {
                        if(seq[23]>seq[42]) seq[42]++;
                    }
                }
                int ans=n-(6*seq[42]);
                out.println(ans);
            }

        }
    }

    public static class FastReader{

        BufferedReader br ;
        StringTokenizer st;

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

        }

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

    }
}