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
/*
 * @Author: Kaustav Vats  
 */
import java.io.*;
import java.util.*;
import java.math.*;
import java.lang.*;


public class PC {
    public static int N;

    public static void main(String[] args) throws IOException{
        Reader.init(System.in);
        N = Reader.nextInt();
        int[] Arr = new int[N];
        for (int i=0; i<N; i++) {
            Arr[i] = Reader.nextInt();
        }
        HashMap<Integer, Integer> Brr = new HashMap<>();
        Brr.put(4, 0);
        Brr.put(8, 0);
        Brr.put(15, 0);
        Brr.put(16, 0);
        Brr.put(23, 0);
        Brr.put(42, 0);

        for (int i=0; i<N; i++) {
            if (Arr[i] == 4) {
                Brr.put(4, Brr.get(4) + 1);
            }
            else if (Arr[i] == 8) {
                if (Brr.get(4) > 0) {
                    Brr.put(4, Brr.get(4) - 1);                    
                    Brr.put(8, Brr.get(8) + 1);
                }
            }
            else if (Arr[i] == 15) {
                if (Brr.get(8) > 0) {
                    Brr.put(8, Brr.get(8) - 1);                    
                    Brr.put(15, Brr.get(15) + 1);
                }
            }
            else if (Arr[i] == 16) {
                if (Brr.get(15) > 0) {
                    Brr.put(15, Brr.get(15) - 1);                    
                    Brr.put(16, Brr.get(16) + 1);
                }
            }
            else if (Arr[i] == 23) {
                if (Brr.get(16) > 0) {
                    Brr.put(16, Brr.get(16) - 1);                    
                    Brr.put(23, Brr.get(23) + 1);
                }
            }
            else if (Arr[i] == 42) {
                if (Brr.get(23) > 0) {
                    Brr.put(23, Brr.get(23) - 1);                    
                    Brr.put(42, Brr.get(42) + 1);
                }
            }
        }
        int count = Brr.get(42) * 6;
        System.out.println(N-count);

    }
}

/** Class for buffered reading int and double values */
class Reader {
    static BufferedReader reader;
    static StringTokenizer tokenizer;

    /** call this method to initialize reader for InputStream */
    static void init(InputStream input) {
        reader = new BufferedReader(
                     new InputStreamReader(input) );
        tokenizer = new StringTokenizer("");
    }

    /** get next word */
    static String next() throws IOException {
        while ( ! tokenizer.hasMoreTokens() ) {
            //TODO add check for eof if necessary
            tokenizer = new StringTokenizer(
                   reader.readLine() );
        }
        return tokenizer.nextToken();
    }

    static int nextInt() throws IOException {
        return Integer.parseInt( next() );
    }

    static long nextLong() throws IOException {
        return Long.parseLong( next() );
    }
	
    static double nextDouble() throws IOException {
        return Double.parseDouble( next() );
    }
}