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.util.HashMap;
import java.util.Map;

public class A {
    public static void main(String[] args) throws IOException {
        BufferedReader inp = new BufferedReader(new InputStreamReader(System.in));
        BufferedWriter out = new BufferedWriter(new OutputStreamWriter(System.out));
        int size = Integer.parseInt(inp.readLine());
        int[] given = new int[size];
        String[] s1 = inp.readLine().split(" ");
        for(int i=0;i<size;i++){
            given[i] = Integer.parseInt(s1[i]);
        }
        Map<Integer,Integer> map = new HashMap<>();
        int[] count = new int[43];
        for(int i=0;i<size;i++){
            if(given[i]==4){
                count[4]++;
            }
            if(given[i]==8){
                if(count[4]>count[8]){
                    count[8]++;
                }
            }
            if(given[i]==15){
                if(count[4]>count[15] && count[8]>count[15]){
                    count[15]++;
                }
            }
            if(given[i]==16){
                if(count[4]>count[16] && count[8]>count[16] && count[15]>count[16]){
                    count[16]++;
                }
            }
            if(given[i]==23){
                if(count[4]>count[23] && count[8]>count[23] && count[15]>count[23] && count[16]>count[23]){
                    count[23]++;
                }
            }
            if(given[i]==42){
                if(count[4]>count[42] && count[8]>count[42] && count[15]>count[42] && count[16]>count[42] && count[23]>count[42]){
                    count[42]++;
                }
            }

        }
        int min = Integer.MAX_VALUE;
        min = Math.min(count[4],min);
        min = Math.min(count[8],min);
        min = Math.min(count[15],min);
        min = Math.min(count[16],min);
        min = Math.min(count[23],min);
        min = Math.min(count[42],min);

        min = min*6;
        System.out.println(size-min);
    }
}
