N = int(input())
table = [input() for _ in range(N)]
EMPTY = ' '
SUN = '*'
HOUSE = '^'
CHUPA = '!'
LEFT = '/'
RIGHT = '\\'
BIRD = 'v'
DRAKE = 'D'
GRILL = 'G'

DXY = [ (1, 0), (0, 1), (-1, 0), (0, -1) ]
def in_table(x, y):
    return 0 <= x < N and 0 <= y < N

chess_moves = ((-1, -2), (-1, 2), (-2, 1), (-2, -1), (2, 1), (2, -1), (1, 2), (1, -2))

from collections import defaultdict, Counter


def find_sun(x, y, dx, dy):
    current = table[y][x]
    if current == EMPTY or current == SUN:
        return False
    x += dx
    y += dy
    while 0 <= x < N and 0 <= y < N:
        if table[y][x] == SUN:
            return True
        elif table[y][x] != EMPTY:
            return False
        x += dx
        y += dy
    return False


def suns():
    total = 0
    for i in range(N):
        for j in range(N):
            current = table[i][j]
            if current == EMPTY or current == SUN:
                continue
            found = any(find_sun(j,i, dx,dy) for dx,dy in [(-1,0),
                                                           (1, 0),
                                                           (0,1),
                                                           (0,-1),
                                                           (1,1), (-1,-1), (-1,1), (1,-1)])
            if found: total += 1
    return total*100


birds_dfs = [[False]*N for _ in range(N)]
flock_perim = defaultdict(lambda: 0)
def biggest_dfs(i,j, idx):
    global birds_dfs, flock_perim
    if not (0 <= j < N and 0 <= i < N) or table[i][j] not in [BIRD, DRAKE]: #vargac (was just BIRD)
        flock_perim[idx] += 1
        return
    if birds_dfs[i][j] is not False: return
    birds_dfs[i][j] = idx
    for dx,dy in [(-1,0),(1, 0),(0,1),(0,-1)]:
        biggest_dfs(i+dy, j+dx, idx)

def biggest_bird():
    idx = 1
    total = 0
    for i in range(N):
        for j in range(N):
            if table[i][j] in [BIRD, DRAKE] and birds_dfs[i][j] is False: #argac (was just BIRD)
                biggest_dfs(i, j, idx)
                idx += 1
    for i in range(1, idx):
        longest = 0
        for row in range(N):
            width = 0
            for col in range(N):
                if birds_dfs[row][col] != i:
                    longest = max(longest, width)
                    width = 0
                    continue
                else:
                    width += 1
            longest = max(longest, width) # if flock ends the row
        total += longest
    return 500*total


def perim():
    total = 0
    for k,v in flock_perim.items():
        total += v * 60
    return total


def house_up():
    total = 0
    for i in range(N):
        for j in range(N):
            if table[i][j] != HOUSE:
                continue
            row = i - 1
            while row >= 0:
                if table[row][j] == EMPTY:
                    total += 1
                else: break
                row -= 1
    return total * 10


def three_three():
    three_blocks = set()
    for row in range(N-2): #vargac(was N-3)
        for col in range(N-2):#vargac(was N-3)
            string = table[row][col:col+3] + table[row+1][col:col+3] + table[row+2][col:col+3]
            three_blocks.add(string)
    return len(three_blocks) * 1


def animals_1():
    total = 0
    for i in range(N):
        for j in range(N):
            if table[i][j] != EMPTY:
                continue
            for dx, dy in [(-1, 0), (1, 0), (0, 1), (0, -1)]:
                x = dx + j
                y = dy + i
                if 0<=x<N and 0<=y<N and table[y][x] in [DRAKE,BIRD,CHUPA]:
                    total += 1
    return total * 15


def freedom():
    free_dfs = [[False]*N for _ in range(N)]

    def free_df(i,j):
        if not (0<=i<N and 0<=j<N) or free_dfs[i][j] is True: return
        free_dfs[i][j] = True
        if table[i][j] != EMPTY: return
        for dx, dy in [(-1, 0), (1, 0), (0, 1), (0, -1)]:
            free_df(i+dy, j+dx)

    for i in range(N):
        r = None
        if i == 0 or i == N - 1:
            r = range(N)
        else:
            r = [0, N-1]
        for j in r: free_df(i,j)
    total = 0
    for i in range(N):
        for j in range(N):
            if table[i][j] != EMPTY and free_dfs[i][j]:
                total += 1
    return 7*total


def chupa():
    total = 0
    for i in range(N):
        for j in range(N):
            if table[i][j] not in [BIRD, DRAKE]: #vargac (was just bird)
                continue
            for dx,dy in chess_moves:
                x = j+dx
                y = i+dy
                if 0<=x<N and 0<=y<N and table[y][x] == CHUPA:
                    total += 1
                    break
    return total * 200


def frequencies():
    freqs = Counter("".join(table))

    empty_fields = freqs[EMPTY]
    animals_2 = freqs[CHUPA] * freqs[BIRD] * freqs[DRAKE]
    houses_grills = 3 * min(freqs[HOUSE], freqs[GRILL])

    fr = 0
    del freqs[EMPTY] # vargac
    min_freq = min(freqs.values())
    for k, v in freqs.items():
        if min_freq == v:
            fr += 10 * v
    return fr + empty_fields + animals_2 + houses_grills


def house_down():
    total = 0
    for i in range(N):
        for j in range(N):
            if table[i][j] != HOUSE:
                continue
            row = i + 1
            while row < N:
                if table[row][j] == EMPTY:
                    total += 1
                else: break
                row += 1
    return total * 5 # vargac (was 10)


def grill_drake():
    total = 0
    for y in range(N):
        for x in range(N):
            if table[y][x] == GRILL:
                for dx, dy in DXY:
                    xx = x + dx
                    yy = y + dy
                    if in_table(xx, yy) and table[yy][xx] == DRAKE:
                        total += 1
                        break
    return total * 50


def drake_grill():
    total = 0
    for y in range(N):
        for x in range(N):
            if table[y][x] == DRAKE:
                for dx, dy in DXY:
                    xx = x + dx
                    yy = y + dy
                    if in_table(xx, yy) and table[yy][xx] == GRILL:
                        total += 1
                        break
    return total * 500


def peaks():
    peaks = []
    for y in range(N):
        for x in range(N-1):
            row = table[y]
            if row[x] == LEFT and row[x+1] == RIGHT:
                peaks.append((x+1, y))
    if len(peaks) < 1:
        return 0
    ul = max(peaks, key=lambda x: N - x[0] + N - x[1])
    ur = max(peaks, key=lambda x:   + x[0] + N - x[1])
    bl = max(peaks, key=lambda x: N - x[0] +   + x[1])
    br = max(peaks, key=lambda x:   + x[0]     + x[1])
    total = 0
    return 50 * sum(max(map(lambda a: abs(a[0][0] - a[1][0]) + abs(a[0][1] - a[1][1]), [(a, b) for a in [ul, ur, bl, br]])) for b in peaks)

l = [ grill_drake() ,
        frequencies() , 
        house_down() ,
        drake_grill() , 
        peaks() , 
      chupa() ,  
      freedom() ,  
      animals_1() ,  
      three_three() ,  
      house_up() ,  
      biggest_bird() ,  
      perim() , 
      suns() ]

print(sum(l))