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
//package codeforces.div2;

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

public class Lostit {

    static public void print(int arr[]) {


        List<Integer> a = new ArrayList<>();
        List<Integer> b = new ArrayList<>();
        List<Integer> c = new ArrayList<>();
        List<Integer> d = new ArrayList<>();
        List<Integer> e = new ArrayList<>();
        List<Integer> f  = new ArrayList<>();

        if(arr.length < 6) {
            System.out.println(arr.length);
        } else {

            for(int i = 0; i < arr.length; i++) {
                if(arr[i] == 4 ) { // 4,8,15,16,23,42.
                   a.add(i);
                } else {
                    if(arr[i] == 8) {
                        b.add(i);
                    } else {
                        if(arr[i] == 15) {
                            c.add(i);
                        } else {
                            if(arr[i] == 16) {
                                d.add(i);
                            } else {
                                if(arr[i] == 23) {
                                    e.add(i);
                                } else {
                                    f.add(i);
                                }
                            }
                        }
                    }
                }
            }

            int iOne = 0;
            int bOne = 0;
            int cOne = 0;
            int dOne = 0;
            int eOne = 0;
            int fOne = 0;
            int count = 0;
            int track = 0;
            while (iOne < a.size() && bOne < b.size() && cOne < c.size() && dOne < d.size() && eOne < e.size()
            && fOne < f.size()) {
                if((a.get(iOne) < b.get(bOne)) && b.get(bOne) < c.get(cOne) && c.get(cOne) < d.get(dOne) && d.get(dOne) < e.get(eOne) && e.get(eOne) < f.get(fOne)) {
                    count = count + 6;
                    iOne++;
                    bOne++;
                    cOne++;
                    dOne++;
                    eOne++;
                    fOne++;
                } else {
                    if(a.get(iOne) > b.get(bOne)) {
                        bOne++;
                        track++;
                    } else {
                        if(b.get(bOne) > c.get(cOne)) {
                            cOne++;
                            track++;
                        } else {
                            if( c.get(cOne) > d.get(dOne)) {
                                dOne++;
                                track++;
                            } else {
                                if( d.get(dOne) > e.get(eOne)) {
                                    track++;
                                    eOne++;
                                } else {
                                    if(e.get(eOne) > f.get(fOne)) {
                                        fOne++;
                                        track++;
                                    }
                                }
                            }
                        }
                    }
                }
            }
            while (iOne < a.size()) {
                track++;
                iOne++;
            }
            while (bOne < b.size()) {
                track++;
                bOne++;
            }
            while (cOne < c.size()) {
                track++;
                cOne++;
            }
            while (dOne < d.size()) {
                dOne++;
                track++;
            }
            while (eOne < e.size()) {
                eOne++;
                track++;
            }
            while (fOne < f.size()) {
                fOne++;
                track++;
            }
            System.out.println(track);
        }
    }

    public static void main(String []args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int i = 0;
        int arr[] = new int[n];
        while ( i < n) {
            arr[i++] = sc.nextInt();
        }
        print(arr);
    }
}
