#!/usr/bin/env python3

from collections import defaultdict

R, S = map(int, input().split())
# Počet věží nás nezajímá, přeskočíme ho:
input()
T = int(input())

# Načteme vstup po řádcích:
A = [input() for _ in range(R)]

# Rotaci věže reprezentujeme jako číslo 0 až 3, kde 0 je otočení nahoru a
# zvýšení o 1 odpovídá otočení o 90 stupňů doleva.
ROTATIONS = "A<V>"
ROTATION_SHIFTS = [(-1, 0), (0, -1), (1, 0), (0, 1)]


class Tower:
    def __init__(self, pos, rot=0, ht=1):
        self.pos = pos
        self.rot = rot
        self.ht = ht

    def rotate(self):
        self.rot = (self.rot + 1) % 4

    def would_move(self):
        """Kam by se věž pohla, kdybychom ignorovali překážky a okraje mapy."""
        return (
            self.pos[0] + [-1, 0, 1, 0][self.rot],
            self.pos[1] + [0, -1, 0, 1][self.rot],
        )

    def move(self):
        """Provedeme jeden krok. Buď se posuneme na volné políčko, nebo se orotujeme."""
        pos = r, s = self.would_move()
        if not (0 <= r < R and 0 <= s < S) or A[r][s] == "#":
            self.rotate()
        else:
            self.pos = pos


towers = []

for r, row in enumerate(A):
    for s, cell in enumerate(row):
        # .find vrací index výskytu, nebo -1, pokud se podřetězec ve stringu
        # nevyskytuje. V našem případě to odpovídá políčkům neobsahující věž.
        rot = "A<V>".find(cell)
        if rot != -1:
            towers.append(Tower((r, s), rot))


def tick(towers):
    # defaultdict(funkce) se chová jako slovník, s tím rozdílem, že pokud
    # indexujeme klíčem, který neexistuje, nejprve se do slovníku vloží
    # výsledek volání funkce() – v našem případě list(), která vrací prázdný
    # seznam.
    positions = defaultdict(list)
    for tower in towers:
        tower.move()
        positions[tower.pos].append(tower)
    new_towers = []
    # Zagregujeme věže na stejné pozici:
    for tower_list in positions.values():
        new_towers.append(merge(tower_list))
    return new_towers


def merge(tower_list):
    if len(tower_list) == 1:
        return tower_list[0]
    return Tower(tower_list[0].pos, rot=0, ht=sum(tower.ht for tower in tower_list))


for _ in range(T):
    towers = tick(towers)

# Funkce map(fn, seznam) proiteruje seznam/iterátor a na každý prvek aplikuje
# funkci fn. V našem případě každou výšku věže převedeme na řetězec, abychom je
# pomocí " ".join mohli spojit do jednoho řádku.
print(" ".join(map(str, sorted(tower.ht for tower in towers))))