#include <bits/stdc++.h>
using namespace std;
typedef pair<int, int> pii;
typedef tuple<int, int, int> tii;
typedef long long ll;

#define eb emplace_back
#define all(s) (s).begin(), (s).end()
#define rep(i, a, b) for (int i = (a); i <= (b); ++i)
#define per(i, a, b) for (int i = (a); i >= (b); --i)

#define N 1000007

inline int trans(int d, int h, int m) {return d * 1440 + h * 60 + m;}

inline tii recov(int t) {
    int d = t / 1440; t %= 1440;
    int h = t / 60; t %= 60;
    return tie(d, h, t);
}

map<string, int> fid;

vector<int> S, seq;

int fidtot, u[N], v[N], s[N], t[N], id[N], rot[N], tot;

struct node {
    int ls, rs, mn = 1e9;
} c[N << 4];

#define mid ((l + r) >> 1)

void upd(int &rt, int l, int r, int pos, int w) {
    if (!rt) rt = ++tot;
    if (l == r) {c[rt].mn = min(c[rt].mn, w); return;}
    pos <= mid ? upd(c[rt].ls, l, mid, pos, w) : upd(c[rt].rs, mid + 1, r, pos, w);
    c[rt].mn = min(c[c[rt].ls].mn, c[c[rt].rs].mn);
}

int query(int rt, int l, int r, int L, int R) {
    if (!rt) return 1e9;
    if (L <= l && r <= R) return c[rt].mn;
    if (L > mid) return query(c[rt].rs, mid + 1, r, L, R);
    if (R <= mid) return query(c[rt].ls, l, mid, L, R);
    return min(query(c[rt].ls, l, mid, L, R), query(c[rt].rs, mid + 1, r, L, R));
}

bool sp[N];

int main() {
    cin.tie(0);
    ios::sync_with_stdio(false);
    int n;
    cin >> n;
    rep(i, 1, n) {
        id[i] = i;
        string nams, namt;
        string tims, timt;
        cin >> nams >> tims >> namt >> timt;
        if (!fid[nams]) fid[nams] = ++fidtot; u[i] = fid[nams];
        if (!fid[namt]) fid[namt] = ++fidtot; v[i] = fid[namt];

        int tmp[3] = {0, 0, 0}, pos = 0;
        for (auto x : tims) isdigit(x) ? tmp[pos] = tmp[pos] * 10 + (x ^ 48) : ++pos;
        S.eb(s[i] = trans(tmp[0], tmp[1], tmp[2]));

        tmp[0] = tmp[1] = tmp[2] = 0, pos = 0;
        for (auto x : timt) isdigit(x) ? tmp[pos] = tmp[pos] * 10 + (x ^ 48) : ++pos;
        S.eb(t[i] = trans(tmp[0], tmp[1], tmp[2]));
    }

    int m; cin >> m;
    rep(i, 1, m) {int x; cin >> x; sp[x] = true; seq.eb(x);}
    int TAR = v[seq.back()], TART = t[seq.back()];

    S.eb(0); sort(all(S));
    S.erase(unique(all(S)), S.end());
    int ss = S.size();
    auto getv = [&](int x) {return lower_bound(all(S), x) - S.begin() + 1;};

    auto ask = [&](int u, int tim) {
        if (u == TAR) return tim;
        return query(rot[u], 1, ss, getv(tim), ss);
    };

    int ans = 0;
    sort(id + 1, id + 1 + n, [&](int a, int b){return s[a] == s[b] ? sp[a] < sp[b] : s[a] > s[b];});
    rep(i, 1, n) {
        if (sp[id[i]]) {
            int res = ask(u[id[i]], s[id[i]]);
            if (res > 1e8) {puts("stranded"); return 0;}
            ans = max(ans, res - TART);
        }
        int tt = ask(v[id[i]], t[id[i]]);
        upd(rot[u[id[i]]], 1, ss, getv(s[id[i]]), tt);
    }
    printf("%d\n", ans);
    return 0;
}