from pprint import pprint

CELL_EMPTY = ' '
CELL_SUN = '*'
CELL_HOUSE = '^'
CELL_CHUPA = '!'
CELL_LEFT = '/'
CELL_RIGHT = '\\'
CELL_BIRD = 'v'
CELL_DRAKE = 'D'
CELL_GRILL = 'G'

grid = []

N = int(input())

for i in range(N):
    grid.append([])

    line = input()

    for ch in line:
        grid[i].append(ch)

price = 0

def suns_price():
    global price

    illum_grid = [[False] * N for _ in range(N)]

    for i in range(N):
        for j in range(N):
            if grid[i][j] == CELL_SUN: # found sun
                for k in range(j, 0, -1): # check columns before
                    if grid[i][k - 1] != CELL_EMPTY:
                        illum_grid[i][k - 1] = True
                        break
                for k in range(j + 1, N): # check columns after
                    if grid[i][k] != CELL_EMPTY:
                        illum_grid[i][k] = True
                        break
                for k in range(i, 0, -1): # check rows before
                    if grid[k - 1][j] != CELL_EMPTY:
                        illum_grid[k - 1][j] = True
                        break
                for k in range(i + 1, N): # check rows after
                    if grid[k][j] != CELL_EMPTY:
                        illum_grid[k][j] = True
                        break
                for k in range(min(i, j)): # check diagonal left up
                    if grid[i - k - 1][j - k - 1] != CELL_EMPTY:
                        illum_grid[i - k - 1][j - k - 1] = True
                        break
                for k in range(min(N - i - 1, j)): # check diagonal left down
                    if grid[i + k + 1][j - k - 1] != CELL_EMPTY:
                        illum_grid[i + k + 1][j - k - 1] = True
                        break
                for k in range(min(i, N - j - 1)): # check diagonal right up
                    if grid[i - k - 1][j + k + 1] != CELL_EMPTY:
                        illum_grid[i - k - 1][j + k + 1] = True
                        break
                for k in range(min(N - i - 1, N - j - 1)): # check diagonal right down
                    if grid[i + k + 1][j + k + 1] != CELL_EMPTY:
                        illum_grid[i + k + 1][j + k + 1] = True
                        break

    price += sum([row.count(True) * 100 for row in illum_grid])

def fill_flock(i, j, checked_grid):
    if i < 0 or j < 0 or i >= N or j >= N:
        return True

    if grid[i][j] in (CELL_BIRD, CELL_DRAKE) and not checked_grid[i][j]:
        checked_grid[i][j] = True
        left_most = right_most = j
        edges = 0

        for x in (-1, 1):
            pos = fill_flock(i, j + x, checked_grid)

            if type(pos) is tuple:
                edges += pos[2]

                if pos[0] < left_most:
                    left_most = pos[0]

                if pos[1] > right_most:
                    right_most = pos[1]
            elif pos:
                edges += 1

        for y in (-1, 1):
            pos = fill_flock(i + y, j, checked_grid)

            if type(pos) is tuple:
                edges += pos[2]

                if pos[0] < left_most:
                    left_most = pos[0]

                if pos[1] > right_most:
                    right_most = pos[1]
            elif pos:
                edges += 1
        
        return left_most, right_most, edges

    return grid[i][j] not in (CELL_BIRD, CELL_DRAKE)

def bird_price():
    global price

    checked_grid = [[False] * N for _ in range(N)]

    for i in range(N):
        for j in range(N):
            if grid[i][j] in (CELL_BIRD, CELL_DRAKE) and not checked_grid[i][j]:
                left_most, right_most, edges = fill_flock(i, j, checked_grid)
                price += 500 * (right_most - left_most + 1)
                price += 60 * edges

def house_up_price():
    global price

    for i in range(N):
        for j in range(N):
            if grid[i][j] == CELL_HOUSE:
                for k in range(i, N):
                    if grid[k][j] == CELL_EMPTY:
                        price += 10
                    else:
                        break

def house_down_price():
    global price

    for i in range(N):
        for j in range(N):
            if grid[i][j] == CELL_HOUSE:
                for k in range(i):
                    if grid[k][j] == CELL_EMPTY:
                        price += 5
                    else:
                        break

def blocks_price():
    global price

    unique_blocks = set()

    for i in range(N - 2):
        for j in range(N - 2):
            block = "".join(["".join(grid[k][j:j + 3]) for k in range(i, i + 3)])

            if block not in unique_blocks:
                price += 1
                unique_blocks.add(block)

def animal_1_price():
    global price

    checked_edges = set()

    for i in range(N):
        for j in range(N):
            if grid[i][j] in (CELL_EMPTY, CELL_BIRD, CELL_CHUPA, CELL_DRAKE):
                for x in (-1, 1):
                    if j + x < 0 or j + x >= N:
                        continue

                    edge_id = str((i, j, i, j + x))
                    
                    if edge_id not in checked_edges:
                        checked_edges.add(edge_id)
                        checked_edges.add(str((i, j + x, i, j)))

                        if (grid[i][j] == CELL_EMPTY and grid[i][j + x] in (CELL_BIRD, CELL_CHUPA, CELL_DRAKE)) or (grid[i][j + x] == CELL_EMPTY and grid[i][j] in (CELL_BIRD, CELL_CHUPA, CELL_DRAKE)):
                            price += 15

                for y in (-1, 1):
                    if i + y < 0 or i + y >= N:
                        continue

                    edge_id = str((i, j, i + y, j))
                    
                    if edge_id not in checked_edges:
                        checked_edges.add(edge_id)
                        checked_edges.add(str((i + y, j, i, j)))

                        if (grid[i][j] == CELL_EMPTY and grid[i + y][j] in (CELL_BIRD, CELL_CHUPA, CELL_DRAKE)) or (grid[i + y][j] == CELL_EMPTY and grid[i][j] in (CELL_BIRD, CELL_CHUPA, CELL_DRAKE)):
                            price += 15

def empty_price():
    global price

    for i in range(N):
        for j in range(N):
            if grid[i][j] == CELL_EMPTY:
                price += 1

def animal_2_price():
    global price

    num_chupa = num_birds = num_drakes = 0

    for i in range(N):
        for j in range(N):
            if grid[i][j] == CELL_CHUPA:
                num_chupa += 1
            elif grid[i][j] == CELL_BIRD:
                num_birds += 1
            elif grid[i][j] == CELL_DRAKE:
                num_drakes += 1

    price += num_chupa * num_birds * num_drakes

def houses_grills_price():
    global price

    num_houses = num_grills = 0

    for i in range(N):
        for j in range(N):
            if grid[i][j] == CELL_HOUSE:
                num_houses += 1
            elif grid[i][j] == CELL_GRILL:
                num_grills += 1

    price += min(num_houses, num_grills) * 3

def min_freq_price():
    global price

    nums = {}

    for i in range(N):
        for j in range(N):
            if grid[i][j] not in nums:
                nums[grid[i][j]] = 1
            else:
                nums[grid[i][j]] += 1

    price += 10 * min(nums.values())

# pprint(grid)

suns_price()
bird_price()
house_up_price()
house_down_price()
blocks_price()
animal_1_price()
animal_2_price()
min_freq_price()

print(price)