#include <cstdio>
#include <iostream>
#include <queue>
#include <sstream>
#include <string>
#include <unordered_map>
#include <vector>

namespace {

struct Team {
    std::string name;
    int solved = 0;   // 通过题数
    int penalty = 0;  // 总罚时（分钟）
    int id = 0;       // 编号：第一次出现在提交记录中的顺序
};

// “名次更靠前”的比较器；作为优先队列的比较器时，堆顶就是最后一名。
struct BetterFirst {
    bool operator()(const Team &a, const Team &b) const {
        if (a.solved != b.solved) return a.solved > b.solved;
        if (a.penalty != b.penalty) return a.penalty < b.penalty;
        return a.id < b.id;
    }
};

}  // namespace

int main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);

    int n = 0, m = 0, K = 0;
    if (!(std::cin >> n >> m >> K)) return 0;

    std::vector<Team> team(m + 1);
    // fails[t][p]：第 t 队第 p 题通过之前的未通过提交数，-1 表示该题已通过
    // pending[t][p]：第 t 队第 p 题封榜后首次通过的时刻（分钟），0 表示没有
    std::vector<std::vector<int>> fails(m + 1, std::vector<int>(26, 0));
    std::vector<std::vector<int>> pending(m + 1, std::vector<int>(26, 0));

    std::unordered_map<std::string, int> teamId;
    int cnt = 0;

    std::string line;
    std::getline(std::cin, line);  // 吃掉第一行剩余的换行
    for (int k = 0; k < K; ++k) {
        if (!std::getline(std::cin, line)) break;
        std::istringstream iss(line);
        std::string timeToken, problemToken, name, verdict;
        iss >> timeToken >> problemToken >> name;
        std::getline(iss, verdict);
        const std::size_t begin = verdict.find_first_not_of(' ');
        verdict = (begin == std::string::npos) ? std::string() : verdict.substr(begin);

        int hh = 0, mm = 0, ss = 0;
        std::sscanf(timeToken.c_str(), "%d:%d:%d", &hh, &mm, &ss);
        const int p = problemToken[0] - 'A';

        auto it = teamId.find(name);
        if (it == teamId.end()) {  // 新队伍：编号就是出现顺序
            teamId[name] = ++cnt;
            it = teamId.find(name);
            team[cnt].name = name;
            team[cnt].id = cnt;
        }
        const int t = it->second;

        if (fails[t][p] == -1 || pending[t][p] != 0) continue;  // 该题已有结论

        if (!verdict.empty() && verdict[0] == 'A') {  // 只有 Accepted 以 A 开头
            if (hh > 4 || (hh == 4 && (mm > 0 || ss > 0))) {
                pending[t][p] = hh * 60 + mm;  // 封榜后的通过留到滚榜时结算
            } else {
                team[t].solved += 1;
                team[t].penalty += hh * 60 + mm + 20 * fails[t][p];
                fails[t][p] = -1;
            }
        } else {
            fails[t][p] += 1;
        }
    }

    std::priority_queue<Team, std::vector<Team>, BetterFirst> heap;
    for (int i = 1; i <= cnt; ++i) heap.push(team[i]);

    std::string out;
    while (!heap.empty()) {
        Team now = heap.top();  // 最后一名
        heap.pop();
        out += now.name;
        out += '\n';
        if (heap.empty()) break;  // 只剩一支队伍，念完即结束

        Team nxt = heap.top();  // 场上的倒数第二名
        heap.pop();

        bool rose = false;
        for (int p = 0; p < n; ++p) {  // 从 A 题依次揭晓
            if (pending[now.id][p] == 0 || fails[now.id][p] == -1) continue;
            now.solved += 1;
            now.penalty += pending[now.id][p] + 20 * fails[now.id][p];
            fails[now.id][p] = -1;  // 已揭晓的题不会再次揭晓
            if (BetterFirst()(now, nxt)) {  // 名次上升
                rose = true;
                break;
            }
        }
        if (rose) heap.push(now);  // 还会被念到
        heap.push(nxt);            // 无论是否上升，倒数第二名都要放回
    }

    std::fwrite(out.data(), 1, out.size(), stdout);
    return 0;
}

import heapq
import sys


def main():
    data = sys.stdin.buffer.read().split(b"\n")
    if not data or not data[0].strip():
        return
    n, m, K = map(int, data[0].split())

    solved = [0] * (m + 1)
    penalty = [0] * (m + 1)
    fails = [[0] * 26 for _ in range(m + 1)]    # -1 表示该题已通过
    pending = [[0] * 26 for _ in range(m + 1)]  # 0 表示没有待判的通过

    index = {}
    names = [b""] * (m + 1)
    cnt = 0

    for i in range(1, K + 1):
        parts = data[i].split()
        hh, mm, ss = map(int, parts[0].split(b":"))
        p = parts[1][0] - ord("A")
        name = parts[2]
        accepted = parts[3][0:1] == b"A"  # 只有 Accepted 以 A 开头

        if name not in index:  # 新队伍：编号就是出现顺序
            cnt += 1
            index[name] = cnt
            names[cnt] = name
        t = index[name]

        if fails[t][p] == -1 or pending[t][p]:
            continue

        if accepted:
            if hh > 4 or (hh == 4 and (mm > 0 or ss > 0)):
                pending[t][p] = hh * 60 + mm
            else:
                solved[t] += 1
                penalty[t] += hh * 60 + mm + 20 * fails[t][p]
                fails[t][p] = -1
        else:
            fails[t][p] += 1

    # 元组 (题数, -罚时, -编号) 越大名次越靠前，于是堆顶（最小值）就是最后一名
    heap = [(solved[t], -penalty[t], -t, t) for t in range(1, cnt + 1)]
    heapq.heapify(heap)

    out = []
    while heap:
        now = heapq.heappop(heap)  # 最后一名
        out.append(names[now[3]])
        if not heap:
            break  # 只剩一支队伍，念完即结束
        nxt = heapq.heappop(heap)  # 场上的倒数第二名

        s, pen, t = now[0], -now[1], now[3]
        rose = False
        for p in range(n):  # 从 A 题依次揭晓
            if pending[t][p] == 0 or fails[t][p] == -1:
                continue
            s += 1
            pen += pending[t][p] + 20 * fails[t][p]
            fails[t][p] = -1
            if (s, -pen, -t) > (nxt[0], nxt[1], nxt[2]):  # 名次上升
                rose = True
                break
        if rose:
            heapq.heappush(heap, (s, -pen, -t, t))
        heapq.heappush(heap, nxt)

    if out:
        sys.stdout.buffer.write(b"\n".join(out) + b"\n")


if __name__ == "__main__":
    main()