#include <bits/stdc++.h>

using namespace std;
using ll = long long;
using ld = long double;

// #define int long long

#define pii pair<int, int>
#define pll pair<ld, ld>
#define vi vector<int>
#define all(v) (v).begin(), (v).end()
#define rall(v) (v).rbegin(), (v).rend()
#define mp make_pair
#define pb push_back
#define sz(v) (int)(v).size()
// #define endl '\n'

const ld eps = 1e-8;
const ll mod = 1e9 + 7;
const int inf0 = 1e9 + 10;
const ll inf = 2e18 + 10;

void solve();

signed main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    cout.tie(nullptr);
#ifdef LC
    freopen("input.txt", "r", stdin);
    // freopen("output.txt", "w", stdout);
#endif
    cout << fixed << setprecision(20);
    int t = 1;
    //cin >> t;
    while (t--) {
        solve();
    }
    return 0;
}

const int MAXN = 1e6;
int ans[MAXN];

int get_time(string t) {
    stringstream in(t);
    int d, h, m;
    char c;
    in >> d >> c >> h >> c >> m;
    return d * 24 * 60 + h * 60 + m;
}

struct edge {
    int from, to;
    int t1, t2;
    int type;
    int value;
};

struct event {
    int edge_i;
    int t;
    int type;
    event(int ee, int tt, int tyy): edge_i(ee), t(tt), type(tyy) {}
};

bool cmp(const event &a, const event &b) {
    if (a.t == b.t) {
        return a.type < b.type;
    }
    return a.t > b.t;
}

void solve() {
    int m;
    cin >> m;
    int n = 0;
    map<string, int> name_to_ind;
    vector<edge> all_edges(m);
    for (int i = 0; i < m; ++i) {
        string from, to;
        string t1, t2;
        cin >> from >> t1 >> to >> t2;
        if (name_to_ind.find(from) == name_to_ind.end()) {
            name_to_ind[from] = n++;
        }
        if (name_to_ind.find(to) == name_to_ind.end()) {
            name_to_ind[to] = n++;
        }
        all_edges[i].from = name_to_ind[from];
        all_edges[i].to = name_to_ind[to];
        all_edges[i].t1 = get_time(t1);
        all_edges[i].t2 = get_time(t2);
        all_edges[i].type = 0;
    }
    for (int i = 0; i < n; ++i) {
        ans[i] = (int)1e9;
    }
    int k;
    cin >> k;
    int final_dest, basic_arr_time;
    for (int i = 0; i < k; ++i) {
        int u;
        cin >> u;
        all_edges[u - 1].type = 1;
        if (i == k - 1) {
            final_dest = all_edges[u - 1].to;
            basic_arr_time = all_edges[u - 1].t2;
        }
    }
    vector<event> events;
    for (int i = 0; i < m; ++i) {
        if (all_edges[i].type == 0) {
            events.emplace_back(event(i, all_edges[i].t1, 0));
            events.emplace_back(event(i, all_edges[i].t2, 1));
        }
        else {
            events.emplace_back(event(i, all_edges[i].t1, 2));
            events.emplace_back(event(i, all_edges[i].t2, 3));
        }
    }
    sort(all(events), cmp);
    int res = 0;
    for (auto elem : events) {
        if (elem.type == 2) {
            if (ans[all_edges[elem.edge_i].from] == (int)1e9 && all_edges[elem.edge_i].from != final_dest) {
                cout << "stranded\n";
                return;
            }
            else if (all_edges[elem.edge_i].from != final_dest) {
                res = max(res, ans[all_edges[elem.edge_i].from] - basic_arr_time);
            }
        }
        if (elem.type % 2 == 0) {
            ans[all_edges[elem.edge_i].from] = min(ans[all_edges[elem.edge_i].from], all_edges[elem.edge_i].value);
        }
        else {
            all_edges[elem.edge_i].value = ans[all_edges[elem.edge_i].to];
            if (all_edges[elem.edge_i].to == final_dest) {
                all_edges[elem.edge_i].value = all_edges[elem.edge_i].t2;
            }
        }
    }
    cout << res << "\n";
}

// g++ -DLC -o a a.cpp && ./a