#include <bits/stdc++.h>

using namespace std;

int xx[] = {1,-1,0,0};
int yy[] = {0,0,1,-1};

bool legal(int n, int x, int y) {
	return x >= 0 && x < n && y >= 0 && y < n;
}

long long suns(vector <string> v) {
	int ans = 0;
	int n = v.size();
	for (int i = 0; i < n; ++i) {
		for (int j = 0; j < n; ++j) {
			if (v[i][j] == ' ' || v[i][j] == '*') {
				continue;
			}
			bool fla = false;
			for (int x = 1; x <= n; ++x) {
				int ni = i + x;
				int nj = j;
				if (!legal(n, ni, nj)) {
					break;
				}
				if (v[ni][nj] == '*') {
					fla = true;
					break;
				}
				if (v[ni][nj] != ' ') {
					break;
				}
			}
			for (int x = 1; x <= n; ++x) {
				int ni = i - x;
				int nj = j;
				if (!legal(n, ni, nj)) {
					break;
				}
				if (v[ni][nj] == '*') {
					fla = true;
					break;
				}
				if (v[ni][nj] != ' ') {
					break;
				}
			}
			for (int x = 1; x <= n; ++x) {
				int ni = i;
				int nj = j + x;
				if (!legal(n, ni, nj)) {
					break;
				}
				if (v[ni][nj] == '*') {
					fla = true;
					break;
				}
				if (v[ni][nj] != ' ') {
					break;
				}
			}
			for (int x = 1; x <= n; ++x) {
				int ni = i;
				int nj = j - x;
				if (!legal(n, ni, nj)) {
					break;
				}
				if (v[ni][nj] == '*') {
					fla = true;
					break;
				}
				if (v[ni][nj] != ' ') {
					break;
				}
			}
			for (int x = 1; x <= n; ++x) {
				int ni = i + x;
				int nj = j + x;
				if (!legal(n, ni, nj)) {
					break;
				}
				if (v[ni][nj] == '*') {
					fla = true;
					break;
				}
				if (v[ni][nj] != ' ') {
					break;
				}
			}
			for (int x = 1; x <= n; ++x) {
				int ni = i + x;
				int nj = j - x;
				if (!legal(n, ni, nj)) {
					break;
				}
				if (v[ni][nj] == '*') {
					fla = true;
					break;
				}
				if (v[ni][nj] != ' ') {
					break;
				}
			}
			for (int x = 1; x <= n; ++x) {
				int ni = i - x;
				int nj = j + x;
				if (!legal(n, ni, nj)) {
					break;
				}
				if (v[ni][nj] == '*') {
					fla = true;
					break;
				}
				if (v[ni][nj] != ' ') {
					break;
				}
			}
			for (int x = 1; x <= n; ++x) {
				int ni = i - x;
				int nj = j - x;
				if (!legal(n, ni, nj)) {
					break;
				}
				if (v[ni][nj] == '*') {
					fla = true;
					break;
				}
				if (v[ni][nj] != ' ') {
					break;
				}
			}
			if (fla) {
				++ans;
			}
		}
	}
	return ans * 100;
}

bool vis[100][100];
long long biggest_bird(const vector<string> &vec){
    int n = vec.size();
    int ile = 0;
    for(int i = 0; i < vec.size(); ++i){
        for(int x = 0; x < vec.size(); ++x){
            if(vec[i][x] == 'D' || vec[i][x] == 'v'){
                vis[i][x] = 0;
            }
            else{
                vis[i][x] = 1;
            }
        }
    }
    /* int cr; */
    vector<pair<int,int>> ps;
    function<void(int, int)> d1 = [&](int i, int x){
        /* ++cr; */
        ps.push_back({i, x});
        vis[i][x] = 1;
        for(int j = 0; j < 4; ++j){
            int nx = i + xx[j];
            int ny = x + yy[j];
            if(legal(n, nx, ny) && !vis[nx][ny]){
                d1(nx, ny);
                break;
            }
        }
    };
    for(int ii = 0; ii < vec.size(); ++ii){
        for(int xx = 0; xx < vec.size(); ++xx){
            if(!vis[ii][xx]){
                /* cr = 0; */
                ps.clear();
                d1(ii, xx);
                /* ile += 500 * */ 
                sort(ps.begin(), ps.end());
                int cr = 0;
                int mx = 0;
                //int pri = -1, prx = -1;
                //for(auto &i: ps){
                    //if(pri != i.first || prx + 1 != i.second){
                        //mx = max(mx, cr);
                        //cr = 1;
                        //pri = i.first;
                        //prx = i.second;
                    //}
                    //else{
						//prx = i.second;
                        //++cr;
                    //}
                //}
                for (int i = 0; i < ps.size(); ++i) {
					int x = i;
					while (x + 1 < ps.size() && ps[x + 1].first == ps[i].first
						&& ps[x + 1].second == ps[x].second + 1) {
						++x;
					}
					mx = max(mx, x - i + 1);
					i = x;
				}
                mx = max(mx, cr);
                ile += 500 * mx;
            }
        }
    }
    return ile;
}

