class Student:
    instances = {}

    def __init__(self, name, score, i, j):
        self.name = name
        self.score = score
        self.i = i
        self.j = j

    def set_score(self, score:int) -> None:
        pass # TODO set the new score for this student, and make sure the score is in valid range

    def get_message(self) -> str:
        pass # TODO get the message by the required format

class PotatosClass:
    students = dict()

    def __init__(self, n, m):
        self.seats = [[None]*m for _ in range(n)]

    def record_students(self):
        for i in range(n*m):
            name, score, i, j = input().split()

            score, i, j = int(score), int(i), int(j)

            student = Student(name, score, i, j)
            self.students[name] = self.seats[i][j] = student

    def command_score(self, stu_name:str, new_score:int) -> None:
        self.students[stu_name].set_score(new_score)

    def command_rotate(self, i:int, j:int, width:int) -> None:
        pass # TODO rotate the student's seats

    def get_best_student(self) -> Student:
        pass # TODO get the best scored student

n, m, k = map(int, input().split())

course = PotatosClass(n, m)
course.record_students()

for i in range(k):
    commands = input().split()

    if(commands[0] == "score"):
        course.command_score(commands[1], int(commands[2]))
    elif(commands[0] == "rotate"):
        course.command_rotate(int(commands[1]), int(commands[2]), int(commands[3]))

print(course.get_best_student().get_message())

class Potato:
    def __init__(self) -> None:
        self.i = 0
        self.j = 0
        self.score = 0

    def play(self, time:int, maze:"Maze") -> None:
        # Update maze (if there's any event, do the event first)
        maze.update_time(time, self)

        # TODO
        # utilize functions in maze
        # 1. pick up the points where you're standing on (take a look in 'class Maze')
        # 2. move Potato by checking if next cell is a stone by the priority of [Right, Down, Left, Up]

    def get_location_message(self, time:int) -> str:
        # TODO
        # return the formated the message by the required format 
        # >> the message printed each second
        return f"Where's Potato!!"

    def get_summary_message(self, time:int) -> str:
        # TODO
        # return the formated the message by the required format 
        # >> the message printed when Potato arrived at bottom right
        return f"How much time and score did Potato spend and get!!"

class MazeRotatingEvent:
    def __init__(self, t, i, j, w, d) -> None:
        self.t = t
        self.i = i
        self.j = j
        self.w = w
        self.d = d

class Maze:
    def __init__(self, n, m) -> None:
        self.n = n
        self.m = m

    def read_grid(self) -> None:
        self.grid = [list(map(int, input().split())) for i in range(self.n)]

    def read_k_events(self, k:int) -> None:
        self.events = None # TODO replace this with how you want to store MazeRotatingEvents
        for i in range(k):
            t, i, j, w, d = map(int, input().split())
            rotatingEvent = MazeRotatingEvent(t, i, j, w, d)
            # TODO store this new MazeRotatingEvent <rotatingEvent>

    def is_cell_the_end(self, i:int, j:int) -> bool:
        # TODO
        # return True if (i, j) is the bottom-right
        # return False if (i, j) is not the bottom-right
        return

    def is_cell_walkable(self, i:int, j:int) -> bool:
        # TODO
        # return False if (i, j) is out of map or is a stone (negative number)
        # return True if (i, j) is in the map and is not a stone (positive number or 0)
        return

    def pick_up_treasure_at(self, i:int, j:int) -> int:
        # TODO
        # return the points on (i, j), and because it's picked up, subtract by 1
        return

    def update_time(self, time:int, potato:Potato) -> None:
        # TODO
        # check if there's a rotating event on time <time>
        # if there's a rotating event, rotate the area, and also move potato's position
        pass

n, m, k = map(int, input().split())

magic_maze = Maze(n, m)
magic_maze.read_grid()
magic_maze.read_k_events(k)

cute_potato = Potato()

time = 0
while(True):
    old_i, old_j = cute_potato.i, cute_potato.j
    cute_potato.play(time, magic_maze)

    print(cute_potato.get_location_message(time))

    if(magic_maze.is_cell_the_end(cute_potato.i, cute_potato.j)):
        print(cute_potato.get_summary_message(time))
        break

    time += 1