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

public class E1176C2 {
    static int q;
    static int [] startS ;
    static int [] endS   ;
    static final int STATES = 6;
    static int head = -1;

    // find beginning pos
    static int lastEnd(int pos) {
//        for (int i= 1; i + pos <= STATES -1; i++ ) {
//            if (endS[i+pos ] != -1) {
//                return (endS[i+pos ] +1);
//            }
//        }
//        return 0;
        head ++;
        return head;
    }
    
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        q = in.nextInt();
        int [] data = new int [q];
        
        for (int i=0; i< q; i++ ) {
            int temp = in.nextInt();
            switch (temp)  {
                case 4: data[i] = -1; break;
                case 8: data[i] = 0; break;
                case 15:data[i] = 1; break;
                case 16:data[i] = 2; break;
                case 23:data[i] = 3; break;
                case 42:data[i] = 4; break;
            }
        }
        
        int readP = 0;
    
        startS = new int [STATES];
        endS   = new int [STATES];
        
        for (int i=0; i< STATES; i++) {
            startS[i] = -1;
            endS[i] = -1;
        }
        
        while (readP < q) {
            if (data[readP] == -1 ) {
                endS[0] = lastEnd(-1);
                if (startS[0] == -1) {
                    startS[0] = endS[0];
                }
                readP ++;
                continue;
            }            

            if (startS[data[readP]] != -1) {
                if (startS [data[readP]] == endS[data[readP]]) {
//                    if (data[readP] != 4) {

                        endS[ data[readP] +1] = startS [data[readP]];
                        if (startS[ data[readP] +1] == -1 ) {
                            startS[ data[readP] +1] = startS [data[readP]];
                        }
                        startS [data[readP]] = -1;
                        endS[data[readP]] = -1;                        
//                    }
                }
                else {

//                    if (data[readP] != 4) {
                        endS[ data[readP] +1] = startS [data[readP]];
                        if (startS[ data[readP] +1] == -1 ) {
                            startS[ data[readP] +1] = startS [data[readP]];
                        }
                        startS [data[readP]] ++;                        
//                    }
                }
            }

            readP ++;
        }      
        out(Integer.toString(q - (endS [5] +1)* 6) + "\n");
    }

    private static void out(String s) {
        System.out.print(s);
        System.exit(0);        
    }        
}