long long flock_perimiter(vector <string> v) {
	int n = v.size();
	int ans = 0;
	for (int i = 1; i < n; ++i) {
		for (int j = 0; j < n; ++j) {
			int sum = (v[i][j] == 'D') + (v[i][j] == 'v') + (v[i - 1][j] == 'D')
				+ (v[i - 1][j] == 'v');
			if (sum == 1) {
				++ans;
			}
		}
	}
	for (int i = 0; i < n; ++i) {
		for (int j = 1; j < n; ++j) {
			int sum = (v[i][j] == 'D') + (v[i][j] == 'v') + (v[i][j - 1] == 'D')
				+ (v[i][j - 1] == 'v');
			if (sum == 1) {
				++ans;
			}
		}
	}
	for (int i = 0; i < n; ++i) {
		if (v[i][0] == 'D' || v[i][0] == 'v') {
			++ans;
		}
		if (v[i][n - 1] == 'D' || v[i][n - 1] == 'v') {
			++ans;
		}
		if (v[0][i] == 'D' || v[0][i] == 'v') {
			++ans;
		}
		if (v[n - 1][i] == 'D' || v[n - 1][i] == 'v') {
			++ans;
		}
	}
	return ans * 60;
}

long long house_view_up(vector <string> v) {
	int n = v.size();
	int ans = 0;
	for (int i = 0; i < n; ++i) {
		for (int j = 0; j < n; ++j) {
			if (v[i][j] != '^') {
				continue;
			}
			for (int k = i - 1; k >= 0; --k) {
				if (v[k][j] == ' ') {
					++ans;
				}
				else {
					break;
				}
			}
		}
	}
	return ans * 10;
}

long long unique_blocks(vector <string> v) {
	int n = v.size();
	int ans = 0;
	set <vector <char> > s;
	for (int i = 0; i < n - 2; ++i) {
		for (int j = 0; j < n - 2; ++j) {
			vector <char> vv;
			for (int k = 0; k < 3; ++k) {
				for (int l = 0; l < 3; ++l) {
					vv.push_back(v[i + k][j + l]);
				}
			}
			s.insert(vv);
		}
	}
	ans = s.size();
	return ans * 1;
}

long long animals1(vector <string> v) {
	int n = v.size();
	int ans = 0;
	for (int i = 1; i < n; ++i) {
		for (int j = 0; j < n; ++j) {
			if (v[i][j] == ' ') {
				if (v[i - 1][j] == 'D' || v[i - 1][j] == 'v' || v[i - 1][j] == '!') {
					++ans;
				}
			}
			else {
				if (v[i - 1][j] == ' ') {
					if (v[i][j] == 'D' || v[i][j] == 'v' || v[i][j] == '!') {
						++ans;
					}
				}
			}
		}
	}
	for (int i = 0; i < n; ++i) {
		for (int j = 1; j < n; ++j) {
			if (v[i][j] == ' ') {
				if (v[i][j - 1] == 'D' || v[i][j - 1] == 'v' || v[i][j - 1] == '!') {
					++ans;
				}
			}
			else {
				if (v[i][j - 1] == ' ') {
					if (v[i][j] == 'D' || v[i][j] == 'v' || v[i][j] == '!') {
						++ans;
					}
				}
			}
		}
	}
	return ans * 15;
}

