#include <bits/stdc++.h>
using namespace std;

#ifdef ONLINE_JUDGE
constexpr bool debug = false;
#else
constexpr bool debug = true;
#endif

using i64 = long long;

struct event {
    i64 time, pos, dur;
    int type, dir, id;
    /*
              case                      available
    type = 0: toilet emerge         pos
    type = 1: person emerge         pos, dur, dir, id
    type = 2: person finds toilet   pos, id
    */
    bool operator < (const event &e) const {
        if(time != e.time) return time < e.time;
        if(type != e.type) return type < e.type;
        if(type) return id < e.id;
        else return pos < e.pos;
    }
    bool operator == (const event &e) const {
        return time == e.time && type == e.type && pos == e.pos && dur == e.dur && dir == e.dir && id == e.id;
    }
};

signed main() {
    ios::sync_with_stdio(0);
    cin.tie(0), cout.tie(0);
    i64 n, m, L;
    cin >> n >> m >> L;
    set<i64> toilet;
    map<i64, set<int>> person_dir[2]; // 1: pos  0: neg
    map<i64, array<int, 2>> toilet_near;
    for(int i = 0; i < m; i++) {
        i64 x;
        cin >> x;
        toilet.insert(x);
        toilet_near[x] = {0, 0};
    }
    set<event> q;
    vector<array<i64, 4>> person(n + 1); // <time, pos, dir, dur>
    vector<event> person_near(n + 1);
    for(int i = 1; i <= n; i++) {
        int t, p, d;
        string s;
        cin >> t >> p >> s >> d;
        person_near[i].pos = -1;
        if(s == "+") {
            q.insert({t, p, d, 1, 1, i});
            person[i] = {t, p, 1, d};
        } else {
            q.insert({t, p, d, 1, 0, i});
            person[i] = {t, p, 0, d};
        }
    }
    auto norm = [&](i64 x) { return (x % L + L) % L; };
    auto dist = [&](int id, i64 pos, i64 ti) -> i64 { // time to go _pos_ for person _id_ at time _ti_
        if(pos == -1) return 1e18;
        ti -= person[id][0];
        return person[id][2] == 1 ? norm(pos - ti - person[id][1]) : norm(person[id][1] - ti - pos);
    };
    auto find_right = [&](set<i64> &st, i64 x) -> i64 {
        if(st.empty()) return -1;
        auto it = st.lower_bound(x);
        if(it == st.end()) return *st.begin();
        return *it;
    };
    auto find_left = [&](set<i64> &st, i64 x) -> i64 {
        if(st.empty()) return -1;
        auto it = st.upper_bound(x);
        if(it == st.begin()) return *st.rbegin();
        return *prev(it);
    };
    auto find_right_id = [&](map<i64, set<int>> &st, i64 x) -> int {
        if(st.empty()) return -1;
        auto it = st.lower_bound(x);
        if(it == st.end()) return *st.begin()->second.begin();
        return *it->second.begin();
    };
    auto find_left_id = [&](map<i64, set<int>> &st, i64 x) -> int {
        if(st.empty()) return -1;
        auto it = st.upper_bound(x);
        if(it == st.begin()) return *st.rbegin()->second.begin();
        return *prev(it)->second.begin();
    };
    i64 cnt = 0;
    vector<pair<i64, i64>> ans(n + 1);
    auto link_person = [&](i64 ti, i64 pos, i64 dur, i64 ty, int dir, int id) { // try to link person _id_ to toilet and maintain the queue
        i64 near = dir == 1 ? find_right(toilet, norm(pos + ti - person[id][0])) : find_left(toilet, norm(pos - ti + person[id][0]));
        if(debug) cerr << "     near = " << near << '\n';
        if(near == -1) return;
        int o = toilet_near[near][!dir];
        if(o == 0) {
            toilet_near[near][!dir] = id;
            person_near[id] = {ti + dist(id, near, ti), near, dur, 2, dir, id};
            q.insert(person_near[id]);
        } else {
            if(debug) cerr << "     dist1 = " << dist(id, near, ti) << ' ' << "dist2 = " << dist(o, near, ti) << '\n';
            if(make_pair(dist(id, near, ti), id) < make_pair(dist(o, near, ti), o)) {
                q.erase(person_near[o]); // should I modify person_near[o] ?
                person_near[o] = {0, -1, 0, 0, 0, 0};
                toilet_near[near][!dir] = id;
                person_near[id] = {ti + dist(id, near, ti), near, dur, 2, dir, id};
                q.insert(person_near[id]);
            }
        }
    };
    while(cnt < n) {
        if(debug) cerr << "-----------------------------------\n";
        auto [ti, pos, dur, ty, dir, id] = *q.begin();
        q.erase(q.begin());
        if(ty == 0) { // toilet emerge
            toilet.insert(pos);
            int left = find_left_id(person_dir[1], norm(pos - ti));
            int right = find_right_id(person_dir[0], norm(pos + ti));
            if(debug) cerr << "     dist1 = " << dist(left, pos, ti) << ' ' << "dist2 = " << dist(left, person_near[left].pos, ti) << '\n';
            if(left != -1 && dist(left, pos, ti) < dist(left, person_near[left].pos, ti)) {
                q.erase(person_near[left]);
                toilet_near[person_near[left].pos][0] = 0;
                toilet_near[pos][0] = left;
                person_near[left] = {ti + dist(left, pos, ti), pos, 0, 2, 0, left};
                q.insert(person_near[left]);
            }
            if(right != -1 && dist(right, pos, ti) < dist(right, person_near[right].pos, ti)) {
                q.erase(person_near[right]);
                toilet_near[person_near[right].pos][1] = 0;
                toilet_near[pos][1] = right;
                person_near[right] = {ti + dist(right, pos, ti), pos, 0, 2, 0, right};
                q.insert(person_near[right]);
            }
        } else if(ty == 1) { // person emerge
            person_dir[dir][norm(dir == 1 ? pos - ti : pos + ti)].insert(id);
            link_person(ti, pos, dur, ty, dir, id);
        } else { // person finds toilet
            dur = person[id][3], dir = person[id][2];
            ans[id] = {pos, ti}, cnt++;
            i64 pp = norm(dir == 1 ? pos - ti : pos + ti);
            person_dir[dir][pp].erase(id);
            if(person_dir[dir][pp].empty()) person_dir[dir].erase(pp);
            int o1 = toilet_near[pos][dir];
            pp = norm(dir == 1 ? person[id][1] - person[id][0] : person[id][1] + person[id][0]);
            int o2 = dir == 1 ? find_left_id(person_dir[1], pp) : find_right_id(person_dir[0], pp);
            toilet_near[pos] = {0, 0};
            toilet.erase(pos);
            q.insert({ti + dur, pos, 0, 0, 0, 0});
            if(o1) { // no need to check o != id
                q.erase(person_near[o1]);
                person_near[o1] = {0, -1, 0, 0, 0, 0};
                link_person(ti, person[o1][1], person[o1][3], 1, person[o1][2], o1);
            }
            if(o2 != -1) {
                link_person(ti, person[o2][1], person[o2][3], 1, person[o2][2], o2);
            }
        }
        if(!debug) continue;
        cerr << "ti = " << ti << ' ' << "pos = " << pos << ' ' << "dur = " << dur << ' ' << "ty = " << ty << ' ' << "dir = " << dir << ' ' << "id = " << id << '\n';
        cerr << "toilet: ";
        for(auto x : toilet) cerr << x << ' ';
        cerr << '\n';
        cerr << "person_dir[0]: ";
        for(auto [x, y] : person_dir[0]) {
            cerr << x << "(";
            for(auto z : y) cerr << z << (z == *y.rbegin() ? "" : ",");
            cerr << ") ";
        }
        cerr << '\n';
        cerr << "person_dir[1]: ";
        for(auto [x, y] : person_dir[1]) {
            cerr << x << "(";
            for(auto z : y) cerr << z << (z == *y.rbegin() ? "" : ",");
            cerr << ") ";
        }
        cerr << '\n';
        cerr << "events:\n";
        cerr << "tim pos dur typ dir  id\n";
        for(auto x : q) {
            cerr << setw(3) << x.time << ' ' << setw(3) << x.pos << ' '
                 << setw(3) << x.dur << ' ' << setw(3) << x.type << ' '
                 << setw(3) << x.dir << ' ' << setw(3) << x.id << '\n';
        }
    }
    for(int i = 1; i <= n; i++) {
        cout << ans[i].first << ' ' << ans[i].second << '\n';
    }
    /*
    i64 time, pos, dur;
    int type, dir, id;
              case                      available
    type = 0: toilet emerge         pos
    type = 1: person emerge         pos, dur, dir, id
    type = 2: person finds toilet   pos, id
    */
    return 0;
}