Anton's favourite geometric figures are regular polyhedrons. Note that there are five kinds of regular polyhedrons: 

  * Tetrahedron. Tetrahedron has 4 triangular faces. 
  * Cube. Cube has 6 square faces. 
  * Octahedron. Octahedron has 8 triangular faces. 
  * Dodecahedron. Dodecahedron has 12 pentagonal faces. 
  * Icosahedron. Icosahedron has 20 triangular faces. 



All five kinds of polyhedrons are shown on the picture below:

<image>

Anton has a collection of n polyhedrons. One day he decided to know, how many faces his polyhedrons have in total. Help Anton and find this number!

Input

The first line of the input contains a single integer n (1 ≤ n ≤ 200 000) — the number of polyhedrons in Anton's collection.

Each of the following n lines of the input contains a string si — the name of the i-th polyhedron in Anton's collection. The string can look like this:

  * "Tetrahedron" (without quotes), if the i-th polyhedron in Anton's collection is a tetrahedron. 
  * "Cube" (without quotes), if the i-th polyhedron in Anton's collection is a cube. 
  * "Octahedron" (without quotes), if the i-th polyhedron in Anton's collection is an octahedron. 
  * "Dodecahedron" (without quotes), if the i-th polyhedron in Anton's collection is a dodecahedron. 
  * "Icosahedron" (without quotes), if the i-th polyhedron in Anton's collection is an icosahedron. 

Output

Output one number — the total number of faces in all the polyhedrons in Anton's collection.

Examples

Input

4
Icosahedron
Cube
Tetrahedron
Dodecahedron


Output

42


Input

3
Dodecahedron
Octahedron
Octahedron


Output

28

Note

In the first sample Anton has one icosahedron, one cube, one tetrahedron and one dodecahedron. Icosahedron has 20 faces, cube has 6 faces, tetrahedron has 4 faces and dodecahedron has 12 faces. In total, they have 20 + 6 + 4 + 12 = 42 faces.
import java.util.*;
import java.math.*;
import java.io.*;
import java.lang.*;
public class Main{

	static int N = (int) (1e6+10);
	static boolean [] vis = new boolean [N];
	static List<Long> prime = new ArrayList<>();

	// prime number
	static void seive(){
		for(int i=2;i<N;i++){
			if(!vis[i]){
				for(int j=i;j<N;j+=i){
					vis[j] = true;
				}
				prime.add((long)i);
			}
		}
	}
	// prime number ends*/

	// sorting (quick sort)
	static int partition(int arr[], int low, int high){
		int pivot = arr[high];
		int i = (low-1);
		for(int j=low;j<high;j++){
			if(arr[j] < pivot){
				i++;
				int temp = arr[i];
				arr[i] = arr[j];
				arr[j] = temp;
			}
		}
		int temp = arr[i+1];
		arr[i+1] = arr[high];
		arr[high] = temp;

		return i+1;
	}
	static void sort(int arr[], int low, int high){
		if(low<high){
			int pi = partition(arr, low, high);
			sort(arr, low, pi-1);
			sort(arr, pi+1, high);
		}
	}
	// sorting ends
    
    // find max from two int
	static int max(int a, int b){
		if(a > b){
			return a;
		}
		else if(a < b){
			return b;
		}
		else
			return a;
	}
	// max ends

	// find min from two int
	static int min(int a, int b){
		if(a < b){
			return a;
		}
		else if(a > b){
			return b;
		}
		else
			return a;
	}
	// min ends

	// find GCD from two long
/*	static long gcd(long x, long y){
        if(x==0)
            return y;
        if(y==0)
            return x;
        long r=0, a, b;
        a = Math.max(x, y);
        b = Math.min(x, y);
        r = b;
        while(a % b != 0){
            r = a % b;
            a = b;
            b = r;
        }
        return r;
    }
    // gcd ends*/

    // find lcm from two long 
    static long gcd(long a, long b){
    	if(a == 0){
    		return b;
    	}
    	return gcd(b%a, a);
    }
    static long lcm(long a, long b){
    	return (a/gcd(a,b))*b;
    }
    // lcm ends

    // modulo
    static long modulo(long a,long b,long c){
        long x=1,y=a%c;
        while(b > 0){
            if(b%2 == 1)
                x=(x*y)%c;
            y = (y*y)%c;
            b = b>>1;
        }
        return  x%c;
    }
    // modulo ends

    // binary search
    public static int binarysearch(int arr[], int l, int r, int x) {
		if (r >= l) {
			int mid = l + (r - l) / 2;
			if (arr[mid] == x)
				return mid;
			if (arr[mid] > x)
				return binarysearch(arr, l, mid - 1, x);
			return binarysearch(arr, mid + 1, r, x);
		}
		return -1;
	}
	// binary search ends

	// transform into absolute form of an int
	public static int abs(int a){
		if(a < 0){
			return -1*a;
		}
		return a;
	}
	// abs ends

	static Scanner sc = new Scanner(System.in);
	//int t = sc.nextInt()   // take input 

	static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
	//int t = Integer.parseInt(br.readLine());   // take input
	//long n = Long.parseLong(br.readline());   // take input

	// Debug | Run
	public static void main(String [] args)throws IOException{
        int n = sc.nextInt();
        String s[] = new String[n];
        s[0] = sc.nextLine();
        for(int i = 0; i<n; i++){
            s[i] = sc.nextLine(); 
        }
        int c = 0;
        for(int i = 0; i<n; i++){
        
            if(s[i].equals("Tetrahedron")) {
            
                c = c + 4;
            }
            else if(s[i].equals("Cube")) {
            
                c = c + 6;
            }
            else if(s[i].equals("Octahedron")){
            
                c = c + 8;
            }
            else if(s[i].equals("Dodecahedron")) {
            
                c = c + 12;
            }
            else {
            
                c = c + 20;
            }
        }
        System.out.println(c);  
	}	
}