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
from collections import defaultdict
import sys


def find(ol, s): #find the first element e in order list ol, such that e > s
    if len(ol) < 5:
        return straight_search(ol, s)
    else:
        return bin_search(ol, s)

def straight_search(ol, s):
    for i in ol:
        if i >= s:
            return i
    return None

def bin_search(ol, k):
    s = 0
    e = len(ol) - 1
    while (e - s) > 6:
        m = (s + e) // 2
        if ol[m] > k:
            e = m
        elif ol[m] < k:
            s = m
        else:
            s = m
    return straight_search(ol[s:e+1], k)

def build_index(a):
    index = defaultdict(list)
    for pos, e in enumerate(a):
        index[e].append(pos)
    for k in [4,8,15,16,23,42]:
        if k not in index:
            index[k] = []
    index_pointer = dict([(k, v[0] if v else 99999999999999999)
                          for k, v in index.items()])
    return (index, index_pointer)

def find_pattern(index, index_pointer):
    pt = [4,8,15,16,23,42]
    last = None
    for e in pt:
        ol = index[e]
        pointer = index_pointer[e]
        if last:
            pointer = max(pointer, last)
        r = find(ol, pointer)
        if r is None:
            return None
        index_pointer[e] = r + 1
        last = r + 1
    return "ok"

def solve(a):
    index, index_pointer = build_index(a)
    n = 0
    while True:
        if find_pattern(index, index_pointer) == "ok":
            n += 1
        else:
            break

    return len(a) - n*6

if __name__ == "__main__":
    sys.stdin.readline()
    print(solve([int(i) for i in sys.stdin.readline().strip().split()]))
