import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        int[][] tiles = new int[n][n];
        
        for(int i = 0; i < n; i++) {
            for(int j = 0; j < n; j++) {
                tiles[i][j] = scanner.nextInt();
            }
        }
        
        System.out.println(solve(n, tiles));
        scanner.close();
    }
    
    public static int solve(int n, int[][] tiles) {
        int[][] dp2 = new int[n][n];
        int[][] dp5 = new int[n][n];
        
        int[][] factors2 = new int[n][n];
        int[][] factors5 = new int[n][n];
        
        for(int i = 0; i < n; i++) {
            for(int j = 0; j < n; j++) {
                factors2[i][j] = countFactor(tiles[i][j], 2);
                factors5[i][j] = countFactor(tiles[i][j], 5);
            }
        }
        
        dp2[0][0] = factors2[0][0];
        dp5[0][0] = factors5[0][0];
        
        for(int j = 1; j < n; j++) {
            dp2[0][j] = dp2[0][j-1] + factors2[0][j];
            dp5[0][j] = dp5[0][j-1] + factors5[0][j];
        }
        
        for(int i = 1; i < n; i++) {
            dp2[i][0] = dp2[i-1][0] + factors2[i][0];
            dp5[i][0] = dp5[i-1][0] + factors5[i][0];
        }
        
        for(int i = 1; i < n; i++) {
            for(int j = 1; j < n; j++) {
                dp2[i][j] = Math.min(dp2[i-1][j], dp2[i][j-1]) + factors2[i][j];
                dp5[i][j] = Math.min(dp5[i-1][j], dp5[i][j-1]) + factors5[i][j];
            }
        }
        
        return Math.min(dp2[n-1][n-1], dp5[n-1][n-1]);
    }
    
    public static int countFactor(int num, int factor) {
        if(num == 0) return Integer.MAX_VALUE;
        int count = 0;
        while(num % factor == 0) {
            count++;
            num /= factor;
        }
        return count;
    }
}

#include <bits/stdc++.h>
using namespace std;
int solve(string s)
{
    if (s.empty()) 
        return 0;
    int n = s.size();
    char lastchar = s[s.size() - 1];
    char firstchar = s[0];
    vector<int> indexlast;
    for (int i = 0; i < n; i++) {
        if (s[i] == lastchar)
            indexlast.push_back(i);
    }

    int mini = INT_MAX;
    for (int i = 0; i < n; i++) {
        if (s[i] == firstchar) {
            int index = *lower_bound(indexlast.begin(), indexlast.end(), i);
            mini = min(mini, index - i + 1);
        }
    }

    return n - mini;
}

#include <iostream>
#include <string>
using namespace std;
string runLengthEncoding(const string& input) {
    if (input.empty()) return ""; 
    
    string result = "";
    int n = input.size();
    
    int count = 1;  
    
    for (int i = 1; i < n; ++i) {
        if (input[i] == input[i - 1]) {
            count++;
        } else {
            result += to_string(count) + input[i - 1];
            count = 1; 
        }
    }
    
    result += to_string(count) + input[n - 1];
    
    return result;
}

#include <iostream>
#include <vector>
#include <set>
#include <algorithm>
using namespace std;

void generatePermutations(string &s, int index, set<string> &result) {
    if (index == s.size()) {
        result.insert(s);  
        return;
    }
    
    for (int i = index; i < s.size(); ++i) {
        swap(s[index], s[i]);
        generatePermutations(s, index + 1, result);  
        swap(s[index], s[i]);  
    }
}

vector<string> solve(string s) {
    if (s.length() < 0 || s.length() > 5 || !all_of(s.begin(), s.end(), ::islower)) {
        return {};
    }

    set<string> result; 
    sort(s.begin(), s.end()); 
    generatePermutations(s, 0, result); 
    
    vector<string> resultVector(result.begin(), result.end());  
    return resultVector;
}

def solve(rectangles):
    covered = set()
    for width, height in rectangles:
        for x in range(width):
            for y in range(height):
                covered.add((x, y)) 
    return len(covered)

def main():
    n = int(input())
    rectangles = []
    for _ in range(n):
        width, height = map(int, input().split())
        rectangles.append((width, height))
    result = solve(rectangles)
    print(result)
if __name__ == "__main__":
    main()

int fun(int node, int parent, vector<vector<int> >&adj, vector<int>&weight, int &maxi)
{
    int sum1 = 0;
    for(auto it:adj[node])
    {
        if(it != parent)
        {
            sum1 += fun(it,node,adj,weight,maxi);
        }
    }

    sum1 = max(sum1,weight[node-1]);
    maxi = max(maxi,sum1);
    return sum1;
}

int findMaximumSum(int tree_nodes, vector<int> tree_from, vector<int> tree_to, vector<int> weight)
{
    int n = tree_nodes;

    vector<vector<int> > adj(n+1);
    for(int i = 0; i<tree_from.size(); i++)
    {
        adj[tree_from[i]].push_back(tree_to[i]);
        adj[tree_to[i]].push_back(tree_from[i]);
    }

    int maxi = -1e9;
    fun(1,-1,adj,weight,maxi);
    return maxi;

}