vector <pair <int, int> > g65[50 + 10][50 + 10];

set <pair <int, int> > odw69;
int dfs(int a, int b, const vector <string> &v) {
	int n = v.size();
	if (odw69.find({a, b}) != odw69.end()) {
		return 0;
	}
	odw69.insert({a, b});
	int ans = 0;
	if (a < n && v[a][b] != ' ') {
		++ans;
	}
	for (auto xd : g65[a][b]) {
		ans += dfs(xd.first, xd.second, v);
	}
	return ans;
}

long long freedom(vector <string> v) {
	int n = v.size();
	int ans = 0;
	for (int i = 0; i < n; ++i) {
		g65[n][n].push_back({i, 0});
		g65[n][n].push_back({i, n - 1});
		g65[n][n].push_back({0, i});
		g65[n][n].push_back({n - 1, i});
	}
	for (int i = 0; i < n; ++i) {
		for (int j = 0; j < n; ++j) {
			if (v[i][j] != ' ') {
				continue;
			}
			if (legal(n, i - 1, j)) {
				g65[i][j].push_back({i - 1, j});
			}
			if (legal(n, i + 1, j)) {
				g65[i][j].push_back({i + 1, j});
			}
			if (legal(n, i, j - 1)) {
				g65[i][j].push_back({i, j - 1});
			}
			if (legal(n, i, j + 1)) {
				g65[i][j].push_back({i, j + 1});
			}
		}
	}
	ans = dfs(n, n, v);
	return ans * 7;
}

int n;

// Each bird which can be reached.
// -> jak 2 mogą reachować birda, do tylko raz się liczy surely.
// bird, drake are birds.
long long chupacabra(const vector<string> &vec){
    int ile = 0;
    for(int i = 0; i < vec.size(); ++i){
        for(int x = 0; x < vec.size(); ++x){
            if(vec[i][x] == 'D' || vec[i][x] == 'v'){
                int xxx[] = {2, 2, -2, -2, 1, -1, 1, -1};
                int yyy[] = {1, -1, 1, -1, 2, 2, -2, -2};
                for(int j = 0; j < 8; ++j){
                    int nx = i + xxx[j];
                    int ny = x + yyy[j];
                    if(legal(n, nx, ny) && vec[nx][ny] == '!'){
                        ile += 200;
                        break;
                    }
                }
            }
        }
    }
    return ile;
}

long long peaks(const vector<string> &vec){
    int ile = 0;
    vector<pair<int,int>> wh;
    for(int i = 0; i < vec.size(); ++i){
        for(int x = 0; x + 1 < vec.size(); ++x){
            if(vec[i][x] == '/' && vec[i][x + 1] == '\\'){
                wh.push_back({i, x});
            }
        }
    }
    int ret = 0;
    for(auto &i: wh){
        int ilecr = 0;
        for(auto &x: wh){
            /* ile = max(ile, abs(x.first - i.first) + abs(x.second - i.second)); */
            ilecr = max(ilecr, abs(x.first - i.first) + abs(x.second - i.second));
        }
        ret += ilecr;
    }
    return 50 * ret;
    /* return wh.size() * 50 * ile; */
}

long long drake_grill(const vector<string> &vec){
    int ile = 0;
    for(int i = 0; i < vec.size(); ++i){
        for(int x = 0; x < vec.size(); ++x){
            if(vec[i][x] == 'D'){
                for(int j = 0; j < 4; ++j){
                    int nx = i + xx[j];
                    int ny = x + yy[j];
                    if(legal(n, nx, ny) && vec[nx][ny] == 'G'){
                        ile += 500;
                        break;
                    }
                }
            }
        }
    }
    return ile;
}

long long min_freq(const vector<string> &vec){
    int ile[128]{};
    for(auto &i: vec){
        for(auto &x: i){
			if (x != ' ')
				++ile[x];
        }
    }
    int wh = 50 * 50 * 50 + 69969;
    for(int i = 0; i < 128; ++i){
        if(ile[i]){
            wh = min(wh, ile[i]);
        }
    }
    //return wh * 10;
    int ans = 0;
    if (wh > 0) {
		for (int i = 0; i < 128; ++i) {
			ans += (ile[i] == wh) * ile[i];
		}
	}
    return ans * 10;
}

long long empty_fields(const vector<string> &vec){
    int ile = 0;
    for(auto &i: vec){
        for(auto &x: i){
            ile += x == ' ';
        }
    }
    return ile;
}

long long animals_2(const vector<string> &vec){
    int ile[3]{};
    for(auto &i: vec){
        for(auto &x: i){
            if(x == '!')
                ++ile[0];
            else if(x == 'D')
                ++ile[1];
            else if(x == 'v')
                ++ile[2];
        }
    }
    return ile[0] * ile[1] * ile[2];
}

long long house_view(const vector<string> &vec){
    int ile = 0;
    for(int i = 0; i < vec.size(); ++i){
        for(int x = 0; x < vec.size(); ++x){
            if(vec[i][x] == ' '){
                for(int ni = i + 1; ni < vec.size(); ++ni){
                    if(vec[ni][x] == '^'){
                        ile += 5;
                        break;
                    }
                    else if(vec[ni][x] != ' '){
                        break;
                    }
                }
            }
        }
    }
    return ile;
}

long long house_view2(const vector<string> &vec){
    int ile = 0;
    for(int i = 0; i < vec.size(); ++i){
        for(int x = 0; x < vec.size(); ++x){
            if(vec[i][x] == ' '){
                for(int ni = i - 1; ni >= 0; --ni){
                    if(vec[ni][x] == '^'){
                        ile += 5;
                        break;
                    }
                    else if(vec[ni][x] != ' '){
                        break;
                    }
                }
            }
        }
    }
    return ile;
}

long long grill_drake(const vector<string> &vec){
    int ile = 0;
    for(int i = 0; i < vec.size(); ++i){
        for(int x = 0; x < vec.size(); ++x){
            if(vec[i][x] == 'G'){
                for(int j = 0; j < 4; ++j){
                    int nx = i + xx[j];
                    int ny = x + yy[j];
                    if(legal(n, nx, ny) && vec[nx][ny] == 'D'){
                        ile += 50;
                        break;
                    }
                }
            }
        }
    }
    return ile;
}

long long houses_and_grills(const vector<string> &vec){
    int ile = 0;
    int cn[2]{};
    for(auto &i: vec){
        for(auto &x: i){
            if(x == 'G')
                ++cn[0];
            else if(x == '^')
                ++cn[1];
        }
    }
    ile = min(cn[0], cn[1]);
    return 3 * ile;
}

void solve() {
	string ss;
	getline(std::cin, ss);
	n = stoi(ss);
	vector <string> v;
	for (int i = 0; i < n; ++i) {
		string s;
		getline(std::cin, s);
		v.push_back(s);
	}
	
	long long ans = 0;
	cerr << biggest_bird(v) << endl;
	//cout << freedom(v) << endl;
	// 1
	cerr << ans << endl;ans += suns(v);
	// 2
	cerr << ans << endl;ans += biggest_bird(v);
	// 3
	cerr << ans << endl;ans += flock_perimiter(v);
	// 4
	cerr << ans << endl;ans += house_view_up(v);
	// 5
	cerr << ans << endl;ans += unique_blocks(v);
	// 6
	cerr << ans << endl;ans += animals1(v);
	// 7
	cerr << ans << endl;ans += freedom(v);
	// 8
	cerr << ans << endl;ans += chupacabra(v);
	// 9
	cerr << ans << endl;ans += peaks(v);
	// 10
	cerr << ans << endl;ans += drake_grill(v);
	// 11
	cerr << ans << endl;ans += min_freq(v);
	// 12
	cerr << ans << endl;ans += empty_fields(v);
	// 13
	cerr << ans << endl;ans += animals_2(v);
	// 14
	cerr << ans << endl;ans += house_view(v);
	// 15
	cerr << ans << endl;ans += grill_drake(v);
	// 16
	cerr << ans << endl;ans += houses_and_grills(v);
	
	printf("%lld\n", ans);
	
}

int main() {
	int tt = 1;
	//scanf("%d", &tt);
	for (int ii = 0; ii < tt; ++ii) {
		solve();
	}
	return 0;
